--- /dev/null
+The documentation directory has been omitted from this copy of PCRE
+inside the httpd codebase because it's huge--over a megabyte of PCRE docs.
+
+The PCRE documentation directory is available in unmodified form in the
+vendor branch. You can access it via web browser or Subversion checkout at
+http://svn.apache.org/repos/asf/httpd/httpd/vendor/pcre/current/doc/
+++ /dev/null
-Technical Notes about PCRE
---------------------------
-
-Historical note 1
------------------
-
-Many years ago I implemented some regular expression functions to an algorithm
-suggested by Martin Richards. These were not Unix-like in form, and were quite
-restricted in what they could do by comparison with Perl. The interesting part
-about the algorithm was that the amount of space required to hold the compiled
-form of an expression was known in advance. The code to apply an expression did
-not operate by backtracking, as the original Henry Spencer code and current
-Perl code does, but instead checked all possibilities simultaneously by keeping
-a list of current states and checking all of them as it advanced through the
-subject string. In the terminology of Jeffrey Friedl's book, it was a "DFA
-algorithm". When the pattern was all used up, all remaining states were
-possible matches, and the one matching the longest subset of the subject string
-was chosen. This did not necessarily maximize the individual wild portions of
-the pattern, as is expected in Unix and Perl-style regular expressions.
-
-Historical note 2
------------------
-
-By contrast, the code originally written by Henry Spencer and subsequently
-heavily modified for Perl actually compiles the expression twice: once in a
-dummy mode in order to find out how much store will be needed, and then for
-real. The execution function operates by backtracking and maximizing (or,
-optionally, minimizing in Perl) the amount of the subject that matches
-individual wild portions of the pattern. This is an "NFA algorithm" in Friedl's
-terminology.
-
-OK, here's the real stuff
--------------------------
-
-For the set of functions that forms PCRE (which are unrelated to those
-mentioned above), I tried at first to invent an algorithm that used an amount
-of store bounded by a multiple of the number of characters in the pattern, to
-save on compiling time. However, because of the greater complexity in Perl
-regular expressions, I couldn't do this. In any case, a first pass through the
-pattern is needed, for a number of reasons. PCRE works by running a very
-degenerate first pass to calculate a maximum store size, and then a second pass
-to do the real compile - which may use a bit less than the predicted amount of
-store. The idea is that this is going to turn out faster because the first pass
-is degenerate and the second pass can just store stuff straight into the
-vector. It does make the compiling functions bigger, of course, but they have
-got quite big anyway to handle all the Perl stuff.
-
-The compiled form of a pattern is a vector of bytes, containing items of
-variable length. The first byte in an item is an opcode, and the length of the
-item is either implicit in the opcode or contained in the data bytes that
-follow it.
-
-In many cases below "two-byte" data values are specified. This is in fact just
-a default. PCRE can be compiled to use 3-byte or 4-byte values (impairing the
-performance). This is necessary only when patterns whose compiled length is
-greater than 64K are going to be processed. In this description, we assume the
-"normal" compilation options.
-
-A list of all the opcodes follows:
-
-Opcodes with no following data
-------------------------------
-
-These items are all just one byte long
-
- OP_END end of pattern
- OP_ANY match any character
- OP_ANYBYTE match any single byte, even in UTF-8 mode
- OP_SOD match start of data: \A
- OP_SOM, start of match (subject + offset): \G
- OP_CIRC ^ (start of data, or after \n in multiline)
- OP_NOT_WORD_BOUNDARY \W
- OP_WORD_BOUNDARY \w
- OP_NOT_DIGIT \D
- OP_DIGIT \d
- OP_NOT_WHITESPACE \S
- OP_WHITESPACE \s
- OP_NOT_WORDCHAR \W
- OP_WORDCHAR \w
- OP_EODN match end of data or \n at end: \Z
- OP_EOD match end of data: \z
- OP_DOLL $ (end of data, or before \n in multiline)
- OP_EXTUNI match an extended Unicode character
-
-
-Repeating single characters
----------------------------
-
-The common repeats (*, +, ?) when applied to a single character use the
-following opcodes:
-
- OP_STAR
- OP_MINSTAR
- OP_PLUS
- OP_MINPLUS
- OP_QUERY
- OP_MINQUERY
-
-In ASCII mode, these are two-byte items; in UTF-8 mode, the length is variable.
-Those with "MIN" in their name are the minimizing versions. Each is followed by
-the character that is to be repeated. Other repeats make use of
-
- OP_UPTO
- OP_MINUPTO
- OP_EXACT
-
-which are followed by a two-byte count (most significant first) and the
-repeated character. OP_UPTO matches from 0 to the given number. A repeat with a
-non-zero minimum and a fixed maximum is coded as an OP_EXACT followed by an
-OP_UPTO (or OP_MINUPTO).
-
-
-Repeating character types
--------------------------
-
-Repeats of things like \d are done exactly as for single characters, except
-that instead of a character, the opcode for the type is stored in the data
-byte. The opcodes are:
-
- OP_TYPESTAR
- OP_TYPEMINSTAR
- OP_TYPEPLUS
- OP_TYPEMINPLUS
- OP_TYPEQUERY
- OP_TYPEMINQUERY
- OP_TYPEUPTO
- OP_TYPEMINUPTO
- OP_TYPEEXACT
-
-
-Match by Unicode property
--------------------------
-
-OP_PROP and OP_NOTPROP are used for positive and negative matches of a
-character by testing its Unicode property (the \p and \P escape sequences).
-Each is followed by a single byte that encodes the desired property value.
-
-Repeats of these items use the OP_TYPESTAR etc. set of opcodes, followed by two
-bytes: OP_PROP or OP_NOTPROP and then the desired property value.
-
-
-Matching literal characters
----------------------------
-
-The OP_CHAR opcode is followed by a single character that is to be matched
-casefully. For caseless matching, OP_CHARNC is used. In UTF-8 mode, the
-character may be more than one byte long. (Earlier versions of PCRE used
-multi-character strings, but this was changed to allow some new features to be
-added.)
-
-
-Character classes
------------------
-
-If there is only one character, OP_CHAR or OP_CHARNC is used for a positive
-class, and OP_NOT for a negative one (that is, for something like [^a]).
-However, in UTF-8 mode, the use of OP_NOT applies only to characters with
-values < 128, because OP_NOT is confined to single bytes.
-
-Another set of repeating opcodes (OP_NOTSTAR etc.) are used for a repeated,
-negated, single-character class. The normal ones (OP_STAR etc.) are used for a
-repeated positive single-character class.
-
-When there's more than one character in a class and all the characters are less
-than 256, OP_CLASS is used for a positive class, and OP_NCLASS for a negative
-one. In either case, the opcode is followed by a 32-byte bit map containing a 1
-bit for every character that is acceptable. The bits are counted from the least
-significant end of each byte.
-
-The reason for having both OP_CLASS and OP_NCLASS is so that, in UTF-8 mode,
-subject characters with values greater than 256 can be handled correctly. For
-OP_CLASS they don't match, whereas for OP_NCLASS they do.
-
-For classes containing characters with values > 255, OP_XCLASS is used. It
-optionally uses a bit map (if any characters lie within it), followed by a list
-of pairs and single characters. There is a flag character than indicates
-whether it's a positive or a negative class.
-
-
-Back references
----------------
-
-OP_REF is followed by two bytes containing the reference number.
-
-
-Repeating character classes and back references
------------------------------------------------
-
-Single-character classes are handled specially (see above). This applies to
-OP_CLASS and OP_REF. In both cases, the repeat information follows the base
-item. The matching code looks at the following opcode to see if it is one of
-
- OP_CRSTAR
- OP_CRMINSTAR
- OP_CRPLUS
- OP_CRMINPLUS
- OP_CRQUERY
- OP_CRMINQUERY
- OP_CRRANGE
- OP_CRMINRANGE
-
-All but the last two are just single-byte items. The others are followed by
-four bytes of data, comprising the minimum and maximum repeat counts.
-
-
-Brackets and alternation
-------------------------
-
-A pair of non-capturing (round) brackets is wrapped round each expression at
-compile time, so alternation always happens in the context of brackets.
-
-Non-capturing brackets use the opcode OP_BRA, while capturing brackets use
-OP_BRA+1, OP_BRA+2, etc. [Note for North Americans: "bracket" to some English
-speakers, including myself, can be round, square, curly, or pointy. Hence this
-usage.]
-
-Originally PCRE was limited to 99 capturing brackets (so as not to use up all
-the opcodes). From release 3.5, there is no limit. What happens is that the
-first ones, up to EXTRACT_BASIC_MAX are handled with separate opcodes, as
-above. If there are more, the opcode is set to EXTRACT_BASIC_MAX+1, and the
-first operation in the bracket is OP_BRANUMBER, followed by a 2-byte bracket
-number. This opcode is ignored while matching, but is fished out when handling
-the bracket itself. (They could have all been done like this, but I was making
-minimal changes.)
-
-A bracket opcode is followed by two bytes which give the offset to the next
-alternative OP_ALT or, if there aren't any branches, to the matching OP_KET
-opcode. Each OP_ALT is followed by two bytes giving the offset to the next one,
-or to the OP_KET opcode.
-
-OP_KET is used for subpatterns that do not repeat indefinitely, while
-OP_KETRMIN and OP_KETRMAX are used for indefinite repetitions, minimally or
-maximally respectively. All three are followed by two bytes giving (as a
-positive number) the offset back to the matching OP_BRA opcode.
-
-If a subpattern is quantified such that it is permitted to match zero times, it
-is preceded by one of OP_BRAZERO or OP_BRAMINZERO. These are single-byte
-opcodes which tell the matcher that skipping this subpattern entirely is a
-valid branch.
-
-A subpattern with an indefinite maximum repetition is replicated in the
-compiled data its minimum number of times (or once with OP_BRAZERO if the
-minimum is zero), with the final copy terminating with OP_KETRMIN or OP_KETRMAX
-as appropriate.
-
-A subpattern with a bounded maximum repetition is replicated in a nested
-fashion up to the maximum number of times, with OP_BRAZERO or OP_BRAMINZERO
-before each replication after the minimum, so that, for example, (abc){2,5} is
-compiled as (abc)(abc)((abc)((abc)(abc)?)?)?.
-
-
-Assertions
-----------
-
-Forward assertions are just like other subpatterns, but starting with one of
-the opcodes OP_ASSERT or OP_ASSERT_NOT. Backward assertions use the opcodes
-OP_ASSERTBACK and OP_ASSERTBACK_NOT, and the first opcode inside the assertion
-is OP_REVERSE, followed by a two byte count of the number of characters to move
-back the pointer in the subject string. When operating in UTF-8 mode, the count
-is a character count rather than a byte count. A separate count is present in
-each alternative of a lookbehind assertion, allowing them to have different
-fixed lengths.
-
-
-Once-only subpatterns
----------------------
-
-These are also just like other subpatterns, but they start with the opcode
-OP_ONCE.
-
-
-Conditional subpatterns
------------------------
-
-These are like other subpatterns, but they start with the opcode OP_COND. If
-the condition is a back reference, this is stored at the start of the
-subpattern using the opcode OP_CREF followed by two bytes containing the
-reference number. If the condition is "in recursion" (coded as "(?(R)"), the
-same scheme is used, with a "reference number" of 0xffff. Otherwise, a
-conditional subpattern always starts with one of the assertions.
-
-
-Recursion
----------
-
-Recursion either matches the current regex, or some subexpression. The opcode
-OP_RECURSE is followed by an value which is the offset to the starting bracket
-from the start of the whole pattern.
-
-
-Callout
--------
-
-OP_CALLOUT is followed by one byte of data that holds a callout number in the
-range 0 to 254 for manual callouts, or 255 for an automatic callout. In both
-cases there follows a two-byte value giving the offset in the pattern to the
-start of the following item, and another two-byte item giving the length of the
-next item.
-
-
-Changing options
-----------------
-
-If any of the /i, /m, or /s options are changed within a pattern, an OP_OPT
-opcode is compiled, followed by one byte containing the new settings of these
-flags. If there are several alternatives, there is an occurrence of OP_OPT at
-the start of all those following the first options change, to set appropriate
-options for the start of the alternative. Immediately after the end of the
-group there is another such item to reset the flags to their previous values. A
-change of flag right at the very start of the pattern can be handled entirely
-at compile time, and so does not cause anything to be put into the compiled
-data.
-
-Philip Hazel
-September 2004
+++ /dev/null
-<html>
-<head>
-<title>PCRE specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>Perl-compatible Regular Expressions (PCRE)</h1>
-<p>
-The HTML documentation for PCRE comprises the following pages:
-</p>
-
-<table>
-<tr><td><a href="pcre.html">pcre</a></td>
- <td> Introductory page</td></tr>
-
-<tr><td><a href="pcreapi.html">pcreapi</a></td>
- <td> PCRE's native API</td></tr>
-
-<tr><td><a href="pcrebuild.html">pcrebuild</a></td>
- <td> Options for building PCRE</td></tr>
-
-<tr><td><a href="pcrecallout.html">pcrecallout</a></td>
- <td> The <i>callout</i> facility</td></tr>
-
-<tr><td><a href="pcrecompat.html">pcrecompat</a></td>
- <td> Compability with Perl</td></tr>
-
-<tr><td><a href="pcregrep.html">pcregrep</a></td>
- <td> The <b>pcregrep</b> command</td></tr>
-
-<tr><td><a href="pcrepartial.html">pcrepartial</a></td>
- <td> Using PCRE for partial matching</td></tr>
-
-<tr><td><a href="pcrepattern.html">pcrepattern</a></td>
- <td> Specification of the regular expressions supported by PCRE</td></tr>
-
-<tr><td><a href="pcreperform.html">pcreperform</a></td>
- <td> Some comments on performance</td></tr>
-
-<tr><td><a href="pcreposix.html">pcreposix</a></td>
- <td> The POSIX API to the PCRE library</td></tr>
-
-<tr><td><a href="pcreprecompile.html">pcreprecompile</a></td>
- <td> How to save and re-use compiled patterns</td></tr>
-
-<tr><td><a href="pcresample.html">pcresample</a></td>
- <td> Description of the sample program</td></tr>
-
-<tr><td><a href="pcretest.html">pcretest</a></td>
- <td> The <b>pcretest</b> command for testing PCRE</td></tr>
-</table>
-
-<p>
-There are also individual pages that summarize the interface for each function
-in the library:
-</p>
-
-<table>
-
-<tr><td><a href="pcre_compile.html">pcre_compile</a></td>
- <td> Compile a regular expression</td></tr>
-
-<tr><td><a href="pcre_config.html">pcre_config</a></td>
- <td> Show build-time configuration options</td></tr>
-
-<tr><td><a href="pcre_copy_named_substring.html">pcre_copy_named_substring</a></td>
- <td> Extract named substring into given buffer</td></tr>
-
-<tr><td><a href="pcre_copy_substring.html">pcre_copy_substring</a></td>
- <td> Extract numbered substring into given buffer</td></tr>
-
-<tr><td><a href="pcre_exec.html">pcre_exec</a></td>
- <td> Match a compiled pattern to a subject string</td></tr>
-
-<tr><td><a href="pcre_free_substring.html">pcre_free_substring</a></td>
- <td> Free extracted substring</td></tr>
-
-<tr><td><a href="pcre_free_substring_list.html">pcre_free_substring_list</a></td>
- <td> Free list of extracted substrings</td></tr>
-
-<tr><td><a href="pcre_fullinfo.html">pcre_fullinfo</a></td>
- <td> Extract information about a pattern</td></tr>
-
-<tr><td><a href="pcre_get_named_substring.html">pcre_get_named_substring</a></td>
- <td> Extract named substring into new memory</td></tr>
-
-<tr><td><a href="pcre_get_stringnumber.html">pcre_get_stringnumber</a></td>
- <td> Convert captured string name to number</td></tr>
-
-<tr><td><a href="pcre_get_substring.html">pcre_get_substring</a></td>
- <td> Extract numbered substring into new memory</td></tr>
-
-<tr><td><a href="pcre_get_substring_list.html">pcre_get_substring_list</a></td>
- <td> Extract all substrings into new memory</td></tr>
-
-<tr><td><a href="pcre_info.html">pcre_info</a></td>
- <td> Obsolete information extraction function</td></tr>
-
-<tr><td><a href="pcre_maketables.html">pcre_maketables</a></td>
- <td> Build character tables in current locale</td></tr>
-
-<tr><td><a href="pcre_study.html">pcre_study</a></td>
- <td> Study a compiled pattern</td></tr>
-
-<tr><td><a href="pcre_version.html">pcre_version</a></td>
- <td> Return PCRE version and release date</td></tr>
-</table>
-
-</html>
+++ /dev/null
-<html>
-<head>
-<title>pcre specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<ul>
-<li><a name="TOC1" href="#SEC1">INTRODUCTION</a>
-<li><a name="TOC2" href="#SEC2">USER DOCUMENTATION</a>
-<li><a name="TOC3" href="#SEC3">LIMITATIONS</a>
-<li><a name="TOC4" href="#SEC4">UTF-8 AND UNICODE PROPERTY SUPPORT</a>
-<li><a name="TOC5" href="#SEC5">AUTHOR</a>
-</ul>
-<br><a name="SEC1" href="#TOC1">INTRODUCTION</a><br>
-<P>
-The PCRE library is a set of functions that implement regular expression
-pattern matching using the same syntax and semantics as Perl, with just a few
-differences. The current implementation of PCRE (release 5.x) corresponds
-approximately with Perl 5.8, including support for UTF-8 encoded strings and
-Unicode general category properties. However, this support has to be explicitly
-enabled; it is not the default.
-</P>
-<P>
-PCRE is written in C and released as a C library. A number of people have
-written wrappers and interfaces of various kinds. A C++ class is included in
-these contributions, which can be found in the <i>Contrib</i> directory at the
-primary FTP site, which is:
-<a href="ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre">ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre</a>
-</P>
-<P>
-Details of exactly which Perl regular expression features are and are not
-supported by PCRE are given in separate documents. See the
-<a href="pcrepattern.html"><b>pcrepattern</b></a>
-and
-<a href="pcrecompat.html"><b>pcrecompat</b></a>
-pages.
-</P>
-<P>
-Some features of PCRE can be included, excluded, or changed when the library is
-built. The
-<a href="pcre_config.html"><b>pcre_config()</b></a>
-function makes it possible for a client to discover which features are
-available. The features themselves are described in the
-<a href="pcrebuild.html"><b>pcrebuild</b></a>
-page. Documentation about building PCRE for various operating systems can be
-found in the <b>README</b> file in the source distribution.
-</P>
-<br><a name="SEC2" href="#TOC1">USER DOCUMENTATION</a><br>
-<P>
-The user documentation for PCRE comprises a number of different sections. In
-the "man" format, each of these is a separate "man page". In the HTML format,
-each is a separate page, linked from the index page. In the plain text format,
-all the sections are concatenated, for ease of searching. The sections are as
-follows:
-<pre>
- pcre this document
- pcreapi details of PCRE's native API
- pcrebuild options for building PCRE
- pcrecallout details of the callout feature
- pcrecompat discussion of Perl compatibility
- pcregrep description of the <b>pcregrep</b> command
- pcrepartial details of the partial matching facility
- pcrepattern syntax and semantics of supported regular expressions
- pcreperform discussion of performance issues
- pcreposix the POSIX-compatible API
- pcreprecompile details of saving and re-using precompiled patterns
- pcresample discussion of the sample program
- pcretest description of the <b>pcretest</b> testing command
-</pre>
-In addition, in the "man" and HTML formats, there is a short page for each
-library function, listing its arguments and results.
-</P>
-<br><a name="SEC3" href="#TOC1">LIMITATIONS</a><br>
-<P>
-There are some size limitations in PCRE but it is hoped that they will never in
-practice be relevant.
-</P>
-<P>
-The maximum length of a compiled pattern is 65539 (sic) bytes if PCRE is
-compiled with the default internal linkage size of 2. If you want to process
-regular expressions that are truly enormous, you can compile PCRE with an
-internal linkage size of 3 or 4 (see the <b>README</b> file in the source
-distribution and the
-<a href="pcrebuild.html"><b>pcrebuild</b></a>
-documentation for details). In these cases the limit is substantially larger.
-However, the speed of execution will be slower.
-</P>
-<P>
-All values in repeating quantifiers must be less than 65536.
-The maximum number of capturing subpatterns is 65535.
-</P>
-<P>
-There is no limit to the number of non-capturing subpatterns, but the maximum
-depth of nesting of all kinds of parenthesized subpattern, including capturing
-subpatterns, assertions, and other types of subpattern, is 200.
-</P>
-<P>
-The maximum length of a subject string is the largest positive number that an
-integer variable can hold. However, PCRE uses recursion to handle subpatterns
-and indefinite repetition. This means that the available stack space may limit
-the size of a subject string that can be processed by certain patterns.
-<a name="utf8support"></a></P>
-<br><a name="SEC4" href="#TOC1">UTF-8 AND UNICODE PROPERTY SUPPORT</a><br>
-<P>
-From release 3.3, PCRE has had some support for character strings encoded in
-the UTF-8 format. For release 4.0 this was greatly extended to cover most
-common requirements, and in release 5.0 additional support for Unicode general
-category properties was added.
-</P>
-<P>
-In order process UTF-8 strings, you must build PCRE to include UTF-8 support in
-the code, and, in addition, you must call
-<a href="pcre_compile.html"><b>pcre_compile()</b></a>
-with the PCRE_UTF8 option flag. When you do this, both the pattern and any
-subject strings that are matched against it are treated as UTF-8 strings
-instead of just strings of bytes.
-</P>
-<P>
-If you compile PCRE with UTF-8 support, but do not use it at run time, the
-library will be a bit bigger, but the additional run time overhead is limited
-to testing the PCRE_UTF8 flag in several places, so should not be very large.
-</P>
-<P>
-If PCRE is built with Unicode character property support (which implies UTF-8
-support), the escape sequences \p{..}, \P{..}, and \X are supported.
-The available properties that can be tested are limited to the general
-category properties such as Lu for an upper case letter or Nd for a decimal
-number. A full list is given in the
-<a href="pcrepattern.html"><b>pcrepattern</b></a>
-documentation. The PCRE library is increased in size by about 90K when Unicode
-property support is included.
-</P>
-<P>
-The following comments apply when PCRE is running in UTF-8 mode:
-</P>
-<P>
-1. When you set the PCRE_UTF8 flag, the strings passed as patterns and subjects
-are checked for validity on entry to the relevant functions. If an invalid
-UTF-8 string is passed, an error return is given. In some situations, you may
-already know that your strings are valid, and therefore want to skip these
-checks in order to improve performance. If you set the PCRE_NO_UTF8_CHECK flag
-at compile time or at run time, PCRE assumes that the pattern or subject it
-is given (respectively) contains only valid UTF-8 codes. In this case, it does
-not diagnose an invalid UTF-8 string. If you pass an invalid UTF-8 string to
-PCRE when PCRE_NO_UTF8_CHECK is set, the results are undefined. Your program
-may crash.
-</P>
-<P>
-2. In a pattern, the escape sequence \x{...}, where the contents of the braces
-is a string of hexadecimal digits, is interpreted as a UTF-8 character whose
-code number is the given hexadecimal number, for example: \x{1234}. If a
-non-hexadecimal digit appears between the braces, the item is not recognized.
-This escape sequence can be used either as a literal, or within a character
-class.
-</P>
-<P>
-3. The original hexadecimal escape sequence, \xhh, matches a two-byte UTF-8
-character if the value is greater than 127.
-</P>
-<P>
-4. Repeat quantifiers apply to complete UTF-8 characters, not to individual
-bytes, for example: \x{100}{3}.
-</P>
-<P>
-5. The dot metacharacter matches one UTF-8 character instead of a single byte.
-</P>
-<P>
-6. The escape sequence \C can be used to match a single byte in UTF-8 mode,
-but its use can lead to some strange effects.
-</P>
-<P>
-7. The character escapes \b, \B, \d, \D, \s, \S, \w, and \W correctly
-test characters of any code value, but the characters that PCRE recognizes as
-digits, spaces, or word characters remain the same set as before, all with
-values less than 256. This remains true even when PCRE includes Unicode
-property support, because to do otherwise would slow down PCRE in many common
-cases. If you really want to test for a wider sense of, say, "digit", you
-must use Unicode property tests such as \p{Nd}.
-</P>
-<P>
-8. Similarly, characters that match the POSIX named character classes are all
-low-valued characters.
-</P>
-<P>
-9. Case-insensitive matching applies only to characters whose values are less
-than 128, unless PCRE is built with Unicode property support. Even when Unicode
-property support is available, PCRE still uses its own character tables when
-checking the case of low-valued characters, so as not to degrade performance.
-The Unicode property information is used only for characters with higher
-values.
-</P>
-<br><a name="SEC5" href="#TOC1">AUTHOR</a><br>
-<P>
-Philip Hazel <ph10@cam.ac.uk>
-<br>
-University Computing Service,
-<br>
-Cambridge CB2 3QG, England.
-<br>
-Phone: +44 1223 334714
-Last updated: 09 September 2004
-<br>
-Copyright © 1997-2004 University of Cambridge.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_compile specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_compile man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>pcre *pcre_compile(const char *<i>pattern</i>, int <i>options</i>,</b>
-<b>const char **<i>errptr</i>, int *<i>erroffset</i>,</b>
-<b>const unsigned char *<i>tableptr</i>);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This function compiles a regular expression into an internal form. Its
-arguments are:
-<pre>
- <i>pattern</i> A zero-terminated string containing the
- regular expression to be compiled
- <i>options</i> Zero or more option bits
- <i>errptr</i> Where to put an error message
- <i>erroffset</i> Offset in pattern where error was found
- <i>tableptr</i> Pointer to character tables, or NULL to
- use the built-in default
-</pre>
-The option bits are:
-<pre>
- PCRE_ANCHORED Force pattern anchoring
- PCRE_AUTO_CALLOUT Compile automatic callouts
- PCRE_CASELESS Do caseless matching
- PCRE_DOLLAR_ENDONLY $ not to match newline at end
- PCRE_DOTALL . matches anything including NL
- PCRE_EXTENDED Ignore whitespace and # comments
- PCRE_EXTRA PCRE extra features
- (not much use currently)
- PCRE_MULTILINE ^ and $ match newlines within data
- PCRE_NO_AUTO_CAPTURE Disable numbered capturing paren-
- theses (named ones available)
- PCRE_UNGREEDY Invert greediness of quantifiers
- PCRE_UTF8 Run in UTF-8 mode
- PCRE_NO_UTF8_CHECK Do not check the pattern for UTF-8
- validity (only relevant if
- PCRE_UTF8 is set)
-</pre>
-PCRE must be built with UTF-8 support in order to use PCRE_UTF8 and
-PCRE_NO_UTF8_CHECK.
-</P>
-<P>
-The yield of the function is a pointer to a private data structure that
-contains the compiled pattern, or NULL if an error was detected.
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_config specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_config man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>int pcre_config(int <i>what</i>, void *<i>where</i>);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This function makes it possible for a client program to find out which optional
-features are available in the version of the PCRE library it is using. Its
-arguments are as follows:
-<pre>
- <i>what</i> A code specifying what information is required
- <i>where</i> Points to where to put the data
-</pre>
-The available codes are:
-<pre>
- PCRE_CONFIG_LINK_SIZE Internal link size: 2, 3, or 4
- PCRE_CONFIG_MATCH_LIMIT Internal resource limit
- PCRE_CONFIG_NEWLINE Value of the newline character
- PCRE_CONFIG_POSIX_MALLOC_THRESHOLD
- Threshold of return slots, above
- which <b>malloc()</b> is used by
- the POSIX API
- PCRE_CONFIG_STACKRECURSE Recursion implementation (1=stack 0=heap)
- PCRE_CONFIG_UTF8 Availability of UTF-8 support (1=yes 0=no)
- PCRE_CONFIG_UNICODE_PROPERTIES
- Availability of Unicode property support
- (1=yes 0=no)
-</pre>
-The function yields 0 on success or PCRE_ERROR_BADOPTION otherwise.
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_copy_named_substring specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_copy_named_substring man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>int pcre_copy_named_substring(const pcre *<i>code</i>,</b>
-<b>const char *<i>subject</i>, int *<i>ovector</i>,</b>
-<b>int <i>stringcount</i>, const char *<i>stringname</i>,</b>
-<b>char *<i>buffer</i>, int <i>buffersize</i>);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This is a convenience function for extracting a captured substring, identified
-by name, into a given buffer. The arguments are:
-<pre>
- <i>code</i> Pattern that was successfully matched
- <i>subject</i> Subject that has been successfully matched
- <i>ovector</i> Offset vector that <b>pcre_exec()</b> used
- <i>stringcount</i> Value returned by <b>pcre_exec()</b>
- <i>stringname</i> Name of the required substring
- <i>buffer</i> Buffer to receive the string
- <i>buffersize</i> Size of buffer
-</pre>
-The yield is the length of the substring, PCRE_ERROR_NOMEMORY if the buffer was
-too small, or PCRE_ERROR_NOSUBSTRING if the string name is invalid.
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_copy_substring specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_copy_substring man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>int pcre_copy_substring(const char *<i>subject</i>, int *<i>ovector</i>,</b>
-<b>int <i>stringcount</i>, int <i>stringnumber</i>, char *<i>buffer</i>,</b>
-<b>int <i>buffersize</i>);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This is a convenience function for extracting a captured substring into a given
-buffer. The arguments are:
-<pre>
- <i>subject</i> Subject that has been successfully matched
- <i>ovector</i> Offset vector that <b>pcre_exec()</b> used
- <i>stringcount</i> Value returned by <b>pcre_exec()</b>
- <i>stringnumber</i> Number of the required substring
- <i>buffer</i> Buffer to receive the string
- <i>buffersize</i> Size of buffer
-</pre>
-The yield is the legnth of the string, PCRE_ERROR_NOMEMORY if the buffer was
-too small, or PCRE_ERROR_NOSUBSTRING if the string number is invalid.
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_exec specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_exec man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>int pcre_exec(const pcre *<i>code</i>, const pcre_extra *<i>extra</i>,</b>
-<b>const char *<i>subject</i>, int <i>length</i>, int <i>startoffset</i>,</b>
-<b>int <i>options</i>, int *<i>ovector</i>, int <i>ovecsize</i>);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This function matches a compiled regular expression against a given subject
-string, and returns offsets to capturing subexpressions. Its arguments are:
-<pre>
- <i>code</i> Points to the compiled pattern
- <i>extra</i> Points to an associated <b>pcre_extra</b> structure,
- or is NULL
- <i>subject</i> Points to the subject string
- <i>length</i> Length of the subject string, in bytes
- <i>startoffset</i> Offset in bytes in the subject at which to
- start matching
- <i>options</i> Option bits
- <i>ovector</i> Points to a vector of ints for result offsets
- <i>ovecsize</i> Number of elements in the vector (a multiple of 3)
-</pre>
-The options are:
-<pre>
- PCRE_ANCHORED Match only at the first position
- PCRE_NOTBOL Subject is not the beginning of a line
- PCRE_NOTEOL Subject is not the end of a line
- PCRE_NOTEMPTY An empty string is not a valid match
- PCRE_NO_UTF8_CHECK Do not check the subject for UTF-8
- validity (only relevant if PCRE_UTF8
- was set at compile time)
- PCRE_PARTIAL Return PCRE_ERROR_PARTIAL for a partial match
-</pre>
-There are restrictions on what may appear in a pattern when partial matching is
-requested.
-</P>
-<P>
-A <b>pcre_extra</b> structure contains the following fields:
-<pre>
- <i>flags</i> Bits indicating which fields are set
- <i>study_data</i> Opaque data from <b>pcre_study()</b>
- <i>match_limit</i> Limit on internal recursion
- <i>callout_data</i> Opaque data passed back to callouts
- <i>tables</i> Points to character tables or is NULL
-</pre>
-The flag bits are PCRE_EXTRA_STUDY_DATA, PCRE_EXTRA_MATCH_LIMIT,
-PCRE_EXTRA_CALLOUT_DATA, and PCRE_EXTRA_TABLES.
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_free_substring specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_free_substring man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>void pcre_free_substring(const char *<i>stringptr</i>);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This is a convenience function for freeing the store obtained by a previous
-call to <b>pcre_get_substring()</b> or <b>pcre_get_named_substring()</b>. Its
-only argument is a pointer to the string.
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_free_substring_list specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_free_substring_list man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>void pcre_free_substring_list(const char **<i>stringptr</i>);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This is a convenience function for freeing the store obtained by a previous
-call to <b>pcre_get_substring_list()</b>. Its only argument is a pointer to the
-list of string pointers.
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_fullinfo specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_fullinfo man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>int pcre_fullinfo(const pcre *<i>code</i>, const pcre_extra *<i>extra</i>,</b>
-<b>int <i>what</i>, void *<i>where</i>);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This function returns information about a compiled pattern. Its arguments are:
-<pre>
- <i>code</i> Compiled regular expression
- <i>extra</i> Result of <b>pcre_study()</b> or NULL
- <i>what</i> What information is required
- <i>where</i> Where to put the information
-</pre>
-The following information is available:
-<pre>
- PCRE_INFO_BACKREFMAX Number of highest back reference
- PCRE_INFO_CAPTURECOUNT Number of capturing subpatterns
- PCRE_INFO_DEFAULT_TABLES Pointer to default tables
- PCRE_INFO_FIRSTBYTE Fixed first byte for a match, or
- -1 for start of string
- or after newline, or
- -2 otherwise
- PCRE_INFO_FIRSTTABLE Table of first bytes
- (after studying)
- PCRE_INFO_LASTLITERAL Literal last byte required
- PCRE_INFO_NAMECOUNT Number of named subpatterns
- PCRE_INFO_NAMEENTRYSIZE Size of name table entry
- PCRE_INFO_NAMETABLE Pointer to name table
- PCRE_INFO_OPTIONS Options used for compilation
- PCRE_INFO_SIZE Size of compiled pattern
- PCRE_INFO_STUDYSIZE Size of study data
-</pre>
-The yield of the function is zero on success or:
-<pre>
- PCRE_ERROR_NULL the argument <i>code</i> was NULL
- the argument <i>where</i> was NULL
- PCRE_ERROR_BADMAGIC the "magic number" was not found
- PCRE_ERROR_BADOPTION the value of <i>what</i> was invalid
-</PRE>
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_get_named_substring specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_get_named_substring man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>int pcre_get_named_substring(const pcre *<i>code</i>,</b>
-<b>const char *<i>subject</i>, int *<i>ovector</i>,</b>
-<b>int <i>stringcount</i>, const char *<i>stringname</i>,</b>
-<b>const char **<i>stringptr</i>);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This is a convenience function for extracting a captured substring by name. The
-arguments are:
-<pre>
- <i>code</i> Compiled pattern
- <i>subject</i> Subject that has been successfully matched
- <i>ovector</i> Offset vector that <b>pcre_exec()</b> used
- <i>stringcount</i> Value returned by <b>pcre_exec()</b>
- <i>stringname</i> Name of the required substring
- <i>stringptr</i> Where to put the string pointer
-</pre>
-The memory in which the substring is placed is obtained by calling
-<b>pcre_malloc()</b>. The yield of the function is the length of the extracted
-substring, PCRE_ERROR_NOMEMORY if sufficient memory could not be obtained, or
-PCRE_ERROR_NOSUBSTRING if the string name is invalid.
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_get_stringnumber specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_get_stringnumber man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>int pcre_get_stringnumber(const pcre *<i>code</i>,</b>
-<b>const char *<i>name</i>);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This convenience function finds the number of a named substring capturing
-parenthesis in a compiled pattern. Its arguments are:
-<pre>
- <i>code</i> Compiled regular expression
- <i>name</i> Name whose number is required
-</pre>
-The yield of the function is the number of the parenthesis if the name is
-found, or PCRE_ERROR_NOSUBSTRING otherwise.
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_get_substring specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_get_substring man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>int pcre_get_substring(const char *<i>subject</i>, int *<i>ovector</i>,</b>
-<b>int <i>stringcount</i>, int <i>stringnumber</i>,</b>
-<b>const char **<i>stringptr</i>);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This is a convenience function for extracting a captured substring. The
-arguments are:
-<pre>
- <i>subject</i> Subject that has been successfully matched
- <i>ovector</i> Offset vector that <b>pcre_exec()</b> used
- <i>stringcount</i> Value returned by <b>pcre_exec()</b>
- <i>stringnumber</i> Number of the required substring
- <i>stringptr</i> Where to put the string pointer
-</pre>
-The memory in which the substring is placed is obtained by calling
-<b>pcre_malloc()</b>. The yield of the function is the length of the substring,
-PCRE_ERROR_NOMEMORY if sufficient memory could not be obtained, or
-PCRE_ERROR_NOSUBSTRING if the string number is invalid.
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_get_substring_list specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_get_substring_list man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>int pcre_get_substring_list(const char *<i>subject</i>,</b>
-<b>int *<i>ovector</i>, int <i>stringcount</i>, const char ***<i>listptr</i>);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This is a convenience function for extracting a list of all the captured
-substrings. The arguments are:
-<pre>
- <i>subject</i> Subject that has been successfully matched
- <i>ovector</i> Offset vector that <b>pcre_exec</b> used
- <i>stringcount</i> Value returned by <b>pcre_exec</b>
- <i>listptr</i> Where to put a pointer to the list
-</pre>
-The memory in which the substrings and the list are placed is obtained by
-calling <b>pcre_malloc()</b>. A pointer to a list of pointers is put in
-the variable whose address is in <i>listptr</i>. The list is terminated by a
-NULL pointer. The yield of the function is zero on success or
-PCRE_ERROR_NOMEMORY if sufficient memory could not be obtained.
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_info specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_info man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>int pcre_info(const pcre *<i>code</i>, int *<i>optptr</i>, int</b>
-<b>*<i>firstcharptr</i>);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This function is obsolete. You should be using <b>pcre_fullinfo()</b> instead.
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_maketables specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_maketables man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>const unsigned char *pcre_maketables(void);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This function builds a set of character tables for character values less than
-256. These can be passed to <b>pcre_compile()</b> to override PCRE's internal,
-built-in tables (which were made by <b>pcre_maketables()</b> when PCRE was
-compiled). You might want to do this if you are using a non-standard locale.
-The function yields a pointer to the tables.
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_study specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_study man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>pcre_extra *pcre_study(const pcre *<i>code</i>, int <i>options</i>,</b>
-<b>const char **<i>errptr</i>);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This function studies a compiled pattern, to see if additional information can
-be extracted that might speed up matching. Its arguments are:
-<pre>
- <i>code</i> A compiled regular expression
- <i>options</i> Options for <b>pcre_study()</b>
- <i>errptr</i> Where to put an error message
-</pre>
-If the function succeeds, it returns a value that can be passed to
-<b>pcre_exec()</b> via its <i>extra</i> argument.
-</P>
-<P>
-If the function returns NULL, either it could not find any additional
-information, or there was an error. You can tell the difference by looking at
-the error value. It is NULL in first case.
-</P>
-<P>
-There are currently no options defined; the value of the second argument should
-always be zero.
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcre_version specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcre_version man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-SYNOPSIS
-</b><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>char *pcre_version(void);</b>
-</P>
-<br><b>
-DESCRIPTION
-</b><br>
-<P>
-This function returns a character string that gives the version number of the
-PCRE library and the date of its release.
-</P>
-<P>
-There is a complete description of the PCRE native API in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page and a description of the POSIX API in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-page.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcreapi specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcreapi man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<ul>
-<li><a name="TOC1" href="#SEC1">PCRE NATIVE API</a>
-<li><a name="TOC2" href="#SEC2">PCRE API OVERVIEW</a>
-<li><a name="TOC3" href="#SEC3">MULTITHREADING</a>
-<li><a name="TOC4" href="#SEC4">SAVING PRECOMPILED PATTERNS FOR LATER USE</a>
-<li><a name="TOC5" href="#SEC5">CHECKING BUILD-TIME OPTIONS</a>
-<li><a name="TOC6" href="#SEC6">COMPILING A PATTERN</a>
-<li><a name="TOC7" href="#SEC7">STUDYING A PATTERN</a>
-<li><a name="TOC8" href="#SEC8">LOCALE SUPPORT</a>
-<li><a name="TOC9" href="#SEC9">INFORMATION ABOUT A PATTERN</a>
-<li><a name="TOC10" href="#SEC10">OBSOLETE INFO FUNCTION</a>
-<li><a name="TOC11" href="#SEC11">MATCHING A PATTERN</a>
-<li><a name="TOC12" href="#SEC12">EXTRACTING CAPTURED SUBSTRINGS BY NUMBER</a>
-<li><a name="TOC13" href="#SEC13">EXTRACTING CAPTURED SUBSTRINGS BY NAME</a>
-</ul>
-<br><a name="SEC1" href="#TOC1">PCRE NATIVE API</a><br>
-<P>
-<b>#include <pcre.h></b>
-</P>
-<P>
-<b>pcre *pcre_compile(const char *<i>pattern</i>, int <i>options</i>,</b>
-<b>const char **<i>errptr</i>, int *<i>erroffset</i>,</b>
-<b>const unsigned char *<i>tableptr</i>);</b>
-</P>
-<P>
-<b>pcre_extra *pcre_study(const pcre *<i>code</i>, int <i>options</i>,</b>
-<b>const char **<i>errptr</i>);</b>
-</P>
-<P>
-<b>int pcre_exec(const pcre *<i>code</i>, const pcre_extra *<i>extra</i>,</b>
-<b>const char *<i>subject</i>, int <i>length</i>, int <i>startoffset</i>,</b>
-<b>int <i>options</i>, int *<i>ovector</i>, int <i>ovecsize</i>);</b>
-</P>
-<P>
-<b>int pcre_copy_named_substring(const pcre *<i>code</i>,</b>
-<b>const char *<i>subject</i>, int *<i>ovector</i>,</b>
-<b>int <i>stringcount</i>, const char *<i>stringname</i>,</b>
-<b>char *<i>buffer</i>, int <i>buffersize</i>);</b>
-</P>
-<P>
-<b>int pcre_copy_substring(const char *<i>subject</i>, int *<i>ovector</i>,</b>
-<b>int <i>stringcount</i>, int <i>stringnumber</i>, char *<i>buffer</i>,</b>
-<b>int <i>buffersize</i>);</b>
-</P>
-<P>
-<b>int pcre_get_named_substring(const pcre *<i>code</i>,</b>
-<b>const char *<i>subject</i>, int *<i>ovector</i>,</b>
-<b>int <i>stringcount</i>, const char *<i>stringname</i>,</b>
-<b>const char **<i>stringptr</i>);</b>
-</P>
-<P>
-<b>int pcre_get_stringnumber(const pcre *<i>code</i>,</b>
-<b>const char *<i>name</i>);</b>
-</P>
-<P>
-<b>int pcre_get_substring(const char *<i>subject</i>, int *<i>ovector</i>,</b>
-<b>int <i>stringcount</i>, int <i>stringnumber</i>,</b>
-<b>const char **<i>stringptr</i>);</b>
-</P>
-<P>
-<b>int pcre_get_substring_list(const char *<i>subject</i>,</b>
-<b>int *<i>ovector</i>, int <i>stringcount</i>, const char ***<i>listptr</i>);</b>
-</P>
-<P>
-<b>void pcre_free_substring(const char *<i>stringptr</i>);</b>
-</P>
-<P>
-<b>void pcre_free_substring_list(const char **<i>stringptr</i>);</b>
-</P>
-<P>
-<b>const unsigned char *pcre_maketables(void);</b>
-</P>
-<P>
-<b>int pcre_fullinfo(const pcre *<i>code</i>, const pcre_extra *<i>extra</i>,</b>
-<b>int <i>what</i>, void *<i>where</i>);</b>
-</P>
-<P>
-<b>int pcre_info(const pcre *<i>code</i>, int *<i>optptr</i>, int</b>
-<b>*<i>firstcharptr</i>);</b>
-</P>
-<P>
-<b>int pcre_config(int <i>what</i>, void *<i>where</i>);</b>
-</P>
-<P>
-<b>char *pcre_version(void);</b>
-</P>
-<P>
-<b>void *(*pcre_malloc)(size_t);</b>
-</P>
-<P>
-<b>void (*pcre_free)(void *);</b>
-</P>
-<P>
-<b>void *(*pcre_stack_malloc)(size_t);</b>
-</P>
-<P>
-<b>void (*pcre_stack_free)(void *);</b>
-</P>
-<P>
-<b>int (*pcre_callout)(pcre_callout_block *);</b>
-</P>
-<br><a name="SEC2" href="#TOC1">PCRE API OVERVIEW</a><br>
-<P>
-PCRE has its own native API, which is described in this document. There is also
-a set of wrapper functions that correspond to the POSIX regular expression API.
-These are described in the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-documentation.
-</P>
-<P>
-The native API function prototypes are defined in the header file <b>pcre.h</b>,
-and on Unix systems the library itself is called <b>libpcre</b>. It can
-normally be accessed by adding <b>-lpcre</b> to the command for linking an
-application that uses PCRE. The header file defines the macros PCRE_MAJOR and
-PCRE_MINOR to contain the major and minor release numbers for the library.
-Applications can use these to include support for different releases of PCRE.
-</P>
-<P>
-The functions <b>pcre_compile()</b>, <b>pcre_study()</b>, and <b>pcre_exec()</b>
-are used for compiling and matching regular expressions. A sample program that
-demonstrates the simplest way of using them is provided in the file called
-<i>pcredemo.c</i> in the source distribution. The
-<a href="pcresample.html"><b>pcresample</b></a>
-documentation describes how to run it.
-</P>
-<P>
-In addition to the main compiling and matching functions, there are convenience
-functions for extracting captured substrings from a matched subject string.
-They are:
-<pre>
- <b>pcre_copy_substring()</b>
- <b>pcre_copy_named_substring()</b>
- <b>pcre_get_substring()</b>
- <b>pcre_get_named_substring()</b>
- <b>pcre_get_substring_list()</b>
- <b>pcre_get_stringnumber()</b>
-</pre>
-<b>pcre_free_substring()</b> and <b>pcre_free_substring_list()</b> are also
-provided, to free the memory used for extracted strings.
-</P>
-<P>
-The function <b>pcre_maketables()</b> is used to build a set of character tables
-in the current locale for passing to <b>pcre_compile()</b> or <b>pcre_exec()</b>.
-This is an optional facility that is provided for specialist use. Most
-commonly, no special tables are passed, in which case internal tables that are
-generated when PCRE is built are used.
-</P>
-<P>
-The function <b>pcre_fullinfo()</b> is used to find out information about a
-compiled pattern; <b>pcre_info()</b> is an obsolete version that returns only
-some of the available information, but is retained for backwards compatibility.
-The function <b>pcre_version()</b> returns a pointer to a string containing the
-version of PCRE and its date of release.
-</P>
-<P>
-The global variables <b>pcre_malloc</b> and <b>pcre_free</b> initially contain
-the entry points of the standard <b>malloc()</b> and <b>free()</b> functions,
-respectively. PCRE calls the memory management functions via these variables,
-so a calling program can replace them if it wishes to intercept the calls. This
-should be done before calling any PCRE functions.
-</P>
-<P>
-The global variables <b>pcre_stack_malloc</b> and <b>pcre_stack_free</b> are also
-indirections to memory management functions. These special functions are used
-only when PCRE is compiled to use the heap for remembering data, instead of
-recursive function calls. This is a non-standard way of building PCRE, for use
-in environments that have limited stacks. Because of the greater use of memory
-management, it runs more slowly. Separate functions are provided so that
-special-purpose external code can be used for this case. When used, these
-functions are always called in a stack-like manner (last obtained, first
-freed), and always for memory blocks of the same size.
-</P>
-<P>
-The global variable <b>pcre_callout</b> initially contains NULL. It can be set
-by the caller to a "callout" function, which PCRE will then call at specified
-points during a matching operation. Details are given in the
-<a href="pcrecallout.html"><b>pcrecallout</b></a>
-documentation.
-</P>
-<br><a name="SEC3" href="#TOC1">MULTITHREADING</a><br>
-<P>
-The PCRE functions can be used in multi-threading applications, with the
-proviso that the memory management functions pointed to by <b>pcre_malloc</b>,
-<b>pcre_free</b>, <b>pcre_stack_malloc</b>, and <b>pcre_stack_free</b>, and the
-callout function pointed to by <b>pcre_callout</b>, are shared by all threads.
-</P>
-<P>
-The compiled form of a regular expression is not altered during matching, so
-the same compiled pattern can safely be used by several threads at once.
-</P>
-<br><a name="SEC4" href="#TOC1">SAVING PRECOMPILED PATTERNS FOR LATER USE</a><br>
-<P>
-The compiled form of a regular expression can be saved and re-used at a later
-time, possibly by a different program, and even on a host other than the one on
-which it was compiled. Details are given in the
-<a href="pcreprecompile.html"><b>pcreprecompile</b></a>
-documentation.
-</P>
-<br><a name="SEC5" href="#TOC1">CHECKING BUILD-TIME OPTIONS</a><br>
-<P>
-<b>int pcre_config(int <i>what</i>, void *<i>where</i>);</b>
-</P>
-<P>
-The function <b>pcre_config()</b> makes it possible for a PCRE client to
-discover which optional features have been compiled into the PCRE library. The
-<a href="pcrebuild.html"><b>pcrebuild</b></a>
-documentation has more details about these optional features.
-</P>
-<P>
-The first argument for <b>pcre_config()</b> is an integer, specifying which
-information is required; the second argument is a pointer to a variable into
-which the information is placed. The following information is available:
-<pre>
- PCRE_CONFIG_UTF8
-</pre>
-The output is an integer that is set to one if UTF-8 support is available;
-otherwise it is set to zero.
-<pre>
- PCRE_CONFIG_UNICODE_PROPERTIES
-</pre>
-The output is an integer that is set to one if support for Unicode character
-properties is available; otherwise it is set to zero.
-<pre>
- PCRE_CONFIG_NEWLINE
-</pre>
-The output is an integer that is set to the value of the code that is used for
-the newline character. It is either linefeed (10) or carriage return (13), and
-should normally be the standard character for your operating system.
-<pre>
- PCRE_CONFIG_LINK_SIZE
-</pre>
-The output is an integer that contains the number of bytes used for internal
-linkage in compiled regular expressions. The value is 2, 3, or 4. Larger values
-allow larger regular expressions to be compiled, at the expense of slower
-matching. The default value of 2 is sufficient for all but the most massive
-patterns, since it allows the compiled pattern to be up to 64K in size.
-<pre>
- PCRE_CONFIG_POSIX_MALLOC_THRESHOLD
-</pre>
-The output is an integer that contains the threshold above which the POSIX
-interface uses <b>malloc()</b> for output vectors. Further details are given in
-the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-documentation.
-<pre>
- PCRE_CONFIG_MATCH_LIMIT
-</pre>
-The output is an integer that gives the default limit for the number of
-internal matching function calls in a <b>pcre_exec()</b> execution. Further
-details are given with <b>pcre_exec()</b> below.
-<pre>
- PCRE_CONFIG_STACKRECURSE
-</pre>
-The output is an integer that is set to one if internal recursion is
-implemented by recursive function calls that use the stack to remember their
-state. This is the usual way that PCRE is compiled. The output is zero if PCRE
-was compiled to use blocks of data on the heap instead of recursive function
-calls. In this case, <b>pcre_stack_malloc</b> and <b>pcre_stack_free</b> are
-called to manage memory blocks on the heap, thus avoiding the use of the stack.
-</P>
-<br><a name="SEC6" href="#TOC1">COMPILING A PATTERN</a><br>
-<P>
-<b>pcre *pcre_compile(const char *<i>pattern</i>, int <i>options</i>,</b>
-<b>const char **<i>errptr</i>, int *<i>erroffset</i>,</b>
-<b>const unsigned char *<i>tableptr</i>);</b>
-</P>
-<P>
-The function <b>pcre_compile()</b> is called to compile a pattern into an
-internal form. The pattern is a C string terminated by a binary zero, and
-is passed in the <i>pattern</i> argument. A pointer to a single block of memory
-that is obtained via <b>pcre_malloc</b> is returned. This contains the compiled
-code and related data. The <b>pcre</b> type is defined for the returned block;
-this is a typedef for a structure whose contents are not externally defined. It
-is up to the caller to free the memory when it is no longer required.
-</P>
-<P>
-Although the compiled code of a PCRE regex is relocatable, that is, it does not
-depend on memory location, the complete <b>pcre</b> data block is not
-fully relocatable, because it may contain a copy of the <i>tableptr</i>
-argument, which is an address (see below).
-</P>
-<P>
-The <i>options</i> argument contains independent bits that affect the
-compilation. It should be zero if no options are required. The available
-options are described below. Some of them, in particular, those that are
-compatible with Perl, can also be set and unset from within the pattern (see
-the detailed description in the
-<a href="pcrepattern.html"><b>pcrepattern</b></a>
-documentation). For these options, the contents of the <i>options</i> argument
-specifies their initial settings at the start of compilation and execution. The
-PCRE_ANCHORED option can be set at the time of matching as well as at compile
-time.
-</P>
-<P>
-If <i>errptr</i> is NULL, <b>pcre_compile()</b> returns NULL immediately.
-Otherwise, if compilation of a pattern fails, <b>pcre_compile()</b> returns
-NULL, and sets the variable pointed to by <i>errptr</i> to point to a textual
-error message. The offset from the start of the pattern to the character where
-the error was discovered is placed in the variable pointed to by
-<i>erroffset</i>, which must not be NULL. If it is, an immediate error is given.
-</P>
-<P>
-If the final argument, <i>tableptr</i>, is NULL, PCRE uses a default set of
-character tables that are built when PCRE is compiled, using the default C
-locale. Otherwise, <i>tableptr</i> must be an address that is the result of a
-call to <b>pcre_maketables()</b>. This value is stored with the compiled
-pattern, and used again by <b>pcre_exec()</b>, unless another table pointer is
-passed to it. For more discussion, see the section on locale support below.
-</P>
-<P>
-This code fragment shows a typical straightforward call to <b>pcre_compile()</b>:
-<pre>
- pcre *re;
- const char *error;
- int erroffset;
- re = pcre_compile(
- "^A.*Z", /* the pattern */
- 0, /* default options */
- &error, /* for error message */
- &erroffset, /* for error offset */
- NULL); /* use default character tables */
-</pre>
-The following names for option bits are defined in the <b>pcre.h</b> header
-file:
-<pre>
- PCRE_ANCHORED
-</pre>
-If this bit is set, the pattern is forced to be "anchored", that is, it is
-constrained to match only at the first matching point in the string that is
-being searched (the "subject string"). This effect can also be achieved by
-appropriate constructs in the pattern itself, which is the only way to do it in
-Perl.
-<pre>
- PCRE_AUTO_CALLOUT
-</pre>
-If this bit is set, <b>pcre_compile()</b> automatically inserts callout items,
-all with number 255, before each pattern item. For discussion of the callout
-facility, see the
-<a href="pcrecallout.html"><b>pcrecallout</b></a>
-documentation.
-<pre>
- PCRE_CASELESS
-</pre>
-If this bit is set, letters in the pattern match both upper and lower case
-letters. It is equivalent to Perl's /i option, and it can be changed within a
-pattern by a (?i) option setting. When running in UTF-8 mode, case support for
-high-valued characters is available only when PCRE is built with Unicode
-character property support.
-<pre>
- PCRE_DOLLAR_ENDONLY
-</pre>
-If this bit is set, a dollar metacharacter in the pattern matches only at the
-end of the subject string. Without this option, a dollar also matches
-immediately before the final character if it is a newline (but not before any
-other newlines). The PCRE_DOLLAR_ENDONLY option is ignored if PCRE_MULTILINE is
-set. There is no equivalent to this option in Perl, and no way to set it within
-a pattern.
-<pre>
- PCRE_DOTALL
-</pre>
-If this bit is set, a dot metacharater in the pattern matches all characters,
-including newlines. Without it, newlines are excluded. This option is
-equivalent to Perl's /s option, and it can be changed within a pattern by a
-(?s) option setting. A negative class such as [^a] always matches a newline
-character, independent of the setting of this option.
-<pre>
- PCRE_EXTENDED
-</pre>
-If this bit is set, whitespace data characters in the pattern are totally
-ignored except when escaped or inside a character class. Whitespace does not
-include the VT character (code 11). In addition, characters between an
-unescaped # outside a character class and the next newline character,
-inclusive, are also ignored. This is equivalent to Perl's /x option, and it can
-be changed within a pattern by a (?x) option setting.
-</P>
-<P>
-This option makes it possible to include comments inside complicated patterns.
-Note, however, that this applies only to data characters. Whitespace characters
-may never appear within special character sequences in a pattern, for example
-within the sequence (?( which introduces a conditional subpattern.
-<pre>
- PCRE_EXTRA
-</pre>
-This option was invented in order to turn on additional functionality of PCRE
-that is incompatible with Perl, but it is currently of very little use. When
-set, any backslash in a pattern that is followed by a letter that has no
-special meaning causes an error, thus reserving these combinations for future
-expansion. By default, as in Perl, a backslash followed by a letter with no
-special meaning is treated as a literal. There are at present no other features
-controlled by this option. It can also be set by a (?X) option setting within a
-pattern.
-<pre>
- PCRE_MULTILINE
-</pre>
-By default, PCRE treats the subject string as consisting of a single line of
-characters (even if it actually contains newlines). The "start of line"
-metacharacter (^) matches only at the start of the string, while the "end of
-line" metacharacter ($) matches only at the end of the string, or before a
-terminating newline (unless PCRE_DOLLAR_ENDONLY is set). This is the same as
-Perl.
-</P>
-<P>
-When PCRE_MULTILINE it is set, the "start of line" and "end of line" constructs
-match immediately following or immediately before any newline in the subject
-string, respectively, as well as at the very start and end. This is equivalent
-to Perl's /m option, and it can be changed within a pattern by a (?m) option
-setting. If there are no "\n" characters in a subject string, or no
-occurrences of ^ or $ in a pattern, setting PCRE_MULTILINE has no effect.
-<pre>
- PCRE_NO_AUTO_CAPTURE
-</pre>
-If this option is set, it disables the use of numbered capturing parentheses in
-the pattern. Any opening parenthesis that is not followed by ? behaves as if it
-were followed by ?: but named parentheses can still be used for capturing (and
-they acquire numbers in the usual way). There is no equivalent of this option
-in Perl.
-<pre>
- PCRE_UNGREEDY
-</pre>
-This option inverts the "greediness" of the quantifiers so that they are not
-greedy by default, but become greedy if followed by "?". It is not compatible
-with Perl. It can also be set by a (?U) option setting within the pattern.
-<pre>
- PCRE_UTF8
-</pre>
-This option causes PCRE to regard both the pattern and the subject as strings
-of UTF-8 characters instead of single-byte character strings. However, it is
-available only when PCRE is built to include UTF-8 support. If not, the use
-of this option provokes an error. Details of how this option changes the
-behaviour of PCRE are given in the
-<a href="pcre.html#utf8support">section on UTF-8 support</a>
-in the main
-<a href="pcre.html"><b>pcre</b></a>
-page.
-<pre>
- PCRE_NO_UTF8_CHECK
-</pre>
-When PCRE_UTF8 is set, the validity of the pattern as a UTF-8 string is
-automatically checked. If an invalid UTF-8 sequence of bytes is found,
-<b>pcre_compile()</b> returns an error. If you already know that your pattern is
-valid, and you want to skip this check for performance reasons, you can set the
-PCRE_NO_UTF8_CHECK option. When it is set, the effect of passing an invalid
-UTF-8 string as a pattern is undefined. It may cause your program to crash.
-Note that this option can also be passed to <b>pcre_exec()</b>, to suppress the
-UTF-8 validity checking of subject strings.
-</P>
-<br><a name="SEC7" href="#TOC1">STUDYING A PATTERN</a><br>
-<P>
-<b>pcre_extra *pcre_study(const pcre *<i>code</i>, int <i>options</i>,</b>
-<b>const char **<i>errptr</i>);</b>
-</P>
-<P>
-If a compiled pattern is going to be used several times, it is worth spending
-more time analyzing it in order to speed up the time taken for matching. The
-function <b>pcre_study()</b> takes a pointer to a compiled pattern as its first
-argument. If studying the pattern produces additional information that will
-help speed up matching, <b>pcre_study()</b> returns a pointer to a
-<b>pcre_extra</b> block, in which the <i>study_data</i> field points to the
-results of the study.
-</P>
-<P>
-The returned value from <b>pcre_study()</b> can be passed directly to
-<b>pcre_exec()</b>. However, a <b>pcre_extra</b> block also contains other
-fields that can be set by the caller before the block is passed; these are
-described
-<a href="#extradata">below</a>
-in the section on matching a pattern.
-</P>
-<P>
-If studying the pattern does not produce any additional information,
-<b>pcre_study()</b> returns NULL. In that circumstance, if the calling program
-wants to pass any of the other fields to <b>pcre_exec()</b>, it must set up its
-own <b>pcre_extra</b> block.
-</P>
-<P>
-The second argument of <b>pcre_study()</b> contains option bits. At present, no
-options are defined, and this argument should always be zero.
-</P>
-<P>
-The third argument for <b>pcre_study()</b> is a pointer for an error message. If
-studying succeeds (even if no data is returned), the variable it points to is
-set to NULL. Otherwise it points to a textual error message. You should
-therefore test the error pointer for NULL after calling <b>pcre_study()</b>, to
-be sure that it has run successfully.
-</P>
-<P>
-This is a typical call to <b>pcre_study</b>():
-<pre>
- pcre_extra *pe;
- pe = pcre_study(
- re, /* result of pcre_compile() */
- 0, /* no options exist */
- &error); /* set to NULL or points to a message */
-</pre>
-At present, studying a pattern is useful only for non-anchored patterns that do
-not have a single fixed starting character. A bitmap of possible starting
-bytes is created.
-<a name="localesupport"></a></P>
-<br><a name="SEC8" href="#TOC1">LOCALE SUPPORT</a><br>
-<P>
-PCRE handles caseless matching, and determines whether characters are letters,
-digits, or whatever, by reference to a set of tables, indexed by character
-value. (When running in UTF-8 mode, this applies only to characters with codes
-less than 128. Higher-valued codes never match escapes such as \w or \d, but
-can be tested with \p if PCRE is built with Unicode character property
-support.)
-</P>
-<P>
-An internal set of tables is created in the default C locale when PCRE is
-built. This is used when the final argument of <b>pcre_compile()</b> is NULL,
-and is sufficient for many applications. An alternative set of tables can,
-however, be supplied. These may be created in a different locale from the
-default. As more and more applications change to using Unicode, the need for
-this locale support is expected to die away.
-</P>
-<P>
-External tables are built by calling the <b>pcre_maketables()</b> function,
-which has no arguments, in the relevant locale. The result can then be passed
-to <b>pcre_compile()</b> or <b>pcre_exec()</b> as often as necessary. For
-example, to build and use tables that are appropriate for the French locale
-(where accented characters with values greater than 128 are treated as letters),
-the following code could be used:
-<pre>
- setlocale(LC_CTYPE, "fr_FR");
- tables = pcre_maketables();
- re = pcre_compile(..., tables);
-</pre>
-When <b>pcre_maketables()</b> runs, the tables are built in memory that is
-obtained via <b>pcre_malloc</b>. It is the caller's responsibility to ensure
-that the memory containing the tables remains available for as long as it is
-needed.
-</P>
-<P>
-The pointer that is passed to <b>pcre_compile()</b> is saved with the compiled
-pattern, and the same tables are used via this pointer by <b>pcre_study()</b>
-and normally also by <b>pcre_exec()</b>. Thus, by default, for any single
-pattern, compilation, studying and matching all happen in the same locale, but
-different patterns can be compiled in different locales.
-</P>
-<P>
-It is possible to pass a table pointer or NULL (indicating the use of the
-internal tables) to <b>pcre_exec()</b>. Although not intended for this purpose,
-this facility could be used to match a pattern in a different locale from the
-one in which it was compiled. Passing table pointers at run time is discussed
-below in the section on matching a pattern.
-</P>
-<br><a name="SEC9" href="#TOC1">INFORMATION ABOUT A PATTERN</a><br>
-<P>
-<b>int pcre_fullinfo(const pcre *<i>code</i>, const pcre_extra *<i>extra</i>,</b>
-<b>int <i>what</i>, void *<i>where</i>);</b>
-</P>
-<P>
-The <b>pcre_fullinfo()</b> function returns information about a compiled
-pattern. It replaces the obsolete <b>pcre_info()</b> function, which is
-nevertheless retained for backwards compability (and is documented below).
-</P>
-<P>
-The first argument for <b>pcre_fullinfo()</b> is a pointer to the compiled
-pattern. The second argument is the result of <b>pcre_study()</b>, or NULL if
-the pattern was not studied. The third argument specifies which piece of
-information is required, and the fourth argument is a pointer to a variable
-to receive the data. The yield of the function is zero for success, or one of
-the following negative numbers:
-<pre>
- PCRE_ERROR_NULL the argument <i>code</i> was NULL
- the argument <i>where</i> was NULL
- PCRE_ERROR_BADMAGIC the "magic number" was not found
- PCRE_ERROR_BADOPTION the value of <i>what</i> was invalid
-</pre>
-The "magic number" is placed at the start of each compiled pattern as an simple
-check against passing an arbitrary memory pointer. Here is a typical call of
-<b>pcre_fullinfo()</b>, to obtain the length of the compiled pattern:
-<pre>
- int rc;
- unsigned long int length;
- rc = pcre_fullinfo(
- re, /* result of pcre_compile() */
- pe, /* result of pcre_study(), or NULL */
- PCRE_INFO_SIZE, /* what is required */
- &length); /* where to put the data */
-</pre>
-The possible values for the third argument are defined in <b>pcre.h</b>, and are
-as follows:
-<pre>
- PCRE_INFO_BACKREFMAX
-</pre>
-Return the number of the highest back reference in the pattern. The fourth
-argument should point to an <b>int</b> variable. Zero is returned if there are
-no back references.
-<pre>
- PCRE_INFO_CAPTURECOUNT
-</pre>
-Return the number of capturing subpatterns in the pattern. The fourth argument
-should point to an <b>int</b> variable.
-<pre>
- PCRE_INFO_DEFAULTTABLES
-</pre>
-Return a pointer to the internal default character tables within PCRE. The
-fourth argument should point to an <b>unsigned char *</b> variable. This
-information call is provided for internal use by the <b>pcre_study()</b>
-function. External callers can cause PCRE to use its internal tables by passing
-a NULL table pointer.
-<pre>
- PCRE_INFO_FIRSTBYTE
-</pre>
-Return information about the first byte of any matched string, for a
-non-anchored pattern. (This option used to be called PCRE_INFO_FIRSTCHAR; the
-old name is still recognized for backwards compatibility.)
-</P>
-<P>
-If there is a fixed first byte, for example, from a pattern such as
-(cat|cow|coyote), it is returned in the integer pointed to by <i>where</i>.
-Otherwise, if either
-<br>
-<br>
-(a) the pattern was compiled with the PCRE_MULTILINE option, and every branch
-starts with "^", or
-<br>
-<br>
-(b) every branch of the pattern starts with ".*" and PCRE_DOTALL is not set
-(if it were set, the pattern would be anchored),
-<br>
-<br>
--1 is returned, indicating that the pattern matches only at the start of a
-subject string or after any newline within the string. Otherwise -2 is
-returned. For anchored patterns, -2 is returned.
-<pre>
- PCRE_INFO_FIRSTTABLE
-</pre>
-If the pattern was studied, and this resulted in the construction of a 256-bit
-table indicating a fixed set of bytes for the first byte in any matching
-string, a pointer to the table is returned. Otherwise NULL is returned. The
-fourth argument should point to an <b>unsigned char *</b> variable.
-<pre>
- PCRE_INFO_LASTLITERAL
-</pre>
-Return the value of the rightmost literal byte that must exist in any matched
-string, other than at its start, if such a byte has been recorded. The fourth
-argument should point to an <b>int</b> variable. If there is no such byte, -1 is
-returned. For anchored patterns, a last literal byte is recorded only if it
-follows something of variable length. For example, for the pattern
-/^a\d+z\d+/ the returned value is "z", but for /^a\dz\d/ the returned value
-is -1.
-<pre>
- PCRE_INFO_NAMECOUNT
- PCRE_INFO_NAMEENTRYSIZE
- PCRE_INFO_NAMETABLE
-</pre>
-PCRE supports the use of named as well as numbered capturing parentheses. The
-names are just an additional way of identifying the parentheses, which still
-acquire numbers. A convenience function called <b>pcre_get_named_substring()</b>
-is provided for extracting an individual captured substring by name. It is also
-possible to extract the data directly, by first converting the name to a number
-in order to access the correct pointers in the output vector (described with
-<b>pcre_exec()</b> below). To do the conversion, you need to use the
-name-to-number map, which is described by these three values.
-</P>
-<P>
-The map consists of a number of fixed-size entries. PCRE_INFO_NAMECOUNT gives
-the number of entries, and PCRE_INFO_NAMEENTRYSIZE gives the size of each
-entry; both of these return an <b>int</b> value. The entry size depends on the
-length of the longest name. PCRE_INFO_NAMETABLE returns a pointer to the first
-entry of the table (a pointer to <b>char</b>). The first two bytes of each entry
-are the number of the capturing parenthesis, most significant byte first. The
-rest of the entry is the corresponding name, zero terminated. The names are in
-alphabetical order. For example, consider the following pattern (assume
-PCRE_EXTENDED is set, so white space - including newlines - is ignored):
-<pre>
- (?P<date> (?P<year>(\d\d)?\d\d) - (?P<month>\d\d) - (?P<day>\d\d) )
-</pre>
-There are four named subpatterns, so the table has four entries, and each entry
-in the table is eight bytes long. The table is as follows, with non-printing
-bytes shows in hexadecimal, and undefined bytes shown as ??:
-<pre>
- 00 01 d a t e 00 ??
- 00 05 d a y 00 ?? ??
- 00 04 m o n t h 00
- 00 02 y e a r 00 ??
-</pre>
-When writing code to extract data from named subpatterns using the
-name-to-number map, remember that the length of each entry is likely to be
-different for each compiled pattern.
-<pre>
- PCRE_INFO_OPTIONS
-</pre>
-Return a copy of the options with which the pattern was compiled. The fourth
-argument should point to an <b>unsigned long int</b> variable. These option bits
-are those specified in the call to <b>pcre_compile()</b>, modified by any
-top-level option settings within the pattern itself.
-</P>
-<P>
-A pattern is automatically anchored by PCRE if all of its top-level
-alternatives begin with one of the following:
-<pre>
- ^ unless PCRE_MULTILINE is set
- \A always
- \G always
- .* if PCRE_DOTALL is set and there are no back references to the subpattern in which .* appears
-</pre>
-For such patterns, the PCRE_ANCHORED bit is set in the options returned by
-<b>pcre_fullinfo()</b>.
-<pre>
- PCRE_INFO_SIZE
-</pre>
-Return the size of the compiled pattern, that is, the value that was passed as
-the argument to <b>pcre_malloc()</b> when PCRE was getting memory in which to
-place the compiled data. The fourth argument should point to a <b>size_t</b>
-variable.
-<pre>
- PCRE_INFO_STUDYSIZE
-</pre>
-Return the size of the data block pointed to by the <i>study_data</i> field in
-a <b>pcre_extra</b> block. That is, it is the value that was passed to
-<b>pcre_malloc()</b> when PCRE was getting memory into which to place the data
-created by <b>pcre_study()</b>. The fourth argument should point to a
-<b>size_t</b> variable.
-</P>
-<br><a name="SEC10" href="#TOC1">OBSOLETE INFO FUNCTION</a><br>
-<P>
-<b>int pcre_info(const pcre *<i>code</i>, int *<i>optptr</i>, int</b>
-<b>*<i>firstcharptr</i>);</b>
-</P>
-<P>
-The <b>pcre_info()</b> function is now obsolete because its interface is too
-restrictive to return all the available data about a compiled pattern. New
-programs should use <b>pcre_fullinfo()</b> instead. The yield of
-<b>pcre_info()</b> is the number of capturing subpatterns, or one of the
-following negative numbers:
-<pre>
- PCRE_ERROR_NULL the argument <i>code</i> was NULL
- PCRE_ERROR_BADMAGIC the "magic number" was not found
-</pre>
-If the <i>optptr</i> argument is not NULL, a copy of the options with which the
-pattern was compiled is placed in the integer it points to (see
-PCRE_INFO_OPTIONS above).
-</P>
-<P>
-If the pattern is not anchored and the <i>firstcharptr</i> argument is not NULL,
-it is used to pass back information about the first character of any matched
-string (see PCRE_INFO_FIRSTBYTE above).
-</P>
-<br><a name="SEC11" href="#TOC1">MATCHING A PATTERN</a><br>
-<P>
-<b>int pcre_exec(const pcre *<i>code</i>, const pcre_extra *<i>extra</i>,</b>
-<b>const char *<i>subject</i>, int <i>length</i>, int <i>startoffset</i>,</b>
-<b>int <i>options</i>, int *<i>ovector</i>, int <i>ovecsize</i>);</b>
-</P>
-<P>
-The function <b>pcre_exec()</b> is called to match a subject string against a
-compiled pattern, which is passed in the <i>code</i> argument. If the
-pattern has been studied, the result of the study should be passed in the
-<i>extra</i> argument.
-</P>
-<P>
-In most applications, the pattern will have been compiled (and optionally
-studied) in the same process that calls <b>pcre_exec()</b>. However, it is
-possible to save compiled patterns and study data, and then use them later
-in different processes, possibly even on different hosts. For a discussion
-about this, see the
-<a href="pcreprecompile.html"><b>pcreprecompile</b></a>
-documentation.
-</P>
-<P>
-Here is an example of a simple call to <b>pcre_exec()</b>:
-<pre>
- int rc;
- int ovector[30];
- rc = pcre_exec(
- re, /* result of pcre_compile() */
- NULL, /* we didn't study the pattern */
- "some string", /* the subject string */
- 11, /* the length of the subject string */
- 0, /* start at offset 0 in the subject */
- 0, /* default options */
- ovector, /* vector of integers for substring information */
- 30); /* number of elements in the vector (NOT size in bytes) */
-<a name="extradata"></a></PRE>
-</P>
-<br><b>
-Extra data for <b>pcre_exec()</b>
-</b><br>
-<P>
-If the <i>extra</i> argument is not NULL, it must point to a <b>pcre_extra</b>
-data block. The <b>pcre_study()</b> function returns such a block (when it
-doesn't return NULL), but you can also create one for yourself, and pass
-additional information in it. The fields in a <b>pcre_extra</b> block are as
-follows:
-<pre>
- unsigned long int <i>flags</i>;
- void *<i>study_data</i>;
- unsigned long int <i>match_limit</i>;
- void *<i>callout_data</i>;
- const unsigned char *<i>tables</i>;
-</pre>
-The <i>flags</i> field is a bitmap that specifies which of the other fields
-are set. The flag bits are:
-<pre>
- PCRE_EXTRA_STUDY_DATA
- PCRE_EXTRA_MATCH_LIMIT
- PCRE_EXTRA_CALLOUT_DATA
- PCRE_EXTRA_TABLES
-</pre>
-Other flag bits should be set to zero. The <i>study_data</i> field is set in the
-<b>pcre_extra</b> block that is returned by <b>pcre_study()</b>, together with
-the appropriate flag bit. You should not set this yourself, but you may add to
-the block by setting the other fields and their corresponding flag bits.
-</P>
-<P>
-The <i>match_limit</i> field provides a means of preventing PCRE from using up a
-vast amount of resources when running patterns that are not going to match,
-but which have a very large number of possibilities in their search trees. The
-classic example is the use of nested unlimited repeats.
-</P>
-<P>
-Internally, PCRE uses a function called <b>match()</b> which it calls repeatedly
-(sometimes recursively). The limit is imposed on the number of times this
-function is called during a match, which has the effect of limiting the amount
-of recursion and backtracking that can take place. For patterns that are not
-anchored, the count starts from zero for each position in the subject string.
-</P>
-<P>
-The default limit for the library can be set when PCRE is built; the default
-default is 10 million, which handles all but the most extreme cases. You can
-reduce the default by suppling <b>pcre_exec()</b> with a <b>pcre_extra</b> block
-in which <i>match_limit</i> is set to a smaller value, and
-PCRE_EXTRA_MATCH_LIMIT is set in the <i>flags</i> field. If the limit is
-exceeded, <b>pcre_exec()</b> returns PCRE_ERROR_MATCHLIMIT.
-</P>
-<P>
-The <i>pcre_callout</i> field is used in conjunction with the "callout" feature,
-which is described in the
-<a href="pcrecallout.html"><b>pcrecallout</b></a>
-documentation.
-</P>
-<P>
-The <i>tables</i> field is used to pass a character tables pointer to
-<b>pcre_exec()</b>; this overrides the value that is stored with the compiled
-pattern. A non-NULL value is stored with the compiled pattern only if custom
-tables were supplied to <b>pcre_compile()</b> via its <i>tableptr</i> argument.
-If NULL is passed to <b>pcre_exec()</b> using this mechanism, it forces PCRE's
-internal tables to be used. This facility is helpful when re-using patterns
-that have been saved after compiling with an external set of tables, because
-the external tables might be at a different address when <b>pcre_exec()</b> is
-called. See the
-<a href="pcreprecompile.html"><b>pcreprecompile</b></a>
-documentation for a discussion of saving compiled patterns for later use.
-</P>
-<br><b>
-Option bits for <b>pcre_exec()</b>
-</b><br>
-<P>
-The unused bits of the <i>options</i> argument for <b>pcre_exec()</b> must be
-zero. The only bits that may be set are PCRE_ANCHORED, PCRE_NOTBOL,
-PCRE_NOTEOL, PCRE_NOTEMPTY, PCRE_NO_UTF8_CHECK and PCRE_PARTIAL.
-<pre>
- PCRE_ANCHORED
-</pre>
-The PCRE_ANCHORED option limits <b>pcre_exec()</b> to matching at the first
-matching position. If a pattern was compiled with PCRE_ANCHORED, or turned out
-to be anchored by virtue of its contents, it cannot be made unachored at
-matching time.
-<pre>
- PCRE_NOTBOL
-</pre>
-This option specifies that first character of the subject string is not the
-beginning of a line, so the circumflex metacharacter should not match before
-it. Setting this without PCRE_MULTILINE (at compile time) causes circumflex
-never to match. This option affects only the behaviour of the circumflex
-metacharacter. It does not affect \A.
-<pre>
- PCRE_NOTEOL
-</pre>
-This option specifies that the end of the subject string is not the end of a
-line, so the dollar metacharacter should not match it nor (except in multiline
-mode) a newline immediately before it. Setting this without PCRE_MULTILINE (at
-compile time) causes dollar never to match. This option affects only the
-behaviour of the dollar metacharacter. It does not affect \Z or \z.
-<pre>
- PCRE_NOTEMPTY
-</pre>
-An empty string is not considered to be a valid match if this option is set. If
-there are alternatives in the pattern, they are tried. If all the alternatives
-match the empty string, the entire match fails. For example, if the pattern
-<pre>
- a?b?
-</pre>
-is applied to a string not beginning with "a" or "b", it matches the empty
-string at the start of the subject. With PCRE_NOTEMPTY set, this match is not
-valid, so PCRE searches further into the string for occurrences of "a" or "b".
-</P>
-<P>
-Perl has no direct equivalent of PCRE_NOTEMPTY, but it does make a special case
-of a pattern match of the empty string within its <b>split()</b> function, and
-when using the /g modifier. It is possible to emulate Perl's behaviour after
-matching a null string by first trying the match again at the same offset with
-PCRE_NOTEMPTY and PCRE_ANCHORED, and then if that fails by advancing the
-starting offset (see below) and trying an ordinary match again. There is some
-code that demonstrates how to do this in the <i>pcredemo.c</i> sample program.
-<pre>
- PCRE_NO_UTF8_CHECK
-</pre>
-When PCRE_UTF8 is set at compile time, the validity of the subject as a UTF-8
-string is automatically checked when <b>pcre_exec()</b> is subsequently called.
-The value of <i>startoffset</i> is also checked to ensure that it points to the
-start of a UTF-8 character. If an invalid UTF-8 sequence of bytes is found,
-<b>pcre_exec()</b> returns the error PCRE_ERROR_BADUTF8. If <i>startoffset</i>
-contains an invalid value, PCRE_ERROR_BADUTF8_OFFSET is returned.
-</P>
-<P>
-If you already know that your subject is valid, and you want to skip these
-checks for performance reasons, you can set the PCRE_NO_UTF8_CHECK option when
-calling <b>pcre_exec()</b>. You might want to do this for the second and
-subsequent calls to <b>pcre_exec()</b> if you are making repeated calls to find
-all the matches in a single subject string. However, you should be sure that
-the value of <i>startoffset</i> points to the start of a UTF-8 character. When
-PCRE_NO_UTF8_CHECK is set, the effect of passing an invalid UTF-8 string as a
-subject, or a value of <i>startoffset</i> that does not point to the start of a
-UTF-8 character, is undefined. Your program may crash.
-<pre>
- PCRE_PARTIAL
-</pre>
-This option turns on the partial matching feature. If the subject string fails
-to match the pattern, but at some point during the matching process the end of
-the subject was reached (that is, the subject partially matches the pattern and
-the failure to match occurred only because there were not enough subject
-characters), <b>pcre_exec()</b> returns PCRE_ERROR_PARTIAL instead of
-PCRE_ERROR_NOMATCH. When PCRE_PARTIAL is used, there are restrictions on what
-may appear in the pattern. These are discussed in the
-<a href="pcrepartial.html"><b>pcrepartial</b></a>
-documentation.
-</P>
-<br><b>
-The string to be matched by <b>pcre_exec()</b>
-</b><br>
-<P>
-The subject string is passed to <b>pcre_exec()</b> as a pointer in
-<i>subject</i>, a length in <i>length</i>, and a starting byte offset in
-<i>startoffset</i>. In UTF-8 mode, the byte offset must point to the start of a
-UTF-8 character. Unlike the pattern string, the subject may contain binary zero
-bytes. When the starting offset is zero, the search for a match starts at the
-beginning of the subject, and this is by far the most common case.
-</P>
-<P>
-A non-zero starting offset is useful when searching for another match in the
-same subject by calling <b>pcre_exec()</b> again after a previous success.
-Setting <i>startoffset</i> differs from just passing over a shortened string and
-setting PCRE_NOTBOL in the case of a pattern that begins with any kind of
-lookbehind. For example, consider the pattern
-<pre>
- \Biss\B
-</pre>
-which finds occurrences of "iss" in the middle of words. (\B matches only if
-the current position in the subject is not a word boundary.) When applied to
-the string "Mississipi" the first call to <b>pcre_exec()</b> finds the first
-occurrence. If <b>pcre_exec()</b> is called again with just the remainder of the
-subject, namely "issipi", it does not match, because \B is always false at the
-start of the subject, which is deemed to be a word boundary. However, if
-<b>pcre_exec()</b> is passed the entire string again, but with <i>startoffset</i>
-set to 4, it finds the second occurrence of "iss" because it is able to look
-behind the starting point to discover that it is preceded by a letter.
-</P>
-<P>
-If a non-zero starting offset is passed when the pattern is anchored, one
-attempt to match at the given offset is made. This can only succeed if the
-pattern does not require the match to be at the start of the subject.
-</P>
-<br><b>
-How <b>pcre_exec()</b> returns captured substrings
-</b><br>
-<P>
-In general, a pattern matches a certain portion of the subject, and in
-addition, further substrings from the subject may be picked out by parts of the
-pattern. Following the usage in Jeffrey Friedl's book, this is called
-"capturing" in what follows, and the phrase "capturing subpattern" is used for
-a fragment of a pattern that picks out a substring. PCRE supports several other
-kinds of parenthesized subpattern that do not cause substrings to be captured.
-</P>
-<P>
-Captured substrings are returned to the caller via a vector of integer offsets
-whose address is passed in <i>ovector</i>. The number of elements in the vector
-is passed in <i>ovecsize</i>, which must be a non-negative number. <b>Note</b>:
-this argument is NOT the size of <i>ovector</i> in bytes.
-</P>
-<P>
-The first two-thirds of the vector is used to pass back captured substrings,
-each substring using a pair of integers. The remaining third of the vector is
-used as workspace by <b>pcre_exec()</b> while matching capturing subpatterns,
-and is not available for passing back information. The length passed in
-<i>ovecsize</i> should always be a multiple of three. If it is not, it is
-rounded down.
-</P>
-<P>
-When a match is successful, information about captured substrings is returned
-in pairs of integers, starting at the beginning of <i>ovector</i>, and
-continuing up to two-thirds of its length at the most. The first element of a
-pair is set to the offset of the first character in a substring, and the second
-is set to the offset of the first character after the end of a substring. The
-first pair, <i>ovector[0]</i> and <i>ovector[1]</i>, identify the portion of the
-subject string matched by the entire pattern. The next pair is used for the
-first capturing subpattern, and so on. The value returned by <b>pcre_exec()</b>
-is the number of pairs that have been set. If there are no capturing
-subpatterns, the return value from a successful match is 1, indicating that
-just the first pair of offsets has been set.
-</P>
-<P>
-Some convenience functions are provided for extracting the captured substrings
-as separate strings. These are described in the following section.
-</P>
-<P>
-It is possible for an capturing subpattern number <i>n+1</i> to match some
-part of the subject when subpattern <i>n</i> has not been used at all. For
-example, if the string "abc" is matched against the pattern (a|(z))(bc)
-subpatterns 1 and 3 are matched, but 2 is not. When this happens, both offset
-values corresponding to the unused subpattern are set to -1.
-</P>
-<P>
-If a capturing subpattern is matched repeatedly, it is the last portion of the
-string that it matched that is returned.
-</P>
-<P>
-If the vector is too small to hold all the captured substring offsets, it is
-used as far as possible (up to two-thirds of its length), and the function
-returns a value of zero. In particular, if the substring offsets are not of
-interest, <b>pcre_exec()</b> may be called with <i>ovector</i> passed as NULL and
-<i>ovecsize</i> as zero. However, if the pattern contains back references and
-the <i>ovector</i> is not big enough to remember the related substrings, PCRE
-has to get additional memory for use during matching. Thus it is usually
-advisable to supply an <i>ovector</i>.
-</P>
-<P>
-Note that <b>pcre_info()</b> can be used to find out how many capturing
-subpatterns there are in a compiled pattern. The smallest size for
-<i>ovector</i> that will allow for <i>n</i> captured substrings, in addition to
-the offsets of the substring matched by the whole pattern, is (<i>n</i>+1)*3.
-</P>
-<br><b>
-Return values from <b>pcre_exec()</b>
-</b><br>
-<P>
-If <b>pcre_exec()</b> fails, it returns a negative number. The following are
-defined in the header file:
-<pre>
- PCRE_ERROR_NOMATCH (-1)
-</pre>
-The subject string did not match the pattern.
-<pre>
- PCRE_ERROR_NULL (-2)
-</pre>
-Either <i>code</i> or <i>subject</i> was passed as NULL, or <i>ovector</i> was
-NULL and <i>ovecsize</i> was not zero.
-<pre>
- PCRE_ERROR_BADOPTION (-3)
-</pre>
-An unrecognized bit was set in the <i>options</i> argument.
-<pre>
- PCRE_ERROR_BADMAGIC (-4)
-</pre>
-PCRE stores a 4-byte "magic number" at the start of the compiled code, to catch
-the case when it is passed a junk pointer and to detect when a pattern that was
-compiled in an environment of one endianness is run in an environment with the
-other endianness. This is the error that PCRE gives when the magic number is
-not present.
-<pre>
- PCRE_ERROR_UNKNOWN_NODE (-5)
-</pre>
-While running the pattern match, an unknown item was encountered in the
-compiled pattern. This error could be caused by a bug in PCRE or by overwriting
-of the compiled pattern.
-<pre>
- PCRE_ERROR_NOMEMORY (-6)
-</pre>
-If a pattern contains back references, but the <i>ovector</i> that is passed to
-<b>pcre_exec()</b> is not big enough to remember the referenced substrings, PCRE
-gets a block of memory at the start of matching to use for this purpose. If the
-call via <b>pcre_malloc()</b> fails, this error is given. The memory is
-automatically freed at the end of matching.
-<pre>
- PCRE_ERROR_NOSUBSTRING (-7)
-</pre>
-This error is used by the <b>pcre_copy_substring()</b>,
-<b>pcre_get_substring()</b>, and <b>pcre_get_substring_list()</b> functions (see
-below). It is never returned by <b>pcre_exec()</b>.
-<pre>
- PCRE_ERROR_MATCHLIMIT (-8)
-</pre>
-The recursion and backtracking limit, as specified by the <i>match_limit</i>
-field in a <b>pcre_extra</b> structure (or defaulted) was reached. See the
-description above.
-<pre>
- PCRE_ERROR_CALLOUT (-9)
-</pre>
-This error is never generated by <b>pcre_exec()</b> itself. It is provided for
-use by callout functions that want to yield a distinctive error code. See the
-<a href="pcrecallout.html"><b>pcrecallout</b></a>
-documentation for details.
-<pre>
- PCRE_ERROR_BADUTF8 (-10)
-</pre>
-A string that contains an invalid UTF-8 byte sequence was passed as a subject.
-<pre>
- PCRE_ERROR_BADUTF8_OFFSET (-11)
-</pre>
-The UTF-8 byte sequence that was passed as a subject was valid, but the value
-of <i>startoffset</i> did not point to the beginning of a UTF-8 character.
-<pre>
- PCRE_ERROR_PARTIAL (-12)
-</pre>
-The subject string did not match, but it did match partially. See the
-<a href="pcrepartial.html"><b>pcrepartial</b></a>
-documentation for details of partial matching.
-<pre>
- PCRE_ERROR_BAD_PARTIAL (-13)
-</pre>
-The PCRE_PARTIAL option was used with a compiled pattern containing items that
-are not supported for partial matching. See the
-<a href="pcrepartial.html"><b>pcrepartial</b></a>
-documentation for details of partial matching.
-<pre>
- PCRE_ERROR_INTERNAL (-14)
-</pre>
-An unexpected internal error has occurred. This error could be caused by a bug
-in PCRE or by overwriting of the compiled pattern.
-<pre>
- PCRE_ERROR_BADCOUNT (-15)
-</pre>
-This error is given if the value of the <i>ovecsize</i> argument is negative.
-</P>
-<br><a name="SEC12" href="#TOC1">EXTRACTING CAPTURED SUBSTRINGS BY NUMBER</a><br>
-<P>
-<b>int pcre_copy_substring(const char *<i>subject</i>, int *<i>ovector</i>,</b>
-<b>int <i>stringcount</i>, int <i>stringnumber</i>, char *<i>buffer</i>,</b>
-<b>int <i>buffersize</i>);</b>
-</P>
-<P>
-<b>int pcre_get_substring(const char *<i>subject</i>, int *<i>ovector</i>,</b>
-<b>int <i>stringcount</i>, int <i>stringnumber</i>,</b>
-<b>const char **<i>stringptr</i>);</b>
-</P>
-<P>
-<b>int pcre_get_substring_list(const char *<i>subject</i>,</b>
-<b>int *<i>ovector</i>, int <i>stringcount</i>, const char ***<i>listptr</i>);</b>
-</P>
-<P>
-Captured substrings can be accessed directly by using the offsets returned by
-<b>pcre_exec()</b> in <i>ovector</i>. For convenience, the functions
-<b>pcre_copy_substring()</b>, <b>pcre_get_substring()</b>, and
-<b>pcre_get_substring_list()</b> are provided for extracting captured substrings
-as new, separate, zero-terminated strings. These functions identify substrings
-by number. The next section describes functions for extracting named
-substrings. A substring that contains a binary zero is correctly extracted and
-has a further zero added on the end, but the result is not, of course,
-a C string.
-</P>
-<P>
-The first three arguments are the same for all three of these functions:
-<i>subject</i> is the subject string that has just been successfully matched,
-<i>ovector</i> is a pointer to the vector of integer offsets that was passed to
-<b>pcre_exec()</b>, and <i>stringcount</i> is the number of substrings that were
-captured by the match, including the substring that matched the entire regular
-expression. This is the value returned by <b>pcre_exec()</b> if it is greater
-than zero. If <b>pcre_exec()</b> returned zero, indicating that it ran out of
-space in <i>ovector</i>, the value passed as <i>stringcount</i> should be the
-number of elements in the vector divided by three.
-</P>
-<P>
-The functions <b>pcre_copy_substring()</b> and <b>pcre_get_substring()</b>
-extract a single substring, whose number is given as <i>stringnumber</i>. A
-value of zero extracts the substring that matched the entire pattern, whereas
-higher values extract the captured substrings. For <b>pcre_copy_substring()</b>,
-the string is placed in <i>buffer</i>, whose length is given by
-<i>buffersize</i>, while for <b>pcre_get_substring()</b> a new block of memory is
-obtained via <b>pcre_malloc</b>, and its address is returned via
-<i>stringptr</i>. The yield of the function is the length of the string, not
-including the terminating zero, or one of
-<pre>
- PCRE_ERROR_NOMEMORY (-6)
-</pre>
-The buffer was too small for <b>pcre_copy_substring()</b>, or the attempt to get
-memory failed for <b>pcre_get_substring()</b>.
-<pre>
- PCRE_ERROR_NOSUBSTRING (-7)
-</pre>
-There is no substring whose number is <i>stringnumber</i>.
-</P>
-<P>
-The <b>pcre_get_substring_list()</b> function extracts all available substrings
-and builds a list of pointers to them. All this is done in a single block of
-memory that is obtained via <b>pcre_malloc</b>. The address of the memory block
-is returned via <i>listptr</i>, which is also the start of the list of string
-pointers. The end of the list is marked by a NULL pointer. The yield of the
-function is zero if all went well, or
-<pre>
- PCRE_ERROR_NOMEMORY (-6)
-</pre>
-if the attempt to get the memory block failed.
-</P>
-<P>
-When any of these functions encounter a substring that is unset, which can
-happen when capturing subpattern number <i>n+1</i> matches some part of the
-subject, but subpattern <i>n</i> has not been used at all, they return an empty
-string. This can be distinguished from a genuine zero-length substring by
-inspecting the appropriate offset in <i>ovector</i>, which is negative for unset
-substrings.
-</P>
-<P>
-The two convenience functions <b>pcre_free_substring()</b> and
-<b>pcre_free_substring_list()</b> can be used to free the memory returned by
-a previous call of <b>pcre_get_substring()</b> or
-<b>pcre_get_substring_list()</b>, respectively. They do nothing more than call
-the function pointed to by <b>pcre_free</b>, which of course could be called
-directly from a C program. However, PCRE is used in some situations where it is
-linked via a special interface to another programming language which cannot use
-<b>pcre_free</b> directly; it is for these cases that the functions are
-provided.
-</P>
-<br><a name="SEC13" href="#TOC1">EXTRACTING CAPTURED SUBSTRINGS BY NAME</a><br>
-<P>
-<b>int pcre_get_stringnumber(const pcre *<i>code</i>,</b>
-<b>const char *<i>name</i>);</b>
-</P>
-<P>
-<b>int pcre_copy_named_substring(const pcre *<i>code</i>,</b>
-<b>const char *<i>subject</i>, int *<i>ovector</i>,</b>
-<b>int <i>stringcount</i>, const char *<i>stringname</i>,</b>
-<b>char *<i>buffer</i>, int <i>buffersize</i>);</b>
-</P>
-<P>
-<b>int pcre_get_named_substring(const pcre *<i>code</i>,</b>
-<b>const char *<i>subject</i>, int *<i>ovector</i>,</b>
-<b>int <i>stringcount</i>, const char *<i>stringname</i>,</b>
-<b>const char **<i>stringptr</i>);</b>
-</P>
-<P>
-To extract a substring by name, you first have to find associated number.
-For example, for this pattern
-<pre>
- (a+)b(?<xxx>\d+)...
-</pre>
-the number of the subpattern called "xxx" is 2. You can find the number from
-the name by calling <b>pcre_get_stringnumber()</b>. The first argument is the
-compiled pattern, and the second is the name. The yield of the function is the
-subpattern number, or PCRE_ERROR_NOSUBSTRING (-7) if there is no subpattern of
-that name.
-</P>
-<P>
-Given the number, you can extract the substring directly, or use one of the
-functions described in the previous section. For convenience, there are also
-two functions that do the whole job.
-</P>
-<P>
-Most of the arguments of <i>pcre_copy_named_substring()</i> and
-<i>pcre_get_named_substring()</i> are the same as those for the similarly named
-functions that extract by number. As these are described in the previous
-section, they are not re-described here. There are just two differences:
-</P>
-<P>
-First, instead of a substring number, a substring name is given. Second, there
-is an extra argument, given at the start, which is a pointer to the compiled
-pattern. This is needed in order to gain access to the name-to-number
-translation table.
-</P>
-<P>
-These functions call <b>pcre_get_stringnumber()</b>, and if it succeeds, they
-then call <i>pcre_copy_substring()</i> or <i>pcre_get_substring()</i>, as
-appropriate.
-</P>
-<P>
-Last updated: 09 September 2004
-<br>
-Copyright © 1997-2004 University of Cambridge.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcrebuild specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcrebuild man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<ul>
-<li><a name="TOC1" href="#SEC1">PCRE BUILD-TIME OPTIONS</a>
-<li><a name="TOC2" href="#SEC2">UTF-8 SUPPORT</a>
-<li><a name="TOC3" href="#SEC3">UNICODE CHARACTER PROPERTY SUPPORT</a>
-<li><a name="TOC4" href="#SEC4">CODE VALUE OF NEWLINE</a>
-<li><a name="TOC5" href="#SEC5">BUILDING SHARED AND STATIC LIBRARIES</a>
-<li><a name="TOC6" href="#SEC6">POSIX MALLOC USAGE</a>
-<li><a name="TOC7" href="#SEC7">LIMITING PCRE RESOURCE USAGE</a>
-<li><a name="TOC8" href="#SEC8">HANDLING VERY LARGE PATTERNS</a>
-<li><a name="TOC9" href="#SEC9">AVOIDING EXCESSIVE STACK USAGE</a>
-<li><a name="TOC10" href="#SEC10">USING EBCDIC CODE</a>
-</ul>
-<br><a name="SEC1" href="#TOC1">PCRE BUILD-TIME OPTIONS</a><br>
-<P>
-This document describes the optional features of PCRE that can be selected when
-the library is compiled. They are all selected, or deselected, by providing
-options to the <b>configure</b> script that is run before the <b>make</b>
-command. The complete list of options for <b>configure</b> (which includes the
-standard ones such as the selection of the installation directory) can be
-obtained by running
-<pre>
- ./configure --help
-</pre>
-The following sections describe certain options whose names begin with --enable
-or --disable. These settings specify changes to the defaults for the
-<b>configure</b> command. Because of the way that <b>configure</b> works,
---enable and --disable always come in pairs, so the complementary option always
-exists as well, but as it specifies the default, it is not described.
-</P>
-<br><a name="SEC2" href="#TOC1">UTF-8 SUPPORT</a><br>
-<P>
-To build PCRE with support for UTF-8 character strings, add
-<pre>
- --enable-utf8
-</pre>
-to the <b>configure</b> command. Of itself, this does not make PCRE treat
-strings as UTF-8. As well as compiling PCRE with this option, you also have
-have to set the PCRE_UTF8 option when you call the <b>pcre_compile()</b>
-function.
-</P>
-<br><a name="SEC3" href="#TOC1">UNICODE CHARACTER PROPERTY SUPPORT</a><br>
-<P>
-UTF-8 support allows PCRE to process character values greater than 255 in the
-strings that it handles. On its own, however, it does not provide any
-facilities for accessing the properties of such characters. If you want to be
-able to use the pattern escapes \P, \p, and \X, which refer to Unicode
-character properties, you must add
-<pre>
- --enable-unicode-properties
-</pre>
-to the <b>configure</b> command. This implies UTF-8 support, even if you have
-not explicitly requested it.
-</P>
-<P>
-Including Unicode property support adds around 90K of tables to the PCRE
-library, approximately doubling its size. Only the general category properties
-such as <i>Lu</i> and <i>Nd</i> are supported. Details are given in the
-<a href="pcrepattern.html"><b>pcrepattern</b></a>
-documentation.
-</P>
-<br><a name="SEC4" href="#TOC1">CODE VALUE OF NEWLINE</a><br>
-<P>
-By default, PCRE treats character 10 (linefeed) as the newline character. This
-is the normal newline character on Unix-like systems. You can compile PCRE to
-use character 13 (carriage return) instead by adding
-<pre>
- --enable-newline-is-cr
-</pre>
-to the <b>configure</b> command. For completeness there is also a
---enable-newline-is-lf option, which explicitly specifies linefeed as the
-newline character.
-</P>
-<br><a name="SEC5" href="#TOC1">BUILDING SHARED AND STATIC LIBRARIES</a><br>
-<P>
-The PCRE building process uses <b>libtool</b> to build both shared and static
-Unix libraries by default. You can suppress one of these by adding one of
-<pre>
- --disable-shared
- --disable-static
-</pre>
-to the <b>configure</b> command, as required.
-</P>
-<br><a name="SEC6" href="#TOC1">POSIX MALLOC USAGE</a><br>
-<P>
-When PCRE is called through the POSIX interface (see the
-<a href="pcreposix.html"><b>pcreposix</b></a>
-documentation), additional working storage is required for holding the pointers
-to capturing substrings, because PCRE requires three integers per substring,
-whereas the POSIX interface provides only two. If the number of expected
-substrings is small, the wrapper function uses space on the stack, because this
-is faster than using <b>malloc()</b> for each call. The default threshold above
-which the stack is no longer used is 10; it can be changed by adding a setting
-such as
-<pre>
- --with-posix-malloc-threshold=20
-</pre>
-to the <b>configure</b> command.
-</P>
-<br><a name="SEC7" href="#TOC1">LIMITING PCRE RESOURCE USAGE</a><br>
-<P>
-Internally, PCRE has a function called <b>match()</b>, which it calls repeatedly
-(possibly recursively) when matching a pattern. By controlling the maximum
-number of times this function may be called during a single matching operation,
-a limit can be placed on the resources used by a single call to
-<b>pcre_exec()</b>. The limit can be changed at run time, as described in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-documentation. The default is 10 million, but this can be changed by adding a
-setting such as
-<pre>
- --with-match-limit=500000
-</pre>
-to the <b>configure</b> command.
-</P>
-<br><a name="SEC8" href="#TOC1">HANDLING VERY LARGE PATTERNS</a><br>
-<P>
-Within a compiled pattern, offset values are used to point from one part to
-another (for example, from an opening parenthesis to an alternation
-metacharacter). By default, two-byte values are used for these offsets, leading
-to a maximum size for a compiled pattern of around 64K. This is sufficient to
-handle all but the most gigantic patterns. Nevertheless, some people do want to
-process enormous patterns, so it is possible to compile PCRE to use three-byte
-or four-byte offsets by adding a setting such as
-<pre>
- --with-link-size=3
-</pre>
-to the <b>configure</b> command. The value given must be 2, 3, or 4. Using
-longer offsets slows down the operation of PCRE because it has to load
-additional bytes when handling them.
-</P>
-<P>
-If you build PCRE with an increased link size, test 2 (and test 5 if you are
-using UTF-8) will fail. Part of the output of these tests is a representation
-of the compiled pattern, and this changes with the link size.
-</P>
-<br><a name="SEC9" href="#TOC1">AVOIDING EXCESSIVE STACK USAGE</a><br>
-<P>
-PCRE implements backtracking while matching by making recursive calls to an
-internal function called <b>match()</b>. In environments where the size of the
-stack is limited, this can severely limit PCRE's operation. (The Unix
-environment does not usually suffer from this problem.) An alternative approach
-that uses memory from the heap to remember data, instead of using recursive
-function calls, has been implemented to work round this problem. If you want to
-build a version of PCRE that works this way, add
-<pre>
- --disable-stack-for-recursion
-</pre>
-to the <b>configure</b> command. With this configuration, PCRE will use the
-<b>pcre_stack_malloc</b> and <b>pcre_stack_free</b> variables to call memory
-management functions. Separate functions are provided because the usage is very
-predictable: the block sizes requested are always the same, and the blocks are
-always freed in reverse order. A calling program might be able to implement
-optimized functions that perform better than the standard <b>malloc()</b> and
-<b>free()</b> functions. PCRE runs noticeably more slowly when built in this
-way.
-</P>
-<br><a name="SEC10" href="#TOC1">USING EBCDIC CODE</a><br>
-<P>
-PCRE assumes by default that it will run in an environment where the character
-code is ASCII (or Unicode, which is a superset of ASCII). PCRE can, however, be
-compiled to run in an EBCDIC environment by adding
-<pre>
- --enable-ebcdic
-</pre>
-to the <b>configure</b> command.
-</P>
-<P>
-Last updated: 09 September 2004
-<br>
-Copyright © 1997-2004 University of Cambridge.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcrecallout specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcrecallout man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<ul>
-<li><a name="TOC1" href="#SEC1">PCRE CALLOUTS</a>
-<li><a name="TOC2" href="#SEC2">MISSING CALLOUTS</a>
-<li><a name="TOC3" href="#SEC3">THE CALLOUT INTERFACE</a>
-<li><a name="TOC4" href="#SEC4">RETURN VALUES</a>
-</ul>
-<br><a name="SEC1" href="#TOC1">PCRE CALLOUTS</a><br>
-<P>
-<b>int (*pcre_callout)(pcre_callout_block *);</b>
-</P>
-<P>
-PCRE provides a feature called "callout", which is a means of temporarily
-passing control to the caller of PCRE in the middle of pattern matching. The
-caller of PCRE provides an external function by putting its entry point in the
-global variable <i>pcre_callout</i>. By default, this variable contains NULL,
-which disables all calling out.
-</P>
-<P>
-Within a regular expression, (?C) indicates the points at which the external
-function is to be called. Different callout points can be identified by putting
-a number less than 256 after the letter C. The default value is zero.
-For example, this pattern has two callout points:
-<pre>
- (?C1)\deabc(?C2)def
-</pre>
-If the PCRE_AUTO_CALLOUT option bit is set when <b>pcre_compile()</b> is called,
-PCRE automatically inserts callouts, all with number 255, before each item in
-the pattern. For example, if PCRE_AUTO_CALLOUT is used with the pattern
-<pre>
- A(\d{2}|--)
-</pre>
-it is processed as if it were
-<br>
-<br>
-(?C255)A(?C255)((?C255)\d{2}(?C255)|(?C255)-(?C255)-(?C255))(?C255)
-<br>
-<br>
-Notice that there is a callout before and after each parenthesis and
-alternation bar. Automatic callouts can be used for tracking the progress of
-pattern matching. The
-<a href="pcretest.html"><b>pcretest</b></a>
-command has an option that sets automatic callouts; when it is used, the output
-indicates how the pattern is matched. This is useful information when you are
-trying to optimize the performance of a particular pattern.
-</P>
-<br><a name="SEC2" href="#TOC1">MISSING CALLOUTS</a><br>
-<P>
-You should be aware that, because of optimizations in the way PCRE matches
-patterns, callouts sometimes do not happen. For example, if the pattern is
-<pre>
- ab(?C4)cd
-</pre>
-PCRE knows that any matching string must contain the letter "d". If the subject
-string is "abyz", the lack of "d" means that matching doesn't ever start, and
-the callout is never reached. However, with "abyd", though the result is still
-no match, the callout is obeyed.
-</P>
-<br><a name="SEC3" href="#TOC1">THE CALLOUT INTERFACE</a><br>
-<P>
-During matching, when PCRE reaches a callout point, the external function
-defined by <i>pcre_callout</i> is called (if it is set). The only argument is a
-pointer to a <b>pcre_callout</b> block. This structure contains the following
-fields:
-<pre>
- int <i>version</i>;
- int <i>callout_number</i>;
- int *<i>offset_vector</i>;
- const char *<i>subject</i>;
- int <i>subject_length</i>;
- int <i>start_match</i>;
- int <i>current_position</i>;
- int <i>capture_top</i>;
- int <i>capture_last</i>;
- void *<i>callout_data</i>;
- int <i>pattern_position</i>;
- int <i>next_item_length</i>;
-</pre>
-The <i>version</i> field is an integer containing the version number of the
-block format. The initial version was 0; the current version is 1. The version
-number will change again in future if additional fields are added, but the
-intention is never to remove any of the existing fields.
-</P>
-<P>
-The <i>callout_number</i> field contains the number of the callout, as compiled
-into the pattern (that is, the number after ?C for manual callouts, and 255 for
-automatically generated callouts).
-</P>
-<P>
-The <i>offset_vector</i> field is a pointer to the vector of offsets that was
-passed by the caller to <b>pcre_exec()</b>. The contents can be inspected in
-order to extract substrings that have been matched so far, in the same way as
-for extracting substrings after a match has completed.
-</P>
-<P>
-The <i>subject</i> and <i>subject_length</i> fields contain copies of the values
-that were passed to <b>pcre_exec()</b>.
-</P>
-<P>
-The <i>start_match</i> field contains the offset within the subject at which the
-current match attempt started. If the pattern is not anchored, the callout
-function may be called several times from the same point in the pattern for
-different starting points in the subject.
-</P>
-<P>
-The <i>current_position</i> field contains the offset within the subject of the
-current match pointer.
-</P>
-<P>
-The <i>capture_top</i> field contains one more than the number of the highest
-numbered captured substring so far. If no substrings have been captured,
-the value of <i>capture_top</i> is one.
-</P>
-<P>
-The <i>capture_last</i> field contains the number of the most recently captured
-substring. If no substrings have been captured, its value is -1.
-</P>
-<P>
-The <i>callout_data</i> field contains a value that is passed to
-<b>pcre_exec()</b> by the caller specifically so that it can be passed back in
-callouts. It is passed in the <i>pcre_callout</i> field of the <b>pcre_extra</b>
-data structure. If no such data was passed, the value of <i>callout_data</i> in
-a <b>pcre_callout</b> block is NULL. There is a description of the
-<b>pcre_extra</b> structure in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-documentation.
-</P>
-<P>
-The <i>pattern_position</i> field is present from version 1 of the
-<i>pcre_callout</i> structure. It contains the offset to the next item to be
-matched in the pattern string.
-</P>
-<P>
-The <i>next_item_length</i> field is present from version 1 of the
-<i>pcre_callout</i> structure. It contains the length of the next item to be
-matched in the pattern string. When the callout immediately precedes an
-alternation bar, a closing parenthesis, or the end of the pattern, the length
-is zero. When the callout precedes an opening parenthesis, the length is that
-of the entire subpattern.
-</P>
-<P>
-The <i>pattern_position</i> and <i>next_item_length</i> fields are intended to
-help in distinguishing between different automatic callouts, which all have the
-same callout number. However, they are set for all callouts.
-</P>
-<br><a name="SEC4" href="#TOC1">RETURN VALUES</a><br>
-<P>
-The external callout function returns an integer to PCRE. If the value is zero,
-matching proceeds as normal. If the value is greater than zero, matching fails
-at the current point, but backtracking to test other matching possibilities
-goes ahead, just as if a lookahead assertion had failed. If the value is less
-than zero, the match is abandoned, and <b>pcre_exec()</b> returns the negative
-value.
-</P>
-<P>
-Negative values should normally be chosen from the set of PCRE_ERROR_xxx
-values. In particular, PCRE_ERROR_NOMATCH forces a standard "no match" failure.
-The error number PCRE_ERROR_CALLOUT is reserved for use by callout functions;
-it will never be used by PCRE itself.
-</P>
-<P>
-Last updated: 09 September 2004
-<br>
-Copyright © 1997-2004 University of Cambridge.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcrecompat specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcrecompat man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-DIFFERENCES BETWEEN PCRE AND PERL
-</b><br>
-<P>
-This document describes the differences in the ways that PCRE and Perl handle
-regular expressions. The differences described here are with respect to Perl
-5.8.
-</P>
-<P>
-1. PCRE does not have full UTF-8 support. Details of what it does have are
-given in the
-<a href="pcre.html#utf8support">section on UTF-8 support</a>
-in the main
-<a href="pcre.html"><b>pcre</b></a>
-page.
-</P>
-<P>
-2. PCRE does not allow repeat quantifiers on lookahead assertions. Perl permits
-them, but they do not mean what you might think. For example, (?!a){3} does
-not assert that the next three characters are not "a". It just asserts that the
-next character is not "a" three times.
-</P>
-<P>
-3. Capturing subpatterns that occur inside negative lookahead assertions are
-counted, but their entries in the offsets vector are never set. Perl sets its
-numerical variables from any such patterns that are matched before the
-assertion fails to match something (thereby succeeding), but only if the
-negative lookahead assertion contains just one branch.
-</P>
-<P>
-4. Though binary zero characters are supported in the subject string, they are
-not allowed in a pattern string because it is passed as a normal C string,
-terminated by zero. The escape sequence \0 can be used in the pattern to
-represent a binary zero.
-</P>
-<P>
-5. The following Perl escape sequences are not supported: \l, \u, \L,
-\U, and \N. In fact these are implemented by Perl's general string-handling
-and are not part of its pattern matching engine. If any of these are
-encountered by PCRE, an error is generated.
-</P>
-<P>
-6. The Perl escape sequences \p, \P, and \X are supported only if PCRE is
-built with Unicode character property support. The properties that can be
-tested with \p and \P are limited to the general category properties such as
-Lu and Nd.
-</P>
-<P>
-7. PCRE does support the \Q...\E escape for quoting substrings. Characters in
-between are treated as literals. This is slightly different from Perl in that $
-and @ are also handled as literals inside the quotes. In Perl, they cause
-variable interpolation (but of course PCRE does not have variables). Note the
-following examples:
-<pre>
- Pattern PCRE matches Perl matches
-
- \Qabc$xyz\E abc$xyz abc followed by the contents of $xyz
- \Qabc\$xyz\E abc\$xyz abc\$xyz
- \Qabc\E\$\Qxyz\E abc$xyz abc$xyz
-</pre>
-The \Q...\E sequence is recognized both inside and outside character classes.
-</P>
-<P>
-8. Fairly obviously, PCRE does not support the (?{code}) and (?p{code})
-constructions. However, there is support for recursive patterns using the
-non-Perl items (?R), (?number), and (?P>name). Also, the PCRE "callout" feature
-allows an external function to be called during pattern matching. See the
-<a href="pcrecallout.html"><b>pcrecallout</b></a>
-documentation for details.
-</P>
-<P>
-9. There are some differences that are concerned with the settings of captured
-strings when part of a pattern is repeated. For example, matching "aba" against
-the pattern /^(a(b)?)+$/ in Perl leaves $2 unset, but in PCRE it is set to "b".
-</P>
-<P>
-10. PCRE provides some extensions to the Perl regular expression facilities:
-<br>
-<br>
-(a) Although lookbehind assertions must match fixed length strings, each
-alternative branch of a lookbehind assertion can match a different length of
-string. Perl requires them all to have the same length.
-<br>
-<br>
-(b) If PCRE_DOLLAR_ENDONLY is set and PCRE_MULTILINE is not set, the $
-meta-character matches only at the very end of the string.
-<br>
-<br>
-(c) If PCRE_EXTRA is set, a backslash followed by a letter with no special
-meaning is faulted.
-<br>
-<br>
-(d) If PCRE_UNGREEDY is set, the greediness of the repetition quantifiers is
-inverted, that is, by default they are not greedy, but if followed by a
-question mark they are.
-<br>
-<br>
-(e) PCRE_ANCHORED can be used at matching time to force a pattern to be tried
-only at the first matching position in the subject string.
-<br>
-<br>
-(f) The PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, and PCRE_NO_AUTO_CAPTURE
-options for <b>pcre_exec()</b> have no Perl equivalents.
-<br>
-<br>
-(g) The (?R), (?number), and (?P>name) constructs allows for recursive pattern
-matching (Perl can do this using the (?p{code}) construct, which PCRE cannot
-support.)
-<br>
-<br>
-(h) PCRE supports named capturing substrings, using the Python syntax.
-<br>
-<br>
-(i) PCRE supports the possessive quantifier "++" syntax, taken from Sun's Java
-package.
-<br>
-<br>
-(j) The (R) condition, for testing recursion, is a PCRE extension.
-<br>
-<br>
-(k) The callout facility is PCRE-specific.
-<br>
-<br>
-(l) The partial matching facility is PCRE-specific.
-<br>
-<br>
-(m) Patterns compiled by PCRE can be saved and re-used at a later time, even on
-different hosts that have the other endianness.
-</P>
-<P>
-Last updated: 09 September 2004
-<br>
-Copyright © 1997-2004 University of Cambridge.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcregrep specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcregrep man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<ul>
-<li><a name="TOC1" href="#SEC1">SYNOPSIS</a>
-<li><a name="TOC2" href="#SEC2">DESCRIPTION</a>
-<li><a name="TOC3" href="#SEC3">OPTIONS</a>
-<li><a name="TOC4" href="#SEC4">LONG OPTIONS</a>
-<li><a name="TOC5" href="#SEC5">DIAGNOSTICS</a>
-<li><a name="TOC6" href="#SEC6">AUTHOR</a>
-</ul>
-<br><a name="SEC1" href="#TOC1">SYNOPSIS</a><br>
-<P>
-<b>pcregrep [-Vcfhilnrsuvx] [long options] [pattern] [file1 file2 ...]</b>
-</P>
-<br><a name="SEC2" href="#TOC1">DESCRIPTION</a><br>
-<P>
-<b>pcregrep</b> searches files for character patterns, in the same way as other
-grep commands do, but it uses the PCRE regular expression library to support
-patterns that are compatible with the regular expressions of Perl 5. See
-<a href="pcrepattern.html"><b>pcrepattern</b></a>
-for a full description of syntax and semantics of the regular expressions that
-PCRE supports.
-</P>
-<P>
-A pattern must be specified on the command line unless the <b>-f</b> option is
-used (see below).
-</P>
-<P>
-If no files are specified, <b>pcregrep</b> reads the standard input. By default,
-each line that matches the pattern is copied to the standard output, and if
-there is more than one file, the file name is printed before each line of
-output. However, there are options that can change how <b>pcregrep</b> behaves.
-</P>
-<P>
-Lines are limited to BUFSIZ characters. BUFSIZ is defined in <b><stdio.h></b>.
-The newline character is removed from the end of each line before it is matched
-against the pattern.
-</P>
-<br><a name="SEC3" href="#TOC1">OPTIONS</a><br>
-<P>
-<b>-V</b>
-Write the version number of the PCRE library being used to the standard error
-stream.
-</P>
-<P>
-<b>-c</b>
-Do not print individual lines; instead just print a count of the number of
-lines that would otherwise have been printed. If several files are given, a
-count is printed for each of them.
-</P>
-<P>
-<b>-f</b><i>filename</i>
-Read a number of patterns from the file, one per line, and match all of them
-against each line of input. A line is output if any of the patterns match it.
-When <b>-f</b> is used, no pattern is taken from the command line; all arguments
-are treated as file names. There is a maximum of 100 patterns. Trailing white
-space is removed, and blank lines are ignored. An empty file contains no
-patterns and therefore matches nothing.
-</P>
-<P>
-<b>-h</b>
-Suppress printing of filenames when searching multiple files.
-</P>
-<P>
-<b>-i</b>
-Ignore upper/lower case distinctions during comparisons.
-</P>
-<P>
-<b>-l</b>
-Instead of printing lines from the files, just print the names of the files
-containing lines that would have been printed. Each file name is printed
-once, on a separate line.
-</P>
-<P>
-<b>-n</b>
-Precede each line by its line number in the file.
-</P>
-<P>
-<b>-r</b>
-If any file is a directory, recursively scan the files it contains. Without
-<b>-r</b> a directory is scanned as a normal file.
-</P>
-<P>
-<b>-s</b>
-Work silently, that is, display nothing except error messages.
-The exit status indicates whether any matches were found.
-</P>
-<P>
-<b>-u</b>
-Operate in UTF-8 mode. This option is available only if PCRE has been compiled
-with UTF-8 support. Both the pattern and each subject line must be valid
-strings of UTF-8 characters.
-</P>
-<P>
-<b>-v</b>
-Invert the sense of the match, so that lines which do <i>not</i> match the
-pattern are now the ones that are found.
-</P>
-<P>
-<b>-x</b>
-Force the pattern to be anchored (it must start matching at the beginning of
-the line) and in addition, require it to match the entire line. This is
-equivalent to having ^ and $ characters at the start and end of each
-alternative branch in the regular expression.
-</P>
-<br><a name="SEC4" href="#TOC1">LONG OPTIONS</a><br>
-<P>
-Long forms of all the options are available, as in GNU grep. They are shown in
-the following table:
-<pre>
- -c --count
- -h --no-filename
- -i --ignore-case
- -l --files-with-matches
- -n --line-number
- -r --recursive
- -s --no-messages
- -u --utf-8
- -V --version
- -v --invert-match
- -x --line-regex
- -x --line-regexp
-</pre>
-In addition, --file=<i>filename</i> is equivalent to -f<i>filename</i>, and
---help shows the list of options and then exits.
-</P>
-<br><a name="SEC5" href="#TOC1">DIAGNOSTICS</a><br>
-<P>
-Exit status is 0 if any matches were found, 1 if no matches were found, and 2
-for syntax errors or inacessible files (even if matches were found).
-</P>
-<br><a name="SEC6" href="#TOC1">AUTHOR</a><br>
-<P>
-Philip Hazel <ph10@cam.ac.uk>
-<br>
-University Computing Service
-<br>
-Cambridge CB2 3QG, England.
-</P>
-<P>
-Last updated: 09 September 2004
-<br>
-Copyright © 1997-2004 University of Cambridge.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcrepartial specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcrepartial man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<ul>
-<li><a name="TOC1" href="#SEC1">PARTIAL MATCHING IN PCRE</a>
-<li><a name="TOC2" href="#SEC2">RESTRICTED PATTERNS FOR PCRE_PARTIAL</a>
-<li><a name="TOC3" href="#SEC3">EXAMPLE OF PARTIAL MATCHING USING PCRETEST</a>
-</ul>
-<br><a name="SEC1" href="#TOC1">PARTIAL MATCHING IN PCRE</a><br>
-<P>
-In normal use of PCRE, if the subject string that is passed to
-<b>pcre_exec()</b> matches as far as it goes, but is too short to match the
-entire pattern, PCRE_ERROR_NOMATCH is returned. There are circumstances where
-it might be helpful to distinguish this case from other cases in which there is
-no match.
-</P>
-<P>
-Consider, for example, an application where a human is required to type in data
-for a field with specific formatting requirements. An example might be a date
-in the form <i>ddmmmyy</i>, defined by this pattern:
-<pre>
- ^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$
-</pre>
-If the application sees the user's keystrokes one by one, and can check that
-what has been typed so far is potentially valid, it is able to raise an error
-as soon as a mistake is made, possibly beeping and not reflecting the
-character that has been typed. This immediate feedback is likely to be a better
-user interface than a check that is delayed until the entire string has been
-entered.
-</P>
-<P>
-PCRE supports the concept of partial matching by means of the PCRE_PARTIAL
-option, which can be set when calling <b>pcre_exec()</b>. When this is done, the
-return code PCRE_ERROR_NOMATCH is converted into PCRE_ERROR_PARTIAL if at any
-time during the matching process the entire subject string matched part of the
-pattern. No captured data is set when this occurs.
-</P>
-<P>
-Using PCRE_PARTIAL disables one of PCRE's optimizations. PCRE remembers the
-last literal byte in a pattern, and abandons matching immediately if such a
-byte is not present in the subject string. This optimization cannot be used
-for a subject string that might match only partially.
-</P>
-<br><a name="SEC2" href="#TOC1">RESTRICTED PATTERNS FOR PCRE_PARTIAL</a><br>
-<P>
-Because of the way certain internal optimizations are implemented in PCRE, the
-PCRE_PARTIAL option cannot be used with all patterns. Repeated single
-characters such as
-<pre>
- a{2,4}
-</pre>
-and repeated single metasequences such as
-<pre>
- \d+
-</pre>
-are not permitted if the maximum number of occurrences is greater than one.
-Optional items such as \d? (where the maximum is one) are permitted.
-Quantifiers with any values are permitted after parentheses, so the invalid
-examples above can be coded thus:
-<pre>
- (a){2,4}
- (\d)+
-</pre>
-These constructions run more slowly, but for the kinds of application that are
-envisaged for this facility, this is not felt to be a major restriction.
-</P>
-<P>
-If PCRE_PARTIAL is set for a pattern that does not conform to the restrictions,
-<b>pcre_exec()</b> returns the error code PCRE_ERROR_BADPARTIAL (-13).
-</P>
-<br><a name="SEC3" href="#TOC1">EXAMPLE OF PARTIAL MATCHING USING PCRETEST</a><br>
-<P>
-If the escape sequence \P is present in a <b>pcretest</b> data line, the
-PCRE_PARTIAL flag is used for the match. Here is a run of <b>pcretest</b> that
-uses the date example quoted above:
-<pre>
- re> /^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$/
- data> 25jun04\P
- 0: 25jun04
- 1: jun
- data> 25dec3\P
- Partial match
- data> 3ju\P
- Partial match
- data> 3juj\P
- No match
- data> j\P
- No match
-</pre>
-The first data string is matched completely, so <b>pcretest</b> shows the
-matched substrings. The remaining four strings do not match the complete
-pattern, but the first two are partial matches.
-</P>
-<P>
-Last updated: 08 September 2004
-<br>
-Copyright © 1997-2004 University of Cambridge.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcrepattern specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcrepattern man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<ul>
-<li><a name="TOC1" href="#SEC1">PCRE REGULAR EXPRESSION DETAILS</a>
-<li><a name="TOC2" href="#SEC2">BACKSLASH</a>
-<li><a name="TOC3" href="#SEC3">CIRCUMFLEX AND DOLLAR</a>
-<li><a name="TOC4" href="#SEC4">FULL STOP (PERIOD, DOT)</a>
-<li><a name="TOC5" href="#SEC5">MATCHING A SINGLE BYTE</a>
-<li><a name="TOC6" href="#SEC6">SQUARE BRACKETS AND CHARACTER CLASSES</a>
-<li><a name="TOC7" href="#SEC7">POSIX CHARACTER CLASSES</a>
-<li><a name="TOC8" href="#SEC8">VERTICAL BAR</a>
-<li><a name="TOC9" href="#SEC9">INTERNAL OPTION SETTING</a>
-<li><a name="TOC10" href="#SEC10">SUBPATTERNS</a>
-<li><a name="TOC11" href="#SEC11">NAMED SUBPATTERNS</a>
-<li><a name="TOC12" href="#SEC12">REPETITION</a>
-<li><a name="TOC13" href="#SEC13">ATOMIC GROUPING AND POSSESSIVE QUANTIFIERS</a>
-<li><a name="TOC14" href="#SEC14">BACK REFERENCES</a>
-<li><a name="TOC15" href="#SEC15">ASSERTIONS</a>
-<li><a name="TOC16" href="#SEC16">CONDITIONAL SUBPATTERNS</a>
-<li><a name="TOC17" href="#SEC17">COMMENTS</a>
-<li><a name="TOC18" href="#SEC18">RECURSIVE PATTERNS</a>
-<li><a name="TOC19" href="#SEC19">SUBPATTERNS AS SUBROUTINES</a>
-<li><a name="TOC20" href="#SEC20">CALLOUTS</a>
-</ul>
-<br><a name="SEC1" href="#TOC1">PCRE REGULAR EXPRESSION DETAILS</a><br>
-<P>
-The syntax and semantics of the regular expressions supported by PCRE are
-described below. Regular expressions are also described in the Perl
-documentation and in a number of books, some of which have copious examples.
-Jeffrey Friedl's "Mastering Regular Expressions", published by O'Reilly, covers
-regular expressions in great detail. This description of PCRE's regular
-expressions is intended as reference material.
-</P>
-<P>
-The original operation of PCRE was on strings of one-byte characters. However,
-there is now also support for UTF-8 character strings. To use this, you must
-build PCRE to include UTF-8 support, and then call <b>pcre_compile()</b> with
-the PCRE_UTF8 option. How this affects pattern matching is mentioned in several
-places below. There is also a summary of UTF-8 features in the
-<a href="pcre.html#utf8support">section on UTF-8 support</a>
-in the main
-<a href="pcre.html"><b>pcre</b></a>
-page.
-</P>
-<P>
-A regular expression is a pattern that is matched against a subject string from
-left to right. Most characters stand for themselves in a pattern, and match the
-corresponding characters in the subject. As a trivial example, the pattern
-<pre>
- The quick brown fox
-</pre>
-matches a portion of a subject string that is identical to itself. The power of
-regular expressions comes from the ability to include alternatives and
-repetitions in the pattern. These are encoded in the pattern by the use of
-<i>metacharacters</i>, which do not stand for themselves but instead are
-interpreted in some special way.
-</P>
-<P>
-There are two different sets of metacharacters: those that are recognized
-anywhere in the pattern except within square brackets, and those that are
-recognized in square brackets. Outside square brackets, the metacharacters are
-as follows:
-<pre>
- \ general escape character with several uses
- ^ assert start of string (or line, in multiline mode)
- $ assert end of string (or line, in multiline mode)
- . match any character except newline (by default)
- [ start character class definition
- | start of alternative branch
- ( start subpattern
- ) end subpattern
- ? extends the meaning of (
- also 0 or 1 quantifier
- also quantifier minimizer
- * 0 or more quantifier
- + 1 or more quantifier
- also "possessive quantifier"
- { start min/max quantifier
-</pre>
-Part of a pattern that is in square brackets is called a "character class". In
-a character class the only metacharacters are:
-<pre>
- \ general escape character
- ^ negate the class, but only if the first character
- - indicates character range
- [ POSIX character class (only if followed by POSIX syntax)
- ] terminates the character class
-</pre>
-The following sections describe the use of each of the metacharacters.
-</P>
-<br><a name="SEC2" href="#TOC1">BACKSLASH</a><br>
-<P>
-The backslash character has several uses. Firstly, if it is followed by a
-non-alphanumeric character, it takes away any special meaning that character may
-have. This use of backslash as an escape character applies both inside and
-outside character classes.
-</P>
-<P>
-For example, if you want to match a * character, you write \* in the pattern.
-This escaping action applies whether or not the following character would
-otherwise be interpreted as a metacharacter, so it is always safe to precede a
-non-alphanumeric with backslash to specify that it stands for itself. In
-particular, if you want to match a backslash, you write \\.
-</P>
-<P>
-If a pattern is compiled with the PCRE_EXTENDED option, whitespace in the
-pattern (other than in a character class) and characters between a # outside
-a character class and the next newline character are ignored. An escaping
-backslash can be used to include a whitespace or # character as part of the
-pattern.
-</P>
-<P>
-If you want to remove the special meaning from a sequence of characters, you
-can do so by putting them between \Q and \E. This is different from Perl in
-that $ and @ are handled as literals in \Q...\E sequences in PCRE, whereas in
-Perl, $ and @ cause variable interpolation. Note the following examples:
-<pre>
- Pattern PCRE matches Perl matches
-
- \Qabc$xyz\E abc$xyz abc followed by the contents of $xyz
- \Qabc\$xyz\E abc\$xyz abc\$xyz
- \Qabc\E\$\Qxyz\E abc$xyz abc$xyz
-</pre>
-The \Q...\E sequence is recognized both inside and outside character classes.
-<a name="digitsafterbackslash"></a></P>
-<br><b>
-Non-printing characters
-</b><br>
-<P>
-A second use of backslash provides a way of encoding non-printing characters
-in patterns in a visible manner. There is no restriction on the appearance of
-non-printing characters, apart from the binary zero that terminates a pattern,
-but when a pattern is being prepared by text editing, it is usually easier to
-use one of the following escape sequences than the binary character it
-represents:
-<pre>
- \a alarm, that is, the BEL character (hex 07)
- \cx "control-x", where x is any character
- \e escape (hex 1B)
- \f formfeed (hex 0C)
- \n newline (hex 0A)
- \r carriage return (hex 0D)
- \t tab (hex 09)
- \ddd character with octal code ddd, or backreference
- \xhh character with hex code hh
- \x{hhh..} character with hex code hhh... (UTF-8 mode only)
-</pre>
-The precise effect of \cx is as follows: if x is a lower case letter, it
-is converted to upper case. Then bit 6 of the character (hex 40) is inverted.
-Thus \cz becomes hex 1A, but \c{ becomes hex 3B, while \c; becomes hex
-7B.
-</P>
-<P>
-After \x, from zero to two hexadecimal digits are read (letters can be in
-upper or lower case). In UTF-8 mode, any number of hexadecimal digits may
-appear between \x{ and }, but the value of the character code must be less
-than 2**31 (that is, the maximum hexadecimal value is 7FFFFFFF). If characters
-other than hexadecimal digits appear between \x{ and }, or if there is no
-terminating }, this form of escape is not recognized. Instead, the initial
-\x will be interpreted as a basic hexadecimal escape, with no following
-digits, giving a character whose value is zero.
-</P>
-<P>
-Characters whose value is less than 256 can be defined by either of the two
-syntaxes for \x when PCRE is in UTF-8 mode. There is no difference in the
-way they are handled. For example, \xdc is exactly the same as \x{dc}.
-</P>
-<P>
-After \0 up to two further octal digits are read. In both cases, if there
-are fewer than two digits, just those that are present are used. Thus the
-sequence \0\x\07 specifies two binary zeros followed by a BEL character
-(code value 7). Make sure you supply two digits after the initial zero if the
-pattern character that follows is itself an octal digit.
-</P>
-<P>
-The handling of a backslash followed by a digit other than 0 is complicated.
-Outside a character class, PCRE reads it and any following digits as a decimal
-number. If the number is less than 10, or if there have been at least that many
-previous capturing left parentheses in the expression, the entire sequence is
-taken as a <i>back reference</i>. A description of how this works is given
-<a href="#backreferences">later,</a>
-following the discussion of
-<a href="#subpattern">parenthesized subpatterns.</a>
-</P>
-<P>
-Inside a character class, or if the decimal number is greater than 9 and there
-have not been that many capturing subpatterns, PCRE re-reads up to three octal
-digits following the backslash, and generates a single byte from the least
-significant 8 bits of the value. Any subsequent digits stand for themselves.
-For example:
-<pre>
- \040 is another way of writing a space
- \40 is the same, provided there are fewer than 40 previous capturing subpatterns
- \7 is always a back reference
- \11 might be a back reference, or another way of writing a tab
- \011 is always a tab
- \0113 is a tab followed by the character "3"
- \113 might be a back reference, otherwise the character with octal code 113
- \377 might be a back reference, otherwise the byte consisting entirely of 1 bits
- \81 is either a back reference, or a binary zero followed by the two characters "8" and "1"
-</pre>
-Note that octal values of 100 or greater must not be introduced by a leading
-zero, because no more than three octal digits are ever read.
-</P>
-<P>
-All the sequences that define a single byte value or a single UTF-8 character
-(in UTF-8 mode) can be used both inside and outside character classes. In
-addition, inside a character class, the sequence \b is interpreted as the
-backspace character (hex 08), and the sequence \X is interpreted as the
-character "X". Outside a character class, these sequences have different
-meanings
-<a href="#uniextseq">(see below).</a>
-</P>
-<br><b>
-Generic character types
-</b><br>
-<P>
-The third use of backslash is for specifying generic character types. The
-following are always recognized:
-<pre>
- \d any decimal digit
- \D any character that is not a decimal digit
- \s any whitespace character
- \S any character that is not a whitespace character
- \w any "word" character
- \W any "non-word" character
-</pre>
-Each pair of escape sequences partitions the complete set of characters into
-two disjoint sets. Any given character matches one, and only one, of each pair.
-</P>
-<P>
-These character type sequences can appear both inside and outside character
-classes. They each match one character of the appropriate type. If the current
-matching point is at the end of the subject string, all of them fail, since
-there is no character to match.
-</P>
-<P>
-For compatibility with Perl, \s does not match the VT character (code 11).
-This makes it different from the the POSIX "space" class. The \s characters
-are HT (9), LF (10), FF (12), CR (13), and space (32).
-</P>
-<P>
-A "word" character is an underscore or any character less than 256 that is a
-letter or digit. The definition of letters and digits is controlled by PCRE's
-low-valued character tables, and may vary if locale-specific matching is taking
-place (see
-<a href="pcreapi.html#localesupport">"Locale support"</a>
-in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-page). For example, in the "fr_FR" (French) locale, some character codes
-greater than 128 are used for accented letters, and these are matched by \w.
-</P>
-<P>
-In UTF-8 mode, characters with values greater than 128 never match \d, \s, or
-\w, and always match \D, \S, and \W. This is true even when Unicode
-character property support is available.
-<a name="uniextseq"></a></P>
-<br><b>
-Unicode character properties
-</b><br>
-<P>
-When PCRE is built with Unicode character property support, three additional
-escape sequences to match generic character types are available when UTF-8 mode
-is selected. They are:
-<pre>
- \p{<i>xx</i>} a character with the <i>xx</i> property
- \P{<i>xx</i>} a character without the <i>xx</i> property
- \X an extended Unicode sequence
-</pre>
-The property names represented by <i>xx</i> above are limited to the
-Unicode general category properties. Each character has exactly one such
-property, specified by a two-letter abbreviation. For compatibility with Perl,
-negation can be specified by including a circumflex between the opening brace
-and the property name. For example, \p{^Lu} is the same as \P{Lu}.
-</P>
-<P>
-If only one letter is specified with \p or \P, it includes all the properties
-that start with that letter. In this case, in the absence of negation, the
-curly brackets in the escape sequence are optional; these two examples have
-the same effect:
-<pre>
- \p{L}
- \pL
-</pre>
-The following property codes are supported:
-<pre>
- C Other
- Cc Control
- Cf Format
- Cn Unassigned
- Co Private use
- Cs Surrogate
-
- L Letter
- Ll Lower case letter
- Lm Modifier letter
- Lo Other letter
- Lt Title case letter
- Lu Upper case letter
-
- M Mark
- Mc Spacing mark
- Me Enclosing mark
- Mn Non-spacing mark
-
- N Number
- Nd Decimal number
- Nl Letter number
- No Other number
-
- P Punctuation
- Pc Connector punctuation
- Pd Dash punctuation
- Pe Close punctuation
- Pf Final punctuation
- Pi Initial punctuation
- Po Other punctuation
- Ps Open punctuation
-
- S Symbol
- Sc Currency symbol
- Sk Modifier symbol
- Sm Mathematical symbol
- So Other symbol
-
- Z Separator
- Zl Line separator
- Zp Paragraph separator
- Zs Space separator
-</pre>
-Extended properties such as "Greek" or "InMusicalSymbols" are not supported by
-PCRE.
-</P>
-<P>
-Specifying caseless matching does not affect these escape sequences. For
-example, \p{Lu} always matches only upper case letters.
-</P>
-<P>
-The \X escape matches any number of Unicode characters that form an extended
-Unicode sequence. \X is equivalent to
-<pre>
- (?>\PM\pM*)
-</pre>
-That is, it matches a character without the "mark" property, followed by zero
-or more characters with the "mark" property, and treats the sequence as an
-atomic group
-<a href="#atomicgroup">(see below).</a>
-Characters with the "mark" property are typically accents that affect the
-preceding character.
-</P>
-<P>
-Matching characters by Unicode property is not fast, because PCRE has to search
-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="smallassertions"></a></P>
-<br><b>
-Simple assertions
-</b><br>
-<P>
-The fourth use of backslash is for certain simple assertions. An assertion
-specifies a condition that has to be met at a particular point in a match,
-without consuming any characters from the subject string. The use of
-subpatterns for more complicated assertions is described
-<a href="#bigassertions">below.</a>
-The backslashed
-assertions are:
-<pre>
- \b matches at a word boundary
- \B matches when not at a word boundary
- \A matches at start of subject
- \Z matches at end of subject or before newline at end
- \z matches at end of subject
- \G matches at first matching position in subject
-</pre>
-These assertions may not appear in character classes (but note that \b has a
-different meaning, namely the backspace character, inside a character class).
-</P>
-<P>
-A word boundary is a position in the subject string where the current character
-and the previous character do not both match \w or \W (i.e. one matches
-\w and the other matches \W), or the start or end of the string if the
-first or last character matches \w, respectively.
-</P>
-<P>
-The \A, \Z, and \z assertions differ from the traditional circumflex and
-dollar (described in the next section) in that they only ever match at the very
-start and end of the subject string, whatever options are set. Thus, they are
-independent of multiline mode. These three assertions are not affected by the
-PCRE_NOTBOL or PCRE_NOTEOL options, which affect only the behaviour of the
-circumflex and dollar metacharacters. However, if the <i>startoffset</i>
-argument of <b>pcre_exec()</b> is non-zero, indicating that matching is to start
-at a point other than the beginning of the subject, \A can never match. The
-difference between \Z and \z is that \Z matches before a newline that is the
-last character of the string as well as at the end of the string, whereas \z
-matches only at the end.
-</P>
-<P>
-The \G assertion is true only when the current matching position is at the
-start point of the match, as specified by the <i>startoffset</i> argument of
-<b>pcre_exec()</b>. It differs from \A when the value of <i>startoffset</i> is
-non-zero. By calling <b>pcre_exec()</b> multiple times with appropriate
-arguments, you can mimic Perl's /g option, and it is in this kind of
-implementation where \G can be useful.
-</P>
-<P>
-Note, however, that PCRE's interpretation of \G, as the start of the current
-match, is subtly different from Perl's, which defines it as the end of the
-previous match. In Perl, these can be different when the previously matched
-string was empty. Because PCRE does just one match at a time, it cannot
-reproduce this behaviour.
-</P>
-<P>
-If all the alternatives of a pattern begin with \G, the expression is anchored
-to the starting match position, and the "anchored" flag is set in the compiled
-regular expression.
-</P>
-<br><a name="SEC3" href="#TOC1">CIRCUMFLEX AND DOLLAR</a><br>
-<P>
-Outside a character class, in the default matching mode, the circumflex
-character is an assertion that is true only if the current matching point is
-at the start of the subject string. If the <i>startoffset</i> argument of
-<b>pcre_exec()</b> is non-zero, circumflex can never match if the PCRE_MULTILINE
-option is unset. Inside a character class, circumflex has an entirely different
-meaning
-<a href="#characterclass">(see below).</a>
-</P>
-<P>
-Circumflex need not be the first character of the pattern if a number of
-alternatives are involved, but it should be the first thing in each alternative
-in which it appears if the pattern is ever to match that branch. If all
-possible alternatives start with a circumflex, that is, if the pattern is
-constrained to match only at the start of the subject, it is said to be an
-"anchored" pattern. (There are also other constructs that can cause a pattern
-to be anchored.)
-</P>
-<P>
-A dollar character is an assertion that is true only if the current matching
-point is at the end of the subject string, or immediately before a newline
-character that is the last character in the string (by default). Dollar need
-not be the last character of the pattern if a number of alternatives are
-involved, but it should be the last item in any branch in which it appears.
-Dollar has no special meaning in a character class.
-</P>
-<P>
-The meaning of dollar can be changed so that it matches only at the very end of
-the string, by setting the PCRE_DOLLAR_ENDONLY option at compile time. This
-does not affect the \Z assertion.
-</P>
-<P>
-The meanings of the circumflex and dollar characters are changed if the
-PCRE_MULTILINE option is set. When this is the case, they match immediately
-after and immediately before an internal newline character, respectively, in
-addition to matching at the start and end of the subject string. For example,
-the pattern /^abc$/ matches the subject string "def\nabc" (where \n
-represents a newline character) in multiline mode, but not otherwise.
-Consequently, patterns that are anchored in single line mode because all
-branches start with ^ are not anchored in multiline mode, and a match for
-circumflex is possible when the <i>startoffset</i> argument of <b>pcre_exec()</b>
-is non-zero. The PCRE_DOLLAR_ENDONLY option is ignored if PCRE_MULTILINE is
-set.
-</P>
-<P>
-Note that the sequences \A, \Z, and \z can be used to match the start and
-end of the subject in both modes, and if all branches of a pattern start with
-\A it is always anchored, whether PCRE_MULTILINE is set or not.
-</P>
-<br><a name="SEC4" href="#TOC1">FULL STOP (PERIOD, DOT)</a><br>
-<P>
-Outside a character class, a dot in the pattern matches any one character in
-the subject, including a non-printing character, but not (by default) newline.
-In UTF-8 mode, a dot matches any UTF-8 character, which might be more than one
-byte long, except (by default) newline. If the PCRE_DOTALL option is set,
-dots match newlines as well. The handling of dot is entirely independent of the
-handling of circumflex and dollar, the only relationship being that they both
-involve newline characters. Dot has no special meaning in a character class.
-</P>
-<br><a name="SEC5" href="#TOC1">MATCHING A SINGLE BYTE</a><br>
-<P>
-Outside a character class, the escape sequence \C matches any one byte, both
-in and out of UTF-8 mode. Unlike a dot, it can match a newline. The feature is
-provided in Perl in order to match individual bytes in UTF-8 mode. Because it
-breaks up UTF-8 characters into individual bytes, what remains in the string
-may be a malformed UTF-8 string. For this reason, the \C escape sequence is
-best avoided.
-</P>
-<P>
-PCRE does not allow \C to appear in lookbehind assertions
-<a href="#lookbehind">(described below),</a>
-because in UTF-8 mode this would make it impossible to calculate the length of
-the lookbehind.
-<a name="characterclass"></a></P>
-<br><a name="SEC6" href="#TOC1">SQUARE BRACKETS AND CHARACTER CLASSES</a><br>
-<P>
-An opening square bracket introduces a character class, terminated by a closing
-square bracket. A closing square bracket on its own is not special. If a
-closing square bracket is required as a member of the class, it should be the
-first data character in the class (after an initial circumflex, if present) or
-escaped with a backslash.
-</P>
-<P>
-A character class matches a single character in the subject. In UTF-8 mode, the
-character may occupy more than one byte. A matched character must be in the set
-of characters defined by the class, unless the first character in the class
-definition is a circumflex, in which case the subject character must not be in
-the set defined by the class. If a circumflex is actually required as a member
-of the class, ensure it is not the first character, or escape it with a
-backslash.
-</P>
-<P>
-For example, the character class [aeiou] matches any lower case vowel, while
-[^aeiou] matches any character that is not a lower case vowel. Note that a
-circumflex is just a convenient notation for specifying the characters that
-are in the class by enumerating those that are not. A class that starts with a
-circumflex is not an assertion: it still consumes a character from the subject
-string, and therefore it fails if the current pointer is at the end of the
-string.
-</P>
-<P>
-In UTF-8 mode, characters with values greater than 255 can be included in a
-class as a literal string of bytes, or by using the \x{ escaping mechanism.
-</P>
-<P>
-When caseless matching is set, any letters in a class represent both their
-upper case and lower case versions, so for example, a caseless [aeiou] matches
-"A" as well as "a", and a caseless [^aeiou] does not match "A", whereas a
-caseful version would. When running 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.
-</P>
-<P>
-The newline character is never treated in any special way in character classes,
-whatever the setting of the PCRE_DOTALL or PCRE_MULTILINE options is. A class
-such as [^a] will always match a newline.
-</P>
-<P>
-The minus (hyphen) character can be used to specify a range of characters in a
-character class. For example, [d-m] matches any letter between d and m,
-inclusive. If a minus character is required in a class, it must be escaped with
-a backslash or appear in a position where it cannot be interpreted as
-indicating a range, typically as the first or last character in the class.
-</P>
-<P>
-It is not possible to have the literal character "]" as the end character of a
-range. A pattern such as [W-]46] is interpreted as a class of two characters
-("W" and "-") followed by a literal string "46]", so it would match "W46]" or
-"-46]". However, if the "]" is escaped with a backslash it is interpreted as
-the end of range, so [W-\]46] is interpreted as a class containing a range
-followed by two other characters. The octal or hexadecimal representation of
-"]" can also be used to end a range.
-</P>
-<P>
-Ranges operate in the collating sequence of character values. They can also be
-used for characters specified numerically, for example [\000-\037]. In UTF-8
-mode, ranges can include characters whose values are greater than 255, for
-example [\x{100}-\x{2ff}].
-</P>
-<P>
-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
-[][\\^_`wxyzabc], matched caselessly, and in non-UTF-8 mode, if character
-tables for the "fr_FR" locale are in use, [\xc8-\xcb] 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.
-</P>
-<P>
-The character types \d, \D, \p, \P, \s, \S, \w, and \W may also appear
-in a character class, and add the characters that they match to the class. For
-example, [\dABCDEF] matches any hexadecimal digit. A circumflex can
-conveniently be used with the upper case character types to specify a more
-restricted set of characters than the matching lower case type. For example,
-the class [^\W_] matches any letter or digit, but not underscore.
-</P>
-<P>
-The only metacharacters that are recognized in character classes are backslash,
-hyphen (only where it can be interpreted as specifying a range), circumflex
-(only at the start), opening square bracket (only when it can be interpreted as
-introducing a POSIX class name - see the next section), and the terminating
-closing square bracket. However, escaping other non-alphanumeric characters
-does no harm.
-</P>
-<br><a name="SEC7" href="#TOC1">POSIX CHARACTER CLASSES</a><br>
-<P>
-Perl supports the POSIX notation for character classes. This uses names
-enclosed by [: and :] within the enclosing square brackets. PCRE also supports
-this notation. For example,
-<pre>
- [01[:alpha:]%]
-</pre>
-matches "0", "1", any alphabetic character, or "%". The supported class names
-are
-<pre>
- alnum letters and digits
- alpha letters
- ascii character codes 0 - 127
- blank space or tab only
- cntrl control characters
- digit decimal digits (same as \d)
- graph printing characters, excluding space
- lower lower case letters
- print printing characters, including space
- punct printing characters, excluding letters and digits
- space white space (not quite the same as \s)
- upper upper case letters
- word "word" characters (same as \w)
- xdigit hexadecimal digits
-</pre>
-The "space" characters are HT (9), LF (10), VT (11), FF (12), CR (13), and
-space (32). Notice that this list includes the VT character (code 11). This
-makes "space" different to \s, which does not include VT (for Perl
-compatibility).
-</P>
-<P>
-The name "word" is a Perl extension, and "blank" is a GNU extension from Perl
-5.8. Another Perl extension is negation, which is indicated by a ^ character
-after the colon. For example,
-<pre>
- [12[:^digit:]]
-</pre>
-matches "1", "2", or any non-digit. PCRE (and Perl) also recognize the POSIX
-syntax [.ch.] and [=ch=] where "ch" is a "collating element", but these are not
-supported, and an error is given if they are encountered.
-</P>
-<P>
-In UTF-8 mode, characters with values greater than 128 do not match any of
-the POSIX character classes.
-</P>
-<br><a name="SEC8" href="#TOC1">VERTICAL BAR</a><br>
-<P>
-Vertical bar characters are used to separate alternative patterns. For example,
-the pattern
-<pre>
- gilbert|sullivan
-</pre>
-matches either "gilbert" or "sullivan". Any number of alternatives may appear,
-and an empty alternative is permitted (matching the empty string).
-The matching process tries each alternative in turn, from left to right,
-and the first one that succeeds is used. If the alternatives are within a
-subpattern
-<a href="#subpattern">(defined below),</a>
-"succeeds" means matching the rest of the main pattern as well as the
-alternative in the subpattern.
-</P>
-<br><a name="SEC9" href="#TOC1">INTERNAL OPTION SETTING</a><br>
-<P>
-The settings of the PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, and
-PCRE_EXTENDED options can be changed from within the pattern by a sequence of
-Perl option letters enclosed between "(?" and ")". The option letters are
-<pre>
- i for PCRE_CASELESS
- m for PCRE_MULTILINE
- s for PCRE_DOTALL
- x for PCRE_EXTENDED
-</pre>
-For example, (?im) sets caseless, multiline matching. It is also possible to
-unset these options by preceding the letter with a hyphen, and a combined
-setting and unsetting such as (?im-sx), which sets PCRE_CASELESS and
-PCRE_MULTILINE while unsetting PCRE_DOTALL and PCRE_EXTENDED, is also
-permitted. If a letter appears both before and after the hyphen, the option is
-unset.
-</P>
-<P>
-When an option change occurs at top level (that is, not inside subpattern
-parentheses), the change applies to the remainder of the pattern that follows.
-If the change is placed right at the start of a pattern, PCRE extracts it into
-the global options (and it will therefore show up in data extracted by the
-<b>pcre_fullinfo()</b> function).
-</P>
-<P>
-An option change within a subpattern affects only that part of the current
-pattern that follows it, so
-<pre>
- (a(?i)b)c
-</pre>
-matches abc and aBc and no other strings (assuming PCRE_CASELESS is not used).
-By this means, options can be made to have different settings in different
-parts of the pattern. Any changes made in one alternative do carry on
-into subsequent branches within the same subpattern. For example,
-<pre>
- (a(?i)b|c)
-</pre>
-matches "ab", "aB", "c", and "C", even though when matching "C" the first
-branch is abandoned before the option setting. This is because the effects of
-option settings happen at compile time. There would be some very weird
-behaviour otherwise.
-</P>
-<P>
-The PCRE-specific options PCRE_UNGREEDY and PCRE_EXTRA can be changed in the
-same way as the Perl-compatible options by using the characters U and X
-respectively. The (?X) flag setting is special in that it must always occur
-earlier in the pattern than any of the additional features it turns on, even
-when it is at top level. It is best to put it at the start.
-<a name="subpattern"></a></P>
-<br><a name="SEC10" href="#TOC1">SUBPATTERNS</a><br>
-<P>
-Subpatterns are delimited by parentheses (round brackets), which can be nested.
-Turning part of a pattern into a subpattern does two things:
-<br>
-<br>
-1. It localizes a set of alternatives. For example, the pattern
-<pre>
- cat(aract|erpillar|)
-</pre>
-matches one of the words "cat", "cataract", or "caterpillar". Without the
-parentheses, it would match "cataract", "erpillar" or the empty string.
-<br>
-<br>
-2. It sets up the subpattern as a capturing subpattern. This means that, when
-the whole pattern matches, that portion of the subject string that matched the
-subpattern is passed back to the caller via the <i>ovector</i> argument of
-<b>pcre_exec()</b>. Opening parentheses are counted from left to right (starting
-from 1) to obtain numbers for the capturing subpatterns.
-</P>
-<P>
-For example, if the string "the red king" is matched against the pattern
-<pre>
- the ((red|white) (king|queen))
-</pre>
-the captured substrings are "red king", "red", and "king", and are numbered 1,
-2, and 3, respectively.
-</P>
-<P>
-The fact that plain parentheses fulfil two functions is not always helpful.
-There are often times when a grouping subpattern is required without a
-capturing requirement. If an opening parenthesis is followed by a question mark
-and a colon, the subpattern does not do any capturing, and is not counted when
-computing the number of any subsequent capturing subpatterns. For example, if
-the string "the white queen" is matched against the pattern
-<pre>
- the ((?:red|white) (king|queen))
-</pre>
-the captured substrings are "white queen" and "queen", and are numbered 1 and
-2. The maximum number of capturing subpatterns is 65535, and the maximum depth
-of nesting of all subpatterns, both capturing and non-capturing, is 200.
-</P>
-<P>
-As a convenient shorthand, if any option settings are required at the start of
-a non-capturing subpattern, the option letters may appear between the "?" and
-the ":". Thus the two patterns
-<pre>
- (?i:saturday|sunday)
- (?:(?i)saturday|sunday)
-</pre>
-match exactly the same set of strings. Because alternative branches are tried
-from left to right, and options are not reset until the end of the subpattern
-is reached, an option setting in one branch does affect subsequent branches, so
-the above patterns match "SUNDAY" as well as "Saturday".
-</P>
-<br><a name="SEC11" href="#TOC1">NAMED SUBPATTERNS</a><br>
-<P>
-Identifying capturing parentheses by number is simple, but it can be very hard
-to keep track of the numbers in complicated regular expressions. Furthermore,
-if an expression is modified, the numbers may change. To help with this
-difficulty, PCRE supports the naming of subpatterns, something that Perl does
-not provide. The Python syntax (?P<name>...) is used. Names consist of
-alphanumeric characters and underscores, and must be unique within a pattern.
-</P>
-<P>
-Named capturing parentheses are still allocated numbers as well as names. The
-PCRE API provides function calls for extracting the name-to-number translation
-table from a compiled pattern. There is also a convenience function for
-extracting a captured substring by name. For further details see the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-documentation.
-</P>
-<br><a name="SEC12" href="#TOC1">REPETITION</a><br>
-<P>
-Repetition is specified by quantifiers, which can follow any of the following
-items:
-<pre>
- a literal data character
- the . metacharacter
- the \C escape sequence
- the \X escape sequence (in UTF-8 mode with Unicode properties)
- an escape such as \d that matches a single character
- a character class
- a back reference (see next section)
- a parenthesized subpattern (unless it is an assertion)
-</pre>
-The general repetition quantifier specifies a minimum and maximum number of
-permitted matches, by giving the two numbers in curly brackets (braces),
-separated by a comma. The numbers must be less than 65536, and the first must
-be less than or equal to the second. For example:
-<pre>
- z{2,4}
-</pre>
-matches "zz", "zzz", or "zzzz". A closing brace on its own is not a special
-character. If the second number is omitted, but the comma is present, there is
-no upper limit; if the second number and the comma are both omitted, the
-quantifier specifies an exact number of required matches. Thus
-<pre>
- [aeiou]{3,}
-</pre>
-matches at least 3 successive vowels, but may match many more, while
-<pre>
- \d{8}
-</pre>
-matches exactly 8 digits. An opening curly bracket that appears in a position
-where a quantifier is not allowed, or one that does not match the syntax of a
-quantifier, is taken as a literal character. For example, {,6} is not a
-quantifier, but a literal string of four characters.
-</P>
-<P>
-In UTF-8 mode, quantifiers apply to UTF-8 characters rather than to individual
-bytes. Thus, for example, \x{100}{2} matches two UTF-8 characters, each of
-which is represented by a two-byte sequence. Similarly, when Unicode property
-support is available, \X{3} matches three Unicode extended sequences, each of
-which may be several bytes long (and they may be of different lengths).
-</P>
-<P>
-The quantifier {0} is permitted, causing the expression to behave as if the
-previous item and the quantifier were not present.
-</P>
-<P>
-For convenience (and historical compatibility) the three most common
-quantifiers have single-character abbreviations:
-<pre>
- * is equivalent to {0,}
- + is equivalent to {1,}
- ? is equivalent to {0,1}
-</pre>
-It is possible to construct infinite loops by following a subpattern that can
-match no characters with a quantifier that has no upper limit, for example:
-<pre>
- (a?)*
-</pre>
-Earlier versions of Perl and PCRE used to give an error at compile time for
-such patterns. However, because there are cases where this can be useful, such
-patterns are now accepted, but if any repetition of the subpattern does in fact
-match no characters, the loop is forcibly broken.
-</P>
-<P>
-By default, the quantifiers are "greedy", that is, they match as much as
-possible (up to the maximum number of permitted times), without causing the
-rest of the pattern to fail. The classic example of where this gives problems
-is in trying to match comments in C programs. These appear between /* and */
-and within the comment, individual * and / characters may appear. An attempt to
-match C comments by applying the pattern
-<pre>
- /\*.*\*/
-</pre>
-to the string
-<pre>
- /* first comment */ not comment /* second comment */
-</pre>
-fails, because it matches the entire string owing to the greediness of the .*
-item.
-</P>
-<P>
-However, if a quantifier is followed by a question mark, it ceases to be
-greedy, and instead matches the minimum number of times possible, so the
-pattern
-<pre>
- /\*.*?\*/
-</pre>
-does the right thing with the C comments. The meaning of the various
-quantifiers is not otherwise changed, just the preferred number of matches.
-Do not confuse this use of question mark with its use as a quantifier in its
-own right. Because it has two uses, it can sometimes appear doubled, as in
-<pre>
- \d??\d
-</pre>
-which matches one digit by preference, but can match two if that is the only
-way the rest of the pattern matches.
-</P>
-<P>
-If the PCRE_UNGREEDY option is set (an option which is not available in Perl),
-the quantifiers are not greedy by default, but individual ones can be made
-greedy by following them with a question mark. In other words, it inverts the
-default behaviour.
-</P>
-<P>
-When a parenthesized subpattern is quantified with a minimum repeat count that
-is greater than 1 or with a limited maximum, more memory is required for the
-compiled pattern, in proportion to the size of the minimum or maximum.
-</P>
-<P>
-If a pattern starts with .* or .{0,} and the PCRE_DOTALL option (equivalent
-to Perl's /s) is set, thus allowing the . to match newlines, the pattern is
-implicitly anchored, because whatever follows will be tried against every
-character position in the subject string, so there is no point in retrying the
-overall match at any position after the first. PCRE normally treats such a
-pattern as though it were preceded by \A.
-</P>
-<P>
-In cases where it is known that the subject string contains no newlines, it is
-worth setting PCRE_DOTALL in order to obtain this optimization, or
-alternatively using ^ to indicate anchoring explicitly.
-</P>
-<P>
-However, there is one situation where the optimization cannot be used. When .*
-is inside capturing parentheses that are the subject of a backreference
-elsewhere in the pattern, a match at the start may fail, and a later one
-succeed. Consider, for example:
-<pre>
- (.*)abc\1
-</pre>
-If the subject is "xyz123abc123" the match point is the fourth character. For
-this reason, such a pattern is not implicitly anchored.
-</P>
-<P>
-When a capturing subpattern is repeated, the value captured is the substring
-that matched the final iteration. For example, after
-<pre>
- (tweedle[dume]{3}\s*)+
-</pre>
-has matched "tweedledum tweedledee" the value of the captured substring is
-"tweedledee". However, if there are nested capturing subpatterns, the
-corresponding captured values may have been set in previous iterations. For
-example, after
-<pre>
- /(a|(b))+/
-</pre>
-matches "aba" the value of the second captured substring is "b".
-<a name="atomicgroup"></a></P>
-<br><a name="SEC13" href="#TOC1">ATOMIC GROUPING AND POSSESSIVE QUANTIFIERS</a><br>
-<P>
-With both maximizing and minimizing repetition, failure of what follows
-normally causes the repeated item to be re-evaluated to see if a different
-number of repeats allows the rest of the pattern to match. Sometimes it is
-useful to prevent this, either to change the nature of the match, or to cause
-it fail earlier than it otherwise might, when the author of the pattern knows
-there is no point in carrying on.
-</P>
-<P>
-Consider, for example, the pattern \d+foo when applied to the subject line
-<pre>
- 123456bar
-</pre>
-After matching all 6 digits and then failing to match "foo", the normal
-action of the matcher is to try again with only 5 digits matching the \d+
-item, and then with 4, and so on, before ultimately failing. "Atomic grouping"
-(a term taken from Jeffrey Friedl's book) provides the means for specifying
-that once a subpattern has matched, it is not to be re-evaluated in this way.
-</P>
-<P>
-If we use atomic grouping for the previous example, the matcher would give up
-immediately on failing to match "foo" the first time. The notation is a kind of
-special parenthesis, starting with (?> as in this example:
-<pre>
- (?>\d+)foo
-</pre>
-This kind of parenthesis "locks up" the part of the pattern it contains once
-it has matched, and a failure further into the pattern is prevented from
-backtracking into it. Backtracking past it to previous items, however, works as
-normal.
-</P>
-<P>
-An alternative description is that a subpattern of this type matches the string
-of characters that an identical standalone pattern would match, if anchored at
-the current point in the subject string.
-</P>
-<P>
-Atomic grouping subpatterns are not capturing subpatterns. Simple cases such as
-the above example can be thought of as a maximizing repeat that must swallow
-everything it can. So, while both \d+ and \d+? are prepared to adjust the
-number of digits they match in order to make the rest of the pattern match,
-(?>\d+) can only match an entire sequence of digits.
-</P>
-<P>
-Atomic groups in general can of course contain arbitrarily complicated
-subpatterns, and can be nested. However, when the subpattern for an atomic
-group is just a single repeated item, as in the example above, a simpler
-notation, called a "possessive quantifier" can be used. This consists of an
-additional + character following a quantifier. Using this notation, the
-previous example can be rewritten as
-<pre>
- \d++foo
-</pre>
-Possessive quantifiers are always greedy; the setting of the PCRE_UNGREEDY
-option is ignored. They are a convenient notation for the simpler forms of
-atomic group. However, there is no difference in the meaning or processing of a
-possessive quantifier and the equivalent atomic group.
-</P>
-<P>
-The possessive quantifier syntax is an extension to the Perl syntax. It
-originates in Sun's Java package.
-</P>
-<P>
-When a pattern contains an unlimited repeat inside a subpattern that can itself
-be repeated an unlimited number of times, the use of an atomic group is the
-only way to avoid some failing matches taking a very long time indeed. The
-pattern
-<pre>
- (\D+|<\d+>)*[!?]
-</pre>
-matches an unlimited number of substrings that either consist of non-digits, or
-digits enclosed in <>, followed by either ! or ?. When it matches, it runs
-quickly. However, if it is applied to
-<pre>
- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-</pre>
-it takes a long time before reporting failure. This is because the string can
-be divided between the internal \D+ repeat and the external * repeat in a
-large number of ways, and all have to be tried. (The example uses [!?] rather
-than a single character at the end, because both PCRE and Perl have an
-optimization that allows for fast failure when a single character is used. They
-remember the last single character that is required for a match, and fail early
-if it is not present in the string.) If the pattern is changed so that it uses
-an atomic group, like this:
-<pre>
- ((?>\D+)|<\d+>)*[!?]
-</pre>
-sequences of non-digits cannot be broken, and failure happens quickly.
-<a name="backreferences"></a></P>
-<br><a name="SEC14" href="#TOC1">BACK REFERENCES</a><br>
-<P>
-Outside a character class, a backslash followed by a digit greater than 0 (and
-possibly further digits) is a back reference to a capturing subpattern earlier
-(that is, to its left) in the pattern, provided there have been that many
-previous capturing left parentheses.
-</P>
-<P>
-However, if the decimal number following the backslash is less than 10, it is
-always taken as a back reference, and causes an error only if there are not
-that many capturing left parentheses in the entire pattern. In other words, the
-parentheses that are referenced need not be to the left of the reference for
-numbers less than 10. See the subsection entitled "Non-printing characters"
-<a href="#digitsafterbackslash">above</a>
-for further details of the handling of digits following a backslash.
-</P>
-<P>
-A back reference matches whatever actually matched the capturing subpattern in
-the current subject string, rather than anything matching the subpattern
-itself (see
-<a href="#subpatternsassubroutines">"Subpatterns as subroutines"</a>
-below for a way of doing that). So the pattern
-<pre>
- (sens|respons)e and \1ibility
-</pre>
-matches "sense and sensibility" and "response and responsibility", but not
-"sense and responsibility". If caseful matching is in force at the time of the
-back reference, the case of letters is relevant. For example,
-<pre>
- ((?i)rah)\s+\1
-</pre>
-matches "rah rah" and "RAH RAH", but not "RAH rah", even though the original
-capturing subpattern is matched caselessly.
-</P>
-<P>
-Back references to named subpatterns use the Python syntax (?P=name). We could
-rewrite the above example as follows:
-<pre>
- (?<p1>(?i)rah)\s+(?P=p1)
-</pre>
-There may be more than one back reference to the same subpattern. If a
-subpattern has not actually been used in a particular match, any back
-references to it always fail. For example, the pattern
-<pre>
- (a|(bc))\2
-</pre>
-always fails if it starts to match "a" rather than "bc". Because there may be
-many capturing parentheses in a pattern, all digits following the backslash are
-taken as part of a potential back reference number. If the pattern continues
-with a digit character, some delimiter must be used to terminate the back
-reference. If the PCRE_EXTENDED option is set, this can be whitespace.
-Otherwise an empty comment (see
-<a href="#comments">"Comments"</a>
-below) can be used.
-</P>
-<P>
-A back reference that occurs inside the parentheses to which it refers fails
-when the subpattern is first used, so, for example, (a\1) never matches.
-However, such references can be useful inside repeated subpatterns. For
-example, the pattern
-<pre>
- (a|b\1)+
-</pre>
-matches any number of "a"s and also "aba", "ababbaa" etc. At each iteration of
-the subpattern, the back reference matches the character string corresponding
-to the previous iteration. In order for this to work, the pattern must be such
-that the first iteration does not need to match the back reference. This can be
-done using alternation, as in the example above, or by a quantifier with a
-minimum of zero.
-<a name="bigassertions"></a></P>
-<br><a name="SEC15" href="#TOC1">ASSERTIONS</a><br>
-<P>
-An assertion is a test on the characters following or preceding the current
-matching point that does not actually consume any characters. The simple
-assertions coded as \b, \B, \A, \G, \Z, \z, ^ and $ are described
-<a href="#smallassertions">above.</a>
-</P>
-<P>
-More complicated assertions are coded as subpatterns. There are two kinds:
-those that look ahead of the current position in the subject string, and those
-that look behind it. An assertion subpattern is matched in the normal way,
-except that it does not cause the current matching position to be changed.
-</P>
-<P>
-Assertion subpatterns are not capturing subpatterns, and may not be repeated,
-because it makes no sense to assert the same thing several times. If any kind
-of assertion contains capturing subpatterns within it, these are counted for
-the purposes of numbering the capturing subpatterns in the whole pattern.
-However, substring capturing is carried out only for positive assertions,
-because it does not make sense for negative assertions.
-</P>
-<br><b>
-Lookahead assertions
-</b><br>
-<P>
-Lookahead assertions start
-with (?= for positive assertions and (?! for negative assertions. For example,
-<pre>
- \w+(?=;)
-</pre>
-matches a word followed by a semicolon, but does not include the semicolon in
-the match, and
-<pre>
- foo(?!bar)
-</pre>
-matches any occurrence of "foo" that is not followed by "bar". Note that the
-apparently similar pattern
-<pre>
- (?!foo)bar
-</pre>
-does not find an occurrence of "bar" that is preceded by something other than
-"foo"; it finds any occurrence of "bar" whatsoever, because the assertion
-(?!foo) is always true when the next three characters are "bar". A
-lookbehind assertion is needed to achieve the other effect.
-</P>
-<P>
-If you want to force a matching failure at some point in a pattern, the most
-convenient way to do it is with (?!) because an empty string always matches, so
-an assertion that requires there not to be an empty string must always fail.
-<a name="lookbehind"></a></P>
-<br><b>
-Lookbehind assertions
-</b><br>
-<P>
-Lookbehind assertions start with (?<= for positive assertions and (?<! for
-negative assertions. For example,
-<pre>
- (?<!foo)bar
-</pre>
-does find an occurrence of "bar" that is not preceded by "foo". The contents of
-a lookbehind assertion are restricted such that all the strings it matches must
-have a fixed length. However, if there are several alternatives, they do not
-all have to have the same fixed length. Thus
-<pre>
- (?<=bullock|donkey)
-</pre>
-is permitted, but
-<pre>
- (?<!dogs?|cats?)
-</pre>
-causes an error at compile time. Branches that match different length strings
-are permitted only at the top level of a lookbehind assertion. This is an
-extension compared with Perl (at least for 5.8), which requires all branches to
-match the same length of string. An assertion such as
-<pre>
- (?<=ab(c|de))
-</pre>
-is not permitted, because its single top-level branch can match two different
-lengths, but it is acceptable if rewritten to use two top-level branches:
-<pre>
- (?<=abc|abde)
-</pre>
-The implementation of lookbehind assertions is, for each alternative, to
-temporarily move the current position back by the fixed width and then try to
-match. If there are insufficient characters before the current position, the
-match is deemed to fail.
-</P>
-<P>
-PCRE does not allow the \C escape (which matches a single byte in UTF-8 mode)
-to appear in lookbehind assertions, because it makes it impossible to calculate
-the length of the lookbehind. The \X escape, which can match different numbers
-of bytes, is also not permitted.
-</P>
-<P>
-Atomic groups can be used in conjunction with lookbehind assertions to specify
-efficient matching at the end of the subject string. Consider a simple pattern
-such as
-<pre>
- abcd$
-</pre>
-when applied to a long string that does not match. Because matching proceeds
-from left to right, PCRE will look for each "a" in the subject and then see if
-what follows matches the rest of the pattern. If the pattern is specified as
-<pre>
- ^.*abcd$
-</pre>
-the initial .* matches the entire string at first, but when this fails (because
-there is no following "a"), it backtracks to match all but the last character,
-then all but the last two characters, and so on. Once again the search for "a"
-covers the entire string, from right to left, so we are no better off. However,
-if the pattern is written as
-<pre>
- ^(?>.*)(?<=abcd)
-</pre>
-or, equivalently, using the possessive quantifier syntax,
-<pre>
- ^.*+(?<=abcd)
-</pre>
-there can be no backtracking for the .* item; it can match only the entire
-string. The subsequent lookbehind assertion does a single test on the last four
-characters. If it fails, the match fails immediately. For long strings, this
-approach makes a significant difference to the processing time.
-</P>
-<br><b>
-Using multiple assertions
-</b><br>
-<P>
-Several assertions (of any sort) may occur in succession. For example,
-<pre>
- (?<=\d{3})(?<!999)foo
-</pre>
-matches "foo" preceded by three digits that are not "999". Notice that each of
-the assertions is applied independently at the same point in the subject
-string. First there is a check that the previous three characters are all
-digits, and then there is a check that the same three characters are not "999".
-This pattern does <i>not</i> match "foo" preceded by six characters, the first
-of which are digits and the last three of which are not "999". For example, it
-doesn't match "123abcfoo". A pattern to do that is
-<pre>
- (?<=\d{3}...)(?<!999)foo
-</pre>
-This time the first assertion looks at the preceding six characters, checking
-that the first three are digits, and then the second assertion checks that the
-preceding three characters are not "999".
-</P>
-<P>
-Assertions can be nested in any combination. For example,
-<pre>
- (?<=(?<!foo)bar)baz
-</pre>
-matches an occurrence of "baz" that is preceded by "bar" which in turn is not
-preceded by "foo", while
-<pre>
- (?<=\d{3}(?!999)...)foo
-</pre>
-is another pattern that matches "foo" preceded by three digits and any three
-characters that are not "999".
-</P>
-<br><a name="SEC16" href="#TOC1">CONDITIONAL SUBPATTERNS</a><br>
-<P>
-It is possible to cause the matching process to obey a subpattern
-conditionally or to choose between two alternative subpatterns, depending on
-the result of an assertion, or whether a previous capturing subpattern matched
-or not. The two possible forms of conditional subpattern are
-<pre>
- (?(condition)yes-pattern)
- (?(condition)yes-pattern|no-pattern)
-</pre>
-If the condition is satisfied, the yes-pattern is used; otherwise the
-no-pattern (if present) is used. If there are more than two alternatives in the
-subpattern, a compile-time error occurs.
-</P>
-<P>
-There are three kinds of condition. If the text between the parentheses
-consists of a sequence of digits, the condition is satisfied if the capturing
-subpattern of that number has previously matched. The number must be greater
-than zero. 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 three parts for ease of discussion:
-<pre>
- ( \( )? [^()]+ (?(1) \) )
-</pre>
-The first part matches an optional opening parenthesis, and if that
-character is present, sets it as the first captured substring. The second part
-matches one or more characters that are not parentheses. The third part is a
-conditional subpattern that tests whether the first set of parentheses matched
-or not. If they did, that is, if subject started with an opening parenthesis,
-the condition is true, and so the yes-pattern is executed and a closing
-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>
-<P>
-If the condition is the string (R), it is satisfied if a recursive call to the
-pattern or subpattern has been made. At "top level", the condition is false.
-This is a PCRE extension. Recursive patterns are described in the next section.
-</P>
-<P>
-If the condition is not a sequence of digits or (R), it must be an assertion.
-This may be a positive or negative lookahead or lookbehind assertion. Consider
-this pattern, again containing non-significant white space, and with the two
-alternatives on the second line:
-<pre>
- (?(?=[^a-z]*[a-z])
- \d{2}-[a-z]{3}-\d{2} | \d{2}-\d{2}-\d{2} )
-</pre>
-The condition is a positive lookahead assertion that matches an optional
-sequence of non-letters followed by a letter. In other words, it tests for the
-presence of at least one letter in the subject. If a letter is found, the
-subject is matched against the first alternative; otherwise it is matched
-against the second. This pattern matches strings in one of the two forms
-dd-aaa-dd or dd-dd-dd, where aaa are letters and dd are digits.
-<a name="comments"></a></P>
-<br><a name="SEC17" href="#TOC1">COMMENTS</a><br>
-<P>
-The sequence (?# marks the start of a comment that continues up to the next
-closing parenthesis. Nested parentheses are not permitted. The characters
-that make up a comment play no part in the pattern matching at all.
-</P>
-<P>
-If the PCRE_EXTENDED option is set, an unescaped # character outside a
-character class introduces a comment that continues up to the next newline
-character in the pattern.
-</P>
-<br><a name="SEC18" href="#TOC1">RECURSIVE PATTERNS</a><br>
-<P>
-Consider the problem of matching a string in parentheses, allowing for
-unlimited nested parentheses. Without the use of recursion, the best that can
-be done is to use a pattern that matches up to some fixed depth of nesting. It
-is not possible to handle an arbitrary nesting depth. Perl provides a facility
-that allows regular expressions to recurse (amongst other things). It does this
-by interpolating Perl code in the expression at run time, and the code can
-refer to the expression itself. A Perl pattern to solve the parentheses problem
-can be created like this:
-<pre>
- $re = qr{\( (?: (?>[^()]+) | (?p{$re}) )* \)}x;
-</pre>
-The (?p{...}) item interpolates Perl code at run time, and in this case refers
-recursively to the pattern in which it appears. Obviously, PCRE cannot support
-the interpolation of Perl code. Instead, it supports some special syntax for
-recursion of the entire pattern, and also for individual subpattern recursion.
-</P>
-<P>
-The special item that consists of (? followed by a number greater than zero and
-a closing parenthesis is a recursive call of the subpattern of the given
-number, provided that it occurs inside that subpattern. (If not, it is a
-"subroutine" call, which is described in the next section.) The special item
-(?R) is a recursive call of the entire regular expression.
-</P>
-<P>
-For example, this PCRE pattern solves the nested parentheses problem (assume
-the PCRE_EXTENDED option is set so that white space is ignored):
-<pre>
- \( ( (?>[^()]+) | (?R) )* \)
-</pre>
-First it matches an opening parenthesis. Then it matches any number of
-substrings which can either be a sequence of non-parentheses, or a recursive
-match of the pattern itself (that is a correctly parenthesized substring).
-Finally there is a closing parenthesis.
-</P>
-<P>
-If this were part of a larger pattern, you would not want to recurse the entire
-pattern, so instead you could use this:
-<pre>
- ( \( ( (?>[^()]+) | (?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
-parenthesis numbers can be tricky. It may be more convenient to use named
-parentheses instead. For this, PCRE uses (?P>name), which is an extension to
-the Python syntax that PCRE uses for named parentheses (Perl does not provide
-named parentheses). We could rewrite the above example as follows:
-<pre>
- (?P<pn> \( ( (?>[^()]+) | (?P>pn) )* \) )
-</pre>
-This particular example pattern 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>
-it yields "no match" quickly. However, if atomic grouping is not used,
-the match runs for a very long time indeed because there are so many different
-ways the + and * repeats can carve up the subject, and all have to be tested
-before failure can be reported.
-</P>
-<P>
-At the end of a match, the values set for any capturing subpatterns are those
-from the outermost level of the recursion at which the subpattern value is set.
-If you want to obtain intermediate values, a callout function can be used (see
-the next section and the
-<a href="pcrecallout.html"><b>pcrecallout</b></a>
-documentation). If the pattern above is matched against
-<pre>
- (ab(cd)ef)
-</pre>
-the value for the capturing parentheses is "ef", which is the last value taken
-on at the top level. If additional parentheses are added, giving
-<pre>
- \( ( ( (?>[^()]+) | (?R) )* ) \)
- ^ ^
- ^ ^
-</pre>
-the string they capture is "ab(cd)ef", the contents of the top level
-parentheses. If there are more than 15 capturing parentheses in a pattern, PCRE
-has to obtain extra memory to store data during a recursion, which it does by
-using <b>pcre_malloc</b>, freeing it via <b>pcre_free</b> afterwards. If no
-memory can be obtained, the match fails with the PCRE_ERROR_NOMEMORY error.
-</P>
-<P>
-Do not confuse the (?R) item with the condition (R), which tests for recursion.
-Consider this pattern, which matches text in angle brackets, allowing for
-arbitrary nesting. Only digits are allowed in nested brackets (that is, when
-recursing), whereas any characters are permitted at the outer level.
-<pre>
- < (?: (?(R) \d++ | [^<>]*+) | (?R)) * >
-</pre>
-In this pattern, (?(R) is the start of a conditional subpattern, with two
-different alternatives for the recursive and non-recursive cases. The (?R) item
-is the actual recursive call.
-<a name="subpatternsassubroutines"></a></P>
-<br><a name="SEC19" href="#TOC1">SUBPATTERNS AS SUBROUTINES</a><br>
-<P>
-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. An earlier example pointed out that the
-pattern
-<pre>
- (sens|respons)e and \1ibility
-</pre>
-matches "sense and sensibility" and "response and responsibility", but not
-"sense and responsibility". If instead the pattern
-<pre>
- (sens|respons)e and (?1)ibility
-</pre>
-is used, it does match "sense and responsibility" as well as the other two
-strings. Such references must, however, follow the subpattern to which they
-refer.
-</P>
-<br><a name="SEC20" href="#TOC1">CALLOUTS</a><br>
-<P>
-Perl has a feature whereby using the sequence (?{...}) causes arbitrary Perl
-code to be obeyed in the middle of matching a regular expression. This makes it
-possible, amongst other things, to extract different substrings that match the
-same pair of parentheses when there is a repetition.
-</P>
-<P>
-PCRE provides a similar feature, but of course it cannot obey arbitrary Perl
-code. The feature is called "callout". The caller of PCRE provides an external
-function by putting its entry point in the global variable <i>pcre_callout</i>.
-By default, this variable contains NULL, which disables all calling out.
-</P>
-<P>
-Within a regular expression, (?C) indicates the points at which the external
-function is to be called. If you want to identify different callout points, you
-can put a number less than 256 after the letter C. The default value is zero.
-For example, this pattern has two callout points:
-<pre>
- (?C1)\dabc(?C2)def
-</pre>
-If the PCRE_AUTO_CALLOUT flag is passed to <b>pcre_compile()</b>, callouts are
-automatically installed before each item in the pattern. They are all numbered
-255.
-</P>
-<P>
-During matching, when PCRE reaches a callout point (and <i>pcre_callout</i> is
-set), the external function is called. It is provided with the number of the
-callout, the position in the pattern, and, optionally, one item of data
-originally supplied by the caller of <b>pcre_exec()</b>. The callout function
-may cause matching to proceed, to backtrack, or to fail altogether. A complete
-description of the interface to the callout function is given in the
-<a href="pcrecallout.html"><b>pcrecallout</b></a>
-documentation.
-</P>
-<P>
-Last updated: 09 September 2004
-<br>
-Copyright © 1997-2004 University of Cambridge.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcreperform specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcreperform man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-PCRE PERFORMANCE
-</b><br>
-<P>
-Certain items that may appear in regular expression patterns are more efficient
-than others. It is more efficient to use a character class like [aeiou] than a
-set of alternatives such as (a|e|i|o|u). In general, the simplest construction
-that provides the required behaviour is usually the most efficient. Jeffrey
-Friedl's book contains a lot of useful general discussion about optimizing
-regular expressions for efficient performance. This document contains a few
-observations about PCRE.
-</P>
-<P>
-Using Unicode character properties (the \p, \P, and \X escapes) is slow,
-because PCRE has to scan a structure that contains data for over fifteen
-thousand characters whenever it needs a character's property. If you can find
-an alternative pattern that does not use character properties, it will probably
-be faster.
-</P>
-<P>
-When a pattern begins with .* not in parentheses, or in parentheses that are
-not the subject of a backreference, and the PCRE_DOTALL option is set, the
-pattern is implicitly anchored by PCRE, since it can match only at the start of
-a subject string. However, if PCRE_DOTALL is not set, PCRE cannot make this
-optimization, because the . metacharacter does not then match a newline, and if
-the subject string contains newlines, the pattern may match from the character
-immediately following one of them instead of from the very start. For example,
-the pattern
-<pre>
- .*second
-</pre>
-matches the subject "first\nand second" (where \n stands for a newline
-character), with the match starting at the seventh character. In order to do
-this, PCRE has to retry the match starting after every newline in the subject.
-</P>
-<P>
-If you are using such a pattern with subject strings that do not contain
-newlines, the best performance is obtained by setting PCRE_DOTALL, or starting
-the pattern with ^.* to indicate explicit anchoring. That saves PCRE from
-having to scan along the subject looking for a newline to restart at.
-</P>
-<P>
-Beware of patterns that contain nested indefinite repeats. These can take a
-long time to run when applied to a string that does not match. Consider the
-pattern fragment
-<pre>
- (a+)*
-</pre>
-This can match "aaaa" in 33 different ways, and this number increases very
-rapidly as the string gets longer. (The * repeat can match 0, 1, 2, 3, or 4
-times, and for each of those cases other than 0, the + repeats can match
-different numbers of times.) When the remainder of the pattern is such that the
-entire match is going to fail, PCRE has in principle to try every possible
-variation, and this can take an extremely long time.
-</P>
-<P>
-An optimization catches some of the more simple cases such as
-<pre>
- (a+)*b
-</pre>
-where a literal character follows. Before embarking on the standard matching
-procedure, PCRE checks that there is a "b" later in the subject string, and if
-there is not, it fails the match immediately. However, when there is no
-following literal this optimization cannot be used. You can see the difference
-by comparing the behaviour of
-<pre>
- (a+)*\d
-</pre>
-with the pattern above. The former gives a failure almost instantly when
-applied to a whole line of "a" characters, whereas the latter takes an
-appreciable time with strings longer than about 20 characters.
-</P>
-<P>
-In many cases, the solution to this kind of performance issue is to use an
-atomic group or a possessive quantifier.
-</P>
-<P>
-Last updated: 09 September 2004
-<br>
-Copyright © 1997-2004 University of Cambridge.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcreposix specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcreposix man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<ul>
-<li><a name="TOC1" href="#SEC1">SYNOPSIS OF POSIX API</a>
-<li><a name="TOC2" href="#SEC2">DESCRIPTION</a>
-<li><a name="TOC3" href="#SEC3">COMPILING A PATTERN</a>
-<li><a name="TOC4" href="#SEC4">MATCHING NEWLINE CHARACTERS</a>
-<li><a name="TOC5" href="#SEC5">MATCHING A PATTERN</a>
-<li><a name="TOC6" href="#SEC6">ERROR MESSAGES</a>
-<li><a name="TOC7" href="#SEC7">MEMORY USAGE</a>
-<li><a name="TOC8" href="#SEC8">AUTHOR</a>
-</ul>
-<br><a name="SEC1" href="#TOC1">SYNOPSIS OF POSIX API</a><br>
-<P>
-<b>#include <pcreposix.h></b>
-</P>
-<P>
-<b>int regcomp(regex_t *<i>preg</i>, const char *<i>pattern</i>,</b>
-<b>int <i>cflags</i>);</b>
-</P>
-<P>
-<b>int regexec(regex_t *<i>preg</i>, const char *<i>string</i>,</b>
-<b>size_t <i>nmatch</i>, regmatch_t <i>pmatch</i>[], int <i>eflags</i>);</b>
-</P>
-<P>
-<b>size_t regerror(int <i>errcode</i>, const regex_t *<i>preg</i>,</b>
-<b>char *<i>errbuf</i>, size_t <i>errbuf_size</i>);</b>
-</P>
-<P>
-<b>void regfree(regex_t *<i>preg</i>);</b>
-</P>
-<br><a name="SEC2" href="#TOC1">DESCRIPTION</a><br>
-<P>
-This set of functions provides a POSIX-style API to the PCRE regular expression
-package. See the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-documentation for a description of PCRE's native API, which contains additional
-functionality.
-</P>
-<P>
-The functions described here are just wrapper functions that ultimately call
-the PCRE native API. Their prototypes are defined in the <b>pcreposix.h</b>
-header file, and on Unix systems the library itself is called
-<b>pcreposix.a</b>, so can be accessed by adding <b>-lpcreposix</b> to the
-command for linking an application that uses them. Because the POSIX functions
-call the native ones, it is also necessary to add <b>-lpcre</b>.
-</P>
-<P>
-I have implemented only those option bits that can be reasonably mapped to PCRE
-native options. In addition, the options REG_EXTENDED and REG_NOSUB are defined
-with the value zero. They have no effect, but since programs that are written
-to the POSIX interface often use them, this makes it easier to slot in PCRE as
-a replacement library. Other POSIX options are not even defined.
-</P>
-<P>
-When PCRE is called via these functions, it is only the API that is POSIX-like
-in style. The syntax and semantics of the regular expressions themselves are
-still those of Perl, subject to the setting of various PCRE options, as
-described below. "POSIX-like in style" means that the API approximates to the
-POSIX definition; it is not fully POSIX-compatible, and in multi-byte encoding
-domains it is probably even less compatible.
-</P>
-<P>
-The header for these functions is supplied as <b>pcreposix.h</b> to avoid any
-potential clash with other POSIX libraries. It can, of course, be renamed or
-aliased as <b>regex.h</b>, which is the "correct" name. It provides two
-structure types, <i>regex_t</i> for compiled internal forms, and
-<i>regmatch_t</i> for returning captured substrings. It also defines some
-constants whose names start with "REG_"; these are used for setting options and
-identifying error codes.
-</P>
-<P>
-</P>
-<br><a name="SEC3" href="#TOC1">COMPILING A PATTERN</a><br>
-<P>
-The function <b>regcomp()</b> is called to compile a pattern into an
-internal form. The pattern is a C string terminated by a binary zero, and
-is passed in the argument <i>pattern</i>. The <i>preg</i> argument is a pointer
-to a <b>regex_t</b> structure that is used as a base for storing information
-about the compiled expression.
-</P>
-<P>
-The argument <i>cflags</i> is either zero, or contains one or more of the bits
-defined by the following macros:
-<pre>
- REG_ICASE
-</pre>
-The PCRE_CASELESS option is set when the expression is passed for compilation
-to the native function.
-<pre>
- REG_NEWLINE
-</pre>
-The PCRE_MULTILINE option is set when the expression is passed for compilation
-to the native function. Note that this does <i>not</i> mimic the defined POSIX
-behaviour for REG_NEWLINE (see the following section).
-</P>
-<P>
-In the absence of these flags, no options are passed to the native function.
-This means the the regex is compiled with PCRE default semantics. In
-particular, the way it handles newline characters in the subject string is the
-Perl way, not the POSIX way. Note that setting PCRE_MULTILINE has only
-<i>some</i> of the effects specified for REG_NEWLINE. It does not affect the way
-newlines are matched by . (they aren't) or by a negative class such as [^a]
-(they are).
-</P>
-<P>
-The yield of <b>regcomp()</b> is zero on success, and non-zero otherwise. The
-<i>preg</i> structure is filled in on success, and one member of the structure
-is public: <i>re_nsub</i> contains the number of capturing subpatterns in
-the regular expression. Various error codes are defined in the header file.
-</P>
-<br><a name="SEC4" href="#TOC1">MATCHING NEWLINE CHARACTERS</a><br>
-<P>
-This area is not simple, because POSIX and Perl take different views of things.
-It is not possible to get PCRE to obey POSIX semantics, but then PCRE was never
-intended to be a POSIX engine. The following table lists the different
-possibilities for matching newline characters in PCRE:
-<pre>
- Default Change with
-
- . matches newline no PCRE_DOTALL
- newline matches [^a] yes not changeable
- $ matches \n at end yes PCRE_DOLLARENDONLY
- $ matches \n in middle no PCRE_MULTILINE
- ^ matches \n in middle no PCRE_MULTILINE
-</pre>
-This is the equivalent table for POSIX:
-<pre>
- Default Change with
-
- . matches newline yes REG_NEWLINE
- newline matches [^a] yes REG_NEWLINE
- $ matches \n at end no REG_NEWLINE
- $ matches \n in middle no REG_NEWLINE
- ^ matches \n in middle no REG_NEWLINE
-</pre>
-PCRE's behaviour is the same as Perl's, except that there is no equivalent for
-PCRE_DOLLAR_ENDONLY in Perl. In both PCRE and Perl, there is no way to stop
-newline from matching [^a].
-</P>
-<P>
-The default POSIX newline handling can be obtained by setting PCRE_DOTALL and
-PCRE_DOLLAR_ENDONLY, but there is no way to make PCRE behave exactly as for the
-REG_NEWLINE action.
-</P>
-<br><a name="SEC5" href="#TOC1">MATCHING A PATTERN</a><br>
-<P>
-The function <b>regexec()</b> is called to match a compiled pattern <i>preg</i>
-against a given <i>string</i>, which is terminated by a zero byte, subject to
-the options in <i>eflags</i>. These can be:
-<pre>
- REG_NOTBOL
-</pre>
-The PCRE_NOTBOL option is set when calling the underlying PCRE matching
-function.
-<pre>
- REG_NOTEOL
-</pre>
-The PCRE_NOTEOL option is set when calling the underlying PCRE matching
-function.
-</P>
-<P>
-The portion of the string that was matched, and also any captured substrings,
-are returned via the <i>pmatch</i> argument, which points to an array of
-<i>nmatch</i> structures of type <i>regmatch_t</i>, containing the members
-<i>rm_so</i> and <i>rm_eo</i>. These contain the offset to the first character of
-each substring and the offset to the first character after the end of each
-substring, respectively. The 0th element of the vector relates to the entire
-portion of <i>string</i> that was matched; subsequent elements relate to the
-capturing subpatterns of the regular expression. Unused entries in the array
-have both structure members set to -1.
-</P>
-<P>
-A successful match yields a zero return; various error codes are defined in the
-header file, of which REG_NOMATCH is the "expected" failure code.
-</P>
-<br><a name="SEC6" href="#TOC1">ERROR MESSAGES</a><br>
-<P>
-The <b>regerror()</b> function maps a non-zero errorcode from either
-<b>regcomp()</b> or <b>regexec()</b> to a printable message. If <i>preg</i> is not
-NULL, the error should have arisen from the use of that structure. A message
-terminated by a binary zero is placed in <i>errbuf</i>. The length of the
-message, including the zero, is limited to <i>errbuf_size</i>. The yield of the
-function is the size of buffer needed to hold the whole message.
-</P>
-<br><a name="SEC7" href="#TOC1">MEMORY USAGE</a><br>
-<P>
-Compiling a regular expression causes memory to be allocated and associated
-with the <i>preg</i> structure. The function <b>regfree()</b> frees all such
-memory, after which <i>preg</i> may no longer be used as a compiled expression.
-</P>
-<br><a name="SEC8" href="#TOC1">AUTHOR</a><br>
-<P>
-Philip Hazel <ph10@cam.ac.uk>
-<br>
-University Computing Service,
-<br>
-Cambridge CB2 3QG, England.
-</P>
-<P>
-Last updated: 07 September 2004
-<br>
-Copyright © 1997-2004 University of Cambridge.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcreprecompile specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcreprecompile man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<ul>
-<li><a name="TOC1" href="#SEC1">SAVING AND RE-USING PRECOMPILED PCRE PATTERNS</a>
-<li><a name="TOC2" href="#SEC2">SAVING A COMPILED PATTERN</a>
-<li><a name="TOC3" href="#SEC3">RE-USING A PRECOMPILED PATTERN</a>
-<li><a name="TOC4" href="#SEC4">COMPATIBILITY WITH DIFFERENT PCRE RELEASES</a>
-</ul>
-<br><a name="SEC1" href="#TOC1">SAVING AND RE-USING PRECOMPILED PCRE PATTERNS</a><br>
-<P>
-If you are running an application that uses a large number of regular
-expression patterns, it may be useful to store them in a precompiled form
-instead of having to compile them every time the application is run.
-If you are not using any private character tables (see the
-<a href="pcre_maketables.html"><b>pcre_maketables()</b></a>
-documentation), this is relatively straightforward. If you are using private
-tables, it is a little bit more complicated.
-</P>
-<P>
-If you save compiled patterns to a file, you can copy them to a different host
-and run them there. This works even if the new host has the opposite endianness
-to the one on which the patterns were compiled. There may be a small
-performance penalty, but it should be insignificant.
-</P>
-<br><a name="SEC2" href="#TOC1">SAVING A COMPILED PATTERN</a><br>
-<P>
-The value returned by <b>pcre_compile()</b> points to a single block of memory
-that holds the compiled pattern and associated data. You can find the length of
-this block in bytes by calling <b>pcre_fullinfo()</b> with an argument of
-PCRE_INFO_SIZE. You can then save the data in any appropriate manner. Here is
-sample code that compiles a pattern and writes it to a file. It assumes that
-the variable <i>fd</i> refers to a file that is open for output:
-<pre>
- int erroroffset, rc, size;
- char *error;
- pcre *re;
-
- re = pcre_compile("my pattern", 0, &error, &erroroffset, NULL);
- if (re == NULL) { ... handle errors ... }
- rc = pcre_fullinfo(re, NULL, PCRE_INFO_SIZE, &size);
- if (rc < 0) { ... handle errors ... }
- rc = fwrite(re, 1, size, fd);
- if (rc != size) { ... handle errors ... }
-</pre>
-In this example, the bytes that comprise the compiled pattern are copied
-exactly. Note that this is binary data that may contain any of the 256 possible
-byte values. On systems that make a distinction between binary and non-binary
-data, be sure that the file is opened for binary output.
-</P>
-<P>
-If you want to write more than one pattern to a file, you will have to devise a
-way of separating them. For binary data, preceding each pattern with its length
-is probably the most straightforward approach. Another possibility is to write
-out the data in hexadecimal instead of binary, one pattern to a line.
-</P>
-<P>
-Saving compiled patterns in a file is only one possible way of storing them for
-later use. They could equally well be saved in a database, or in the memory of
-some daemon process that passes them via sockets to the processes that want
-them.
-</P>
-<P>
-If the pattern has been studied, it is also possible to save the study data in
-a similar way to the compiled pattern itself. When studying generates
-additional information, <b>pcre_study()</b> returns a pointer to a
-<b>pcre_extra</b> data block. Its format is defined in the
-<a href="pcreapi.html#extradata">section on matching a pattern</a>
-in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-documentation. The <i>study_data</i> field points to the binary study data, and
-this is what you must save (not the <b>pcre_extra</b> block itself). The length
-of the study data can be obtained by calling <b>pcre_fullinfo()</b> with an
-argument of PCRE_INFO_STUDYSIZE. Remember to check that <b>pcre_study()</b> did
-return a non-NULL value before trying to save the study data.
-</P>
-<br><a name="SEC3" href="#TOC1">RE-USING A PRECOMPILED PATTERN</a><br>
-<P>
-Re-using a precompiled pattern is straightforward. Having reloaded it into main
-memory, you pass its pointer to <b>pcre_exec()</b> in the usual way. This should
-work even on another host, and even if that host has the opposite endianness to
-the one where the pattern was compiled.
-</P>
-<P>
-However, if you passed a pointer to custom character tables when the pattern
-was compiled (the <i>tableptr</i> argument of <b>pcre_compile()</b>), you must
-now pass a similar pointer to <b>pcre_exec()</b>, because the value saved with
-the compiled pattern will obviously be nonsense. A field in a
-<b>pcre_extra()</b> block is used to pass this data, as described in the
-<a href="pcreapi.html#extradata">section on matching a pattern</a>
-in the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-documentation.
-</P>
-<P>
-If you did not provide custom character tables when the pattern was compiled,
-the pointer in the compiled pattern is NULL, which causes <b>pcre_exec()</b> to
-use PCRE's internal tables. Thus, you do not need to take any special action at
-run time in this case.
-</P>
-<P>
-If you saved study data with the compiled pattern, you need to create your own
-<b>pcre_extra</b> data block and set the <i>study_data</i> field to point to the
-reloaded study data. You must also set the PCRE_EXTRA_STUDY_DATA bit in the
-<i>flags</i> field to indicate that study data is present. Then pass the
-<b>pcre_extra</b> block to <b>pcre_exec()</b> in the usual way.
-</P>
-<br><a name="SEC4" href="#TOC1">COMPATIBILITY WITH DIFFERENT PCRE RELEASES</a><br>
-<P>
-The layout of the control block that is at the start of the data that makes up
-a compiled pattern was changed for release 5.0. If you have any saved patterns
-that were compiled with previous releases (not a facility that was previously
-advertised), you will have to recompile them for release 5.0. However, from now
-on, it should be possible to make changes in a compabible manner.
-</P>
-<P>
-Last updated: 10 September 2004
-<br>
-Copyright © 1997-2004 University of Cambridge.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcresample specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcresample man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<br><b>
-PCRE SAMPLE PROGRAM
-</b><br>
-<P>
-A simple, complete demonstration program, to get you started with using PCRE,
-is supplied in the file <i>pcredemo.c</i> in the PCRE distribution.
-</P>
-<P>
-The program compiles the regular expression that is its first argument, and
-matches it against the subject string in its second argument. No PCRE options
-are set, and default character tables are used. If matching succeeds, the
-program outputs the portion of the subject that matched, together with the
-contents of any captured substrings.
-</P>
-<P>
-If the -g option is given on the command line, the program then goes on to
-check for further matches of the same regular expression in the same subject
-string. The logic is a little bit tricky because of the possibility of matching
-an empty string. Comments in the code explain what is going on.
-</P>
-<P>
-If PCRE is installed in the standard include and library directories for your
-system, you should be able to compile the demonstration program using this
-command:
-<pre>
- gcc -o pcredemo pcredemo.c -lpcre
-</pre>
-If PCRE is installed elsewhere, you may need to add additional options to the
-command line. For example, on a Unix-like system that has PCRE installed in
-<i>/usr/local</i>, you can compile the demonstration program using a command
-like this:
-<pre>
- gcc -o pcredemo -I/usr/local/include pcredemo.c -L/usr/local/lib -lpcre
-</pre>
-Once you have compiled the demonstration program, you can run simple tests like
-this:
-<pre>
- ./pcredemo 'cat|dog' 'the cat sat on the mat'
- ./pcredemo -g 'cat|dog' 'the dog sat on the cat'
-</pre>
-Note that there is a much more comprehensive test program, called
-<a href="pcretest.html"><b>pcretest</b>,</a>
-which supports many more facilities for testing regular expressions and the
-PCRE library. The <b>pcredemo</b> program is provided as a simple coding
-example.
-</P>
-<P>
-On some operating systems (e.g. Solaris), when PCRE is not installed in the
-standard library directory, you may get an error like this when you try to run
-<b>pcredemo</b>:
-<pre>
- ld.so.1: a.out: fatal: libpcre.so.0: open failed: No such file or directory
-</pre>
-This is caused by the way shared library support works on those systems. You
-need to add
-<pre>
- -R/usr/local/lib
-</pre>
-(for example) to the compile command to get round this problem.
-</P>
-<P>
-Last updated: 09 September 2004
-<br>
-Copyright © 1997-2004 University of Cambridge.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-<html>
-<head>
-<title>pcretest specification</title>
-</head>
-<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
-<h1>pcretest man page</h1>
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
-<p>
-This page is part of the PCRE HTML documentation. It was generated automatically
-from the original man page. If there is any nonsense in it, please consult the
-man page, in case the conversion went wrong.
-<br>
-<ul>
-<li><a name="TOC1" href="#SEC1">SYNOPSIS</a>
-<li><a name="TOC2" href="#SEC2">OPTIONS</a>
-<li><a name="TOC3" href="#SEC3">DESCRIPTION</a>
-<li><a name="TOC4" href="#SEC4">PATTERN MODIFIERS</a>
-<li><a name="TOC5" href="#SEC5">DATA LINES</a>
-<li><a name="TOC6" href="#SEC6">OUTPUT FROM PCRETEST</a>
-<li><a name="TOC7" href="#SEC7">CALLOUTS</a>
-<li><a name="TOC8" href="#SEC8">SAVING AND RELOADING COMPILED PATTERNS</a>
-<li><a name="TOC9" href="#SEC9">AUTHOR</a>
-</ul>
-<br><a name="SEC1" href="#TOC1">SYNOPSIS</a><br>
-<P>
-<b>pcretest [-C] [-d] [-i] [-m] [-o osize] [-p] [-t] [source]</b>
-<b>[destination]</b>
-</P>
-<P>
-<b>pcretest</b> was written as a test program for the PCRE regular expression
-library itself, but it can also be used for experimenting with regular
-expressions. This document describes the features of the test program; for
-details of the regular expressions themselves, see the
-<a href="pcrepattern.html"><b>pcrepattern</b></a>
-documentation. For details of the PCRE library function calls and their
-options, see the
-<a href="pcreapi.html"><b>pcreapi</b></a>
-documentation.
-</P>
-<br><a name="SEC2" href="#TOC1">OPTIONS</a><br>
-<P>
-<b>-C</b>
-Output the version number of the PCRE library, and all available information
-about the optional features that are included, and then exit.
-</P>
-<P>
-<b>-d</b>
-Behave as if each regex had the <b>/D</b> (debug) modifier; the internal
-form is output after compilation.
-</P>
-<P>
-<b>-i</b>
-Behave as if each regex had the <b>/I</b> modifier; information about the
-compiled pattern is given after compilation.
-</P>
-<P>
-<b>-m</b>
-Output the size of each compiled pattern after it has been compiled. This is
-equivalent to adding <b>/M</b> to each regular expression. For compatibility
-with earlier versions of pcretest, <b>-s</b> is a synonym for <b>-m</b>.
-</P>
-<P>
-<b>-o</b> <i>osize</i>
-Set the number of elements in the output vector that is used when calling
-<b>pcre_exec()</b> to be <i>osize</i>. The default value is 45, which is enough
-for 14 capturing subexpressions. The vector size can be changed for individual
-matching calls by including \O in the data line (see below).
-</P>
-<P>
-<b>-p</b>
-Behave as if each regex has <b>/P</b> modifier; the POSIX wrapper API is used
-to call PCRE. None of the other options has any effect when <b>-p</b> is set.
-</P>
-<P>
-<b>-t</b>
-Run each compile, study, and match many times with a timer, and output
-resulting time per compile or match (in milliseconds). Do not set <b>-m</b> with
-<b>-t</b>, because you will then get the size output a zillion times, and the
-timing will be distorted.
-</P>
-<br><a name="SEC3" href="#TOC1">DESCRIPTION</a><br>
-<P>
-If <b>pcretest</b> is given two filename arguments, it reads from the first and
-writes to the second. If it is given only one filename argument, it reads from
-that file and writes to stdout. Otherwise, it reads from stdin and writes to
-stdout, and prompts for each line of input, using "re>" to prompt for regular
-expressions, and "data>" to prompt for data lines.
-</P>
-<P>
-The program handles any number of sets of input on a single input file. Each
-set starts with a regular expression, and continues with any number of data
-lines to be matched against the pattern.
-</P>
-<P>
-Each data line is matched separately and independently. If you want to do
-multiple-line matches, you have to use the \n escape sequence in a single line
-of input to encode the newline characters. The maximum length of data line is
-30,000 characters.
-</P>
-<P>
-An empty line signals the end of the data lines, at which point a new regular
-expression is read. The regular expressions are given enclosed in any
-non-alphanumeric delimiters other than backslash, for example
-<pre>
- /(a|bc)x+yz/
-</pre>
-White space before the initial delimiter is ignored. A regular expression may
-be continued over several input lines, in which case the newline characters are
-included within it. It is possible to include the delimiter within the pattern
-by escaping it, for example
-<pre>
- /abc\/def/
-</pre>
-If you do so, the escape and the delimiter form part of the pattern, but since
-delimiters are always non-alphanumeric, this does not affect its interpretation.
-If the terminating delimiter is immediately followed by a backslash, for
-example,
-<pre>
- /abc/\
-</pre>
-then a backslash is added to the end of the pattern. This is done to provide a
-way of testing the error condition that arises if a pattern finishes with a
-backslash, because
-<pre>
- /abc\/
-</pre>
-is interpreted as the first line of a pattern that starts with "abc/", causing
-pcretest to read the next line as a continuation of the regular expression.
-</P>
-<br><a name="SEC4" href="#TOC1">PATTERN MODIFIERS</a><br>
-<P>
-A pattern may be followed by any number of modifiers, which are mostly single
-characters. Following Perl usage, these are referred to below as, for example,
-"the <b>/i</b> modifier", even though the delimiter of the pattern need not
-always be a slash, and no slash is used when writing modifiers. Whitespace may
-appear between the final pattern delimiter and the first modifier, and between
-the modifiers themselves.
-</P>
-<P>
-The <b>/i</b>, <b>/m</b>, <b>/s</b>, and <b>/x</b> modifiers set the PCRE_CASELESS,
-PCRE_MULTILINE, PCRE_DOTALL, or PCRE_EXTENDED options, respectively, when
-<b>pcre_compile()</b> is called. These four modifier letters have the same
-effect as they do in Perl. For example:
-<pre>
- /caseless/i
-</pre>
-The following table shows additional modifiers for setting PCRE options that do
-not correspond to anything in Perl:
-<pre>
- <b>/A</b> PCRE_ANCHORED
- <b>/C</b> PCRE_AUTO_CALLOUT
- <b>/E</b> PCRE_DOLLAR_ENDONLY
- <b>/N</b> PCRE_NO_AUTO_CAPTURE
- <b>/U</b> PCRE_UNGREEDY
- <b>/X</b> PCRE_EXTRA
-</pre>
-Searching for all possible matches within each subject string can be requested
-by the <b>/g</b> or <b>/G</b> modifier. After finding a match, PCRE is called
-again to search the remainder of the subject string. The difference between
-<b>/g</b> and <b>/G</b> is that the former uses the <i>startoffset</i> argument to
-<b>pcre_exec()</b> to start searching at a new point within the entire string
-(which is in effect what Perl does), whereas the latter passes over a shortened
-substring. This makes a difference to the matching process if the pattern
-begins with a lookbehind assertion (including \b or \B).
-</P>
-<P>
-If any call to <b>pcre_exec()</b> in a <b>/g</b> or <b>/G</b> sequence matches an
-empty string, the next call is done with the PCRE_NOTEMPTY and PCRE_ANCHORED
-flags set in order to search for another, non-empty, match at the same point.
-If this second match fails, the start offset is advanced by one, and the normal
-match is retried. This imitates the way Perl handles such cases when using the
-<b>/g</b> modifier or the <b>split()</b> function.
-</P>
-<P>
-There are yet more modifiers for controlling the way <b>pcretest</b>
-operates.
-</P>
-<P>
-The <b>/+</b> modifier requests that as well as outputting the substring that
-matched the entire pattern, pcretest should in addition output the remainder of
-the subject string. This is useful for tests where the subject contains
-multiple copies of the same substring.
-</P>
-<P>
-The <b>/L</b> modifier must be followed directly by the name of a locale, for
-example,
-<pre>
- /pattern/Lfr_FR
-</pre>
-For this reason, it must be the last modifier. The given locale is set,
-<b>pcre_maketables()</b> is called to build a set of character tables for the
-locale, and this is then passed to <b>pcre_compile()</b> when compiling the
-regular expression. Without an <b>/L</b> modifier, NULL is passed as the tables
-pointer; that is, <b>/L</b> applies only to the expression on which it appears.
-</P>
-<P>
-The <b>/I</b> modifier requests that <b>pcretest</b> output information about the
-compiled pattern (whether it is anchored, has a fixed first character, and
-so on). It does this by calling <b>pcre_fullinfo()</b> after compiling a
-pattern. If the pattern is studied, the results of that are also output.
-</P>
-<P>
-The <b>/D</b> modifier is a PCRE debugging feature, which also assumes <b>/I</b>.
-It causes the internal form of compiled regular expressions to be output after
-compilation. If the pattern was studied, the information returned is also
-output.
-</P>
-<P>
-The <b>/F</b> modifier causes <b>pcretest</b> to flip the byte order of the
-fields in the compiled pattern that contain 2-byte and 4-byte numbers. This
-facility is for testing the feature in PCRE that allows it to execute patterns
-that were compiled on a host with a different endianness. This feature is not
-available when the POSIX interface to PCRE is being used, that is, when the
-<b>/P</b> pattern modifier is specified. See also the section about saving and
-reloading compiled patterns below.
-</P>
-<P>
-The <b>/S</b> modifier causes <b>pcre_study()</b> to be called after the
-expression has been compiled, and the results used when the expression is
-matched.
-</P>
-<P>
-The <b>/M</b> modifier causes the size of memory block used to hold the compiled
-pattern to be output.
-</P>
-<P>
-The <b>/P</b> modifier causes <b>pcretest</b> to call PCRE via the POSIX wrapper
-API rather than its native API. When this is done, all other modifiers except
-<b>/i</b>, <b>/m</b>, and <b>/+</b> are ignored. REG_ICASE is set if <b>/i</b> is
-present, and REG_NEWLINE is set if <b>/m</b> is present. The wrapper functions
-force PCRE_DOLLAR_ENDONLY always, and PCRE_DOTALL unless REG_NEWLINE is set.
-</P>
-<P>
-The <b>/8</b> modifier causes <b>pcretest</b> to call PCRE with the PCRE_UTF8
-option set. This turns on support for UTF-8 character handling in PCRE,
-provided that it was compiled with this support enabled. This modifier also
-causes any non-printing characters in output strings to be printed using the
-\x{hh...} notation if they are valid UTF-8 sequences.
-</P>
-<P>
-If the <b>/?</b> modifier is used with <b>/8</b>, it causes <b>pcretest</b> to
-call <b>pcre_compile()</b> with the PCRE_NO_UTF8_CHECK option, to suppress the
-checking of the string for UTF-8 validity.
-</P>
-<br><a name="SEC5" href="#TOC1">DATA LINES</a><br>
-<P>
-Before each data line is passed to <b>pcre_exec()</b>, leading and trailing
-whitespace is removed, and it is then scanned for \ escapes. Some of these are
-pretty esoteric features, intended for checking out some of the more
-complicated features of PCRE. If you are just testing "ordinary" regular
-expressions, you probably don't need any of these. The following escapes are
-recognized:
-<pre>
- \a alarm (= BEL)
- \b backspace
- \e escape
- \f formfeed
- \n newline
- \r carriage return
- \t tab
- \v vertical tab
- \nnn octal character (up to 3 octal digits)
- \xhh hexadecimal character (up to 2 hex digits)
- \x{hh...} hexadecimal character, any number of digits in UTF-8 mode
- \A pass the PCRE_ANCHORED option to <b>pcre_exec()</b>
- \B pass the PCRE_NOTBOL option to <b>pcre_exec()</b>
- \Cdd call pcre_copy_substring() for substring dd after a successful match (number less than 32)
- \Cname call pcre_copy_named_substring() for substring "name" after a successful match (name termin-
- ated by next non alphanumeric character)
- \C+ show the current captured substrings at callout time
- \C- do not supply a callout function
- \C!n return 1 instead of 0 when callout number n is reached
- \C!n!m return 1 instead of 0 when callout number n is reached for the nth time
- \C*n pass the number n (may be negative) as callout data; this is used as the callout return value
- \Gdd call pcre_get_substring() for substring dd after a successful match (number less than 32)
- \Gname call pcre_get_named_substring() for substring "name" after a successful match (name termin-
- ated by next non-alphanumeric character)
- \L call pcre_get_substringlist() after a successful match
- \M discover the minimum MATCH_LIMIT setting
- \N pass the PCRE_NOTEMPTY option to <b>pcre_exec()</b>
- \Odd set the size of the output vector passed to <b>pcre_exec()</b> to dd (any number of digits)
- \P pass the PCRE_PARTIAL option to <b>pcre_exec()</b>
- \S output details of memory get/free calls during matching
- \Z pass the PCRE_NOTEOL option to <b>pcre_exec()</b>
- \? pass the PCRE_NO_UTF8_CHECK option to <b>pcre_exec()</b>
- \>dd start the match at offset dd (any number of digits);
- this sets the <i>startoffset</i> argument for <b>pcre_exec()</b>
-</pre>
-A backslash followed by anything else just escapes the anything else. If the
-very last character is a backslash, it is ignored. This gives a way of passing
-an empty line as data, since a real empty line terminates the data input.
-</P>
-<P>
-If \M is present, <b>pcretest</b> calls <b>pcre_exec()</b> several times, with
-different values in the <i>match_limit</i> field of the <b>pcre_extra</b> data
-structure, until it finds the minimum number that is needed for
-<b>pcre_exec()</b> to complete. This number is a measure of the amount of
-recursion and backtracking that takes place, and checking it out can be
-instructive. For most simple matches, the number is quite small, but for
-patterns with very large numbers of matching possibilities, it can become large
-very quickly with increasing length of subject string.
-</P>
-<P>
-When \O is used, the value specified may be higher or lower than the size set
-by the <b>-O</b> command line option (or defaulted to 45); \O applies only to
-the call of <b>pcre_exec()</b> for the line in which it appears.
-</P>
-<P>
-If the <b>/P</b> modifier was present on the pattern, causing the POSIX wrapper
-API to be used, only \B and \Z have any effect, causing REG_NOTBOL and
-REG_NOTEOL to be passed to <b>regexec()</b> respectively.
-</P>
-<P>
-The use of \x{hh...} to represent UTF-8 characters is not dependent on the use
-of the <b>/8</b> modifier on the pattern. It is recognized always. There may be
-any number of hexadecimal digits inside the braces. The result is from one to
-six bytes, encoded according to the UTF-8 rules.
-</P>
-<br><a name="SEC6" href="#TOC1">OUTPUT FROM PCRETEST</a><br>
-<P>
-When a match succeeds, pcretest outputs the list of captured substrings that
-<b>pcre_exec()</b> returns, starting with number 0 for the string that matched
-the whole pattern. Otherwise, it outputs "No match" or "Partial match"
-when <b>pcre_exec()</b> returns PCRE_ERROR_NOMATCH or PCRE_ERROR_PARTIAL,
-respectively, and otherwise the PCRE negative error number. Here is an example
-of an interactive pcretest run.
-<pre>
- $ pcretest
- PCRE version 5.00 07-Sep-2004
-
- re> /^abc(\d+)/
- data> abc123
- 0: abc123
- 1: 123
- data> xyz
- No match
-</pre>
-If the strings contain any non-printing characters, they are output as \0x
-escapes, or as \x{...} escapes if the <b>/8</b> modifier was present on the
-pattern. If the pattern has the <b>/+</b> modifier, the output for substring 0
-is followed by the the rest of the subject string, identified by "0+" like
-this:
-<pre>
- re> /cat/+
- data> cataract
- 0: cat
- 0+ aract
-</pre>
-If the pattern has the <b>/g</b> or <b>/G</b> modifier, the results of successive
-matching attempts are output in sequence, like this:
-<pre>
- re> /\Bi(\w\w)/g
- data> Mississippi
- 0: iss
- 1: ss
- 0: iss
- 1: ss
- 0: ipp
- 1: pp
-</pre>
-"No match" is output only if the first match attempt fails.
-</P>
-<P>
-If any of the sequences <b>\C</b>, <b>\G</b>, or <b>\L</b> are present in a
-data line that is successfully matched, the substrings extracted by the
-convenience functions are output with C, G, or L after the string number
-instead of a colon. This is in addition to the normal full list. The string
-length (that is, the return from the extraction function) is given in
-parentheses after each string for <b>\C</b> and <b>\G</b>.
-</P>
-<P>
-Note that while patterns can be continued over several lines (a plain ">"
-prompt is used for continuations), data lines may not. However newlines can be
-included in data by means of the \n escape.
-</P>
-<br><a name="SEC7" href="#TOC1">CALLOUTS</a><br>
-<P>
-If the pattern contains any callout requests, <b>pcretest</b>'s callout function
-is called during matching. By default, it displays the callout number, the
-start and current positions in the text at the callout time, and the next
-pattern item to be tested. For example, the output
-<pre>
- --->pqrabcdef
- 0 ^ ^ \d
-</pre>
-indicates that callout number 0 occurred for a match attempt starting at the
-fourth character of the subject string, when the pointer was at the seventh
-character of the data, and when the next pattern item was \d. Just one
-circumflex is output if the start and current positions are the same.
-</P>
-<P>
-Callouts numbered 255 are assumed to be automatic callouts, inserted as a
-result of the <b>/C</b> pattern modifier. In this case, instead of showing the
-callout number, the offset in the pattern, preceded by a plus, is output. For
-example:
-<pre>
- re> /\d?[A-E]\*/C
- data> E*
- --->E*
- +0 ^ \d?
- +3 ^ [A-E]
- +8 ^^ \*
- +10 ^ ^
- 0: E*
-</pre>
-The callout function in <b>pcretest</b> returns zero (carry on matching) by
-default, but you can use an \C item in a data line (as described above) to
-change this.
-</P>
-<P>
-Inserting callouts can be helpful when using <b>pcretest</b> to check
-complicated regular expressions. For further information about callouts, see
-the
-<a href="pcrecallout.html"><b>pcrecallout</b></a>
-documentation.
-</P>
-<br><a name="SEC8" href="#TOC1">SAVING AND RELOADING COMPILED PATTERNS</a><br>
-<P>
-The facilities described in this section are not available when the POSIX
-inteface to PCRE is being used, that is, when the <b>/P</b> pattern modifier is
-specified.
-</P>
-<P>
-When the POSIX interface is not in use, you can cause <b>pcretest</b> to write a
-compiled pattern to a file, by following the modifiers with > and a file name.
-For example:
-<pre>
- /pattern/im >/some/file
-</pre>
-See the
-<a href="pcreprecompile.html"><b>pcreprecompile</b></a>
-documentation for a discussion about saving and re-using compiled patterns.
-</P>
-<P>
-The data that is written is binary. The first eight bytes are the length of the
-compiled pattern data followed by the length of the optional study data, each
-written as four bytes in big-endian order (most significant byte first). If
-there is no study data (either the pattern was not studied, or studying did not
-return any data), the second length is zero. The lengths are followed by an
-exact copy of the compiled pattern. If there is additional study data, this
-follows immediately after the compiled pattern. After writing the file,
-<b>pcretest</b> expects to read a new pattern.
-</P>
-<P>
-A saved pattern can be reloaded into <b>pcretest</b> by specifing < and a file
-name instead of a pattern. The name of the file must not contain a < character,
-as otherwise <b>pcretest</b> will interpret the line as a pattern delimited by <
-characters.
-For example:
-<pre>
- re> </some/file
- Compiled regex loaded from /some/file
- No study data
-</pre>
-When the pattern has been loaded, <b>pcretest</b> proceeds to read data lines in
-the usual way.
-</P>
-<P>
-You can copy a file written by <b>pcretest</b> to a different host and reload it
-there, even if the new host has opposite endianness to the one on which the
-pattern was compiled. For example, you can compile on an i86 machine and run on
-a SPARC machine.
-</P>
-<P>
-File names for saving and reloading can be absolute or relative, but note that
-the shell facility of expanding a file name that starts with a tilde (~) is not
-available.
-</P>
-<P>
-The ability to save and reload files in <b>pcretest</b> is intended for testing
-and experimentation. It is not intended for production use because only a
-single pattern can be written to a file. Furthermore, there is no facility for
-supplying custom character tables for use with a reloaded pattern. If the
-original pattern was compiled with custom tables, an attempt to match a subject
-string using a reloaded pattern is likely to cause <b>pcretest</b> to crash.
-Finally, if you attempt to load a file that is not in the correct format, the
-result is undefined.
-</P>
-<br><a name="SEC9" href="#TOC1">AUTHOR</a><br>
-<P>
-Philip Hazel <ph10@cam.ac.uk>
-<br>
-University Computing Service,
-<br>
-Cambridge CB2 3QG, England.
-</P>
-<P>
-Last updated: 10 September 2004
-<br>
-Copyright © 1997-2004 University of Cambridge.
-<p>
-Return to the <a href="index.html">PCRE index page</a>.
-</p>
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH INTRODUCTION
-.rs
-.sp
-The PCRE library is a set of functions that implement regular expression
-pattern matching using the same syntax and semantics as Perl, with just a few
-differences. The current implementation of PCRE (release 5.x) corresponds
-approximately with Perl 5.8, including support for UTF-8 encoded strings and
-Unicode general category properties. However, this support has to be explicitly
-enabled; it is not the default.
-.P
-PCRE is written in C and released as a C library. A number of people have
-written wrappers and interfaces of various kinds. A C++ class is included in
-these contributions, which can be found in the \fIContrib\fR directory at the
-primary FTP site, which is:
-.sp
-.\" HTML <a href="ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre">
-.\" </a>
-ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre
-.P
-Details of exactly which Perl regular expression features are and are not
-supported by PCRE are given in separate documents. See the
-.\" HREF
-\fBpcrepattern\fR
-.\"
-and
-.\" HREF
-\fBpcrecompat\fR
-.\"
-pages.
-.P
-Some features of PCRE can be included, excluded, or changed when the library is
-built. The
-.\" HREF
-\fBpcre_config()\fR
-.\"
-function makes it possible for a client to discover which features are
-available. The features themselves are described in the
-.\" HREF
-\fBpcrebuild\fP
-.\"
-page. Documentation about building PCRE for various operating systems can be
-found in the \fBREADME\fP file in the source distribution.
-.
-.
-.SH "USER DOCUMENTATION"
-.rs
-.sp
-The user documentation for PCRE comprises a number of different sections. In
-the "man" format, each of these is a separate "man page". In the HTML format,
-each is a separate page, linked from the index page. In the plain text format,
-all the sections are concatenated, for ease of searching. The sections are as
-follows:
-.sp
- pcre this document
- pcreapi details of PCRE's native API
- pcrebuild options for building PCRE
- pcrecallout details of the callout feature
- pcrecompat discussion of Perl compatibility
- pcregrep description of the \fBpcregrep\fP command
- pcrepartial details of the partial matching facility
-.\" JOIN
- pcrepattern syntax and semantics of supported
- regular expressions
- pcreperform discussion of performance issues
- pcreposix the POSIX-compatible API
- pcreprecompile details of saving and re-using precompiled patterns
- pcresample discussion of the sample program
- pcretest description of the \fBpcretest\fP testing command
-.sp
-In addition, in the "man" and HTML formats, there is a short page for each
-library function, listing its arguments and results.
-.
-.
-.SH LIMITATIONS
-.rs
-.sp
-There are some size limitations in PCRE but it is hoped that they will never in
-practice be relevant.
-.P
-The maximum length of a compiled pattern is 65539 (sic) bytes if PCRE is
-compiled with the default internal linkage size of 2. If you want to process
-regular expressions that are truly enormous, you can compile PCRE with an
-internal linkage size of 3 or 4 (see the \fBREADME\fP file in the source
-distribution and the
-.\" HREF
-\fBpcrebuild\fP
-.\"
-documentation for details). In these cases the limit is substantially larger.
-However, the speed of execution will be slower.
-.P
-All values in repeating quantifiers must be less than 65536.
-The maximum number of capturing subpatterns is 65535.
-.P
-There is no limit to the number of non-capturing subpatterns, but the maximum
-depth of nesting of all kinds of parenthesized subpattern, including capturing
-subpatterns, assertions, and other types of subpattern, is 200.
-.P
-The maximum length of a subject string is the largest positive number that an
-integer variable can hold. However, PCRE uses recursion to handle subpatterns
-and indefinite repetition. This means that the available stack space may limit
-the size of a subject string that can be processed by certain patterns.
-.sp
-.\" HTML <a name="utf8support"></a>
-.
-.
-.SH "UTF-8 AND UNICODE PROPERTY SUPPORT"
-.rs
-.sp
-From release 3.3, PCRE has had some support for character strings encoded in
-the UTF-8 format. For release 4.0 this was greatly extended to cover most
-common requirements, and in release 5.0 additional support for Unicode general
-category properties was added.
-.P
-In order process UTF-8 strings, you must build PCRE to include UTF-8 support in
-the code, and, in addition, you must call
-.\" HREF
-\fBpcre_compile()\fP
-.\"
-with the PCRE_UTF8 option flag. When you do this, both the pattern and any
-subject strings that are matched against it are treated as UTF-8 strings
-instead of just strings of bytes.
-.P
-If you compile PCRE with UTF-8 support, but do not use it at run time, the
-library will be a bit bigger, but the additional run time overhead is limited
-to testing the PCRE_UTF8 flag in several places, so should not be very large.
-.P
-If PCRE is built with Unicode character property support (which implies UTF-8
-support), the escape sequences \ep{..}, \eP{..}, and \eX are supported.
-The available properties that can be tested are limited to the general
-category properties such as Lu for an upper case letter or Nd for a decimal
-number. A full list is given in the
-.\" HREF
-\fBpcrepattern\fP
-.\"
-documentation. The PCRE library is increased in size by about 90K when Unicode
-property support is included.
-.P
-The following comments apply when PCRE is running in UTF-8 mode:
-.P
-1. When you set the PCRE_UTF8 flag, the strings passed as patterns and subjects
-are checked for validity on entry to the relevant functions. If an invalid
-UTF-8 string is passed, an error return is given. In some situations, you may
-already know that your strings are valid, and therefore want to skip these
-checks in order to improve performance. If you set the PCRE_NO_UTF8_CHECK flag
-at compile time or at run time, PCRE assumes that the pattern or subject it
-is given (respectively) contains only valid UTF-8 codes. In this case, it does
-not diagnose an invalid UTF-8 string. If you pass an invalid UTF-8 string to
-PCRE when PCRE_NO_UTF8_CHECK is set, the results are undefined. Your program
-may crash.
-.P
-2. In a pattern, the escape sequence \ex{...}, where the contents of the braces
-is a string of hexadecimal digits, is interpreted as a UTF-8 character whose
-code number is the given hexadecimal number, for example: \ex{1234}. If a
-non-hexadecimal digit appears between the braces, the item is not recognized.
-This escape sequence can be used either as a literal, or within a character
-class.
-.P
-3. The original hexadecimal escape sequence, \exhh, matches a two-byte UTF-8
-character if the value is greater than 127.
-.P
-4. Repeat quantifiers apply to complete UTF-8 characters, not to individual
-bytes, for example: \ex{100}{3}.
-.P
-5. The dot metacharacter matches one UTF-8 character instead of a single byte.
-.P
-6. The escape sequence \eC can be used to match a single byte in UTF-8 mode,
-but its use can lead to some strange effects.
-.P
-7. The character escapes \eb, \eB, \ed, \eD, \es, \eS, \ew, and \eW correctly
-test characters of any code value, but the characters that PCRE recognizes as
-digits, spaces, or word characters remain the same set as before, all with
-values less than 256. This remains true even when PCRE includes Unicode
-property support, because to do otherwise would slow down PCRE in many common
-cases. If you really want to test for a wider sense of, say, "digit", you
-must use Unicode property tests such as \ep{Nd}.
-.P
-8. Similarly, characters that match the POSIX named character classes are all
-low-valued characters.
-.P
-9. Case-insensitive matching applies only to characters whose values are less
-than 128, unless PCRE is built with Unicode property support. Even when Unicode
-property support is available, PCRE still uses its own character tables when
-checking the case of low-valued characters, so as not to degrade performance.
-The Unicode property information is used only for characters with higher
-values.
-.
-.SH AUTHOR
-.rs
-.sp
-Philip Hazel <ph10@cam.ac.uk>
-.br
-University Computing Service,
-.br
-Cambridge CB2 3QG, England.
-.br
-Phone: +44 1223 334714
-.sp
-.in 0
-Last updated: 09 September 2004
-.br
-Copyright (c) 1997-2004 University of Cambridge.
+++ /dev/null
-<HTML>
-<HEAD>
-<TITLE>pcre specification</TITLE>
-</HEAD>
-<body bgcolor="#FFFFFF" text="#00005A">
-<H1>pcre specification</H1>
-This HTML document has been generated automatically from the original man page.
-If there is any nonsense in it, please consult the man page in case the
-conversion went wrong.
-<UL>
-<LI><A NAME="TOC1" HREF="#SEC1">NAME</A>
-<LI><A NAME="TOC2" HREF="#SEC2">SYNOPSIS</A>
-<LI><A NAME="TOC3" HREF="#SEC3">DESCRIPTION</A>
-<LI><A NAME="TOC4" HREF="#SEC4">MULTI-THREADING</A>
-<LI><A NAME="TOC5" HREF="#SEC5">COMPILING A PATTERN</A>
-<LI><A NAME="TOC6" HREF="#SEC6">STUDYING A PATTERN</A>
-<LI><A NAME="TOC7" HREF="#SEC7">LOCALE SUPPORT</A>
-<LI><A NAME="TOC8" HREF="#SEC8">INFORMATION ABOUT A PATTERN</A>
-<LI><A NAME="TOC9" HREF="#SEC9">MATCHING A PATTERN</A>
-<LI><A NAME="TOC10" HREF="#SEC10">EXTRACTING CAPTURED SUBSTRINGS</A>
-<LI><A NAME="TOC11" HREF="#SEC11">LIMITATIONS</A>
-<LI><A NAME="TOC12" HREF="#SEC12">DIFFERENCES FROM PERL</A>
-<LI><A NAME="TOC13" HREF="#SEC13">REGULAR EXPRESSION DETAILS</A>
-<LI><A NAME="TOC14" HREF="#SEC14">BACKSLASH</A>
-<LI><A NAME="TOC15" HREF="#SEC15">CIRCUMFLEX AND DOLLAR</A>
-<LI><A NAME="TOC16" HREF="#SEC16">FULL STOP (PERIOD, DOT)</A>
-<LI><A NAME="TOC17" HREF="#SEC17">SQUARE BRACKETS</A>
-<LI><A NAME="TOC18" HREF="#SEC18">POSIX CHARACTER CLASSES</A>
-<LI><A NAME="TOC19" HREF="#SEC19">VERTICAL BAR</A>
-<LI><A NAME="TOC20" HREF="#SEC20">INTERNAL OPTION SETTING</A>
-<LI><A NAME="TOC21" HREF="#SEC21">SUBPATTERNS</A>
-<LI><A NAME="TOC22" HREF="#SEC22">REPETITION</A>
-<LI><A NAME="TOC23" HREF="#SEC23">BACK REFERENCES</A>
-<LI><A NAME="TOC24" HREF="#SEC24">ASSERTIONS</A>
-<LI><A NAME="TOC25" HREF="#SEC25">ONCE-ONLY SUBPATTERNS</A>
-<LI><A NAME="TOC26" HREF="#SEC26">CONDITIONAL SUBPATTERNS</A>
-<LI><A NAME="TOC27" HREF="#SEC27">COMMENTS</A>
-<LI><A NAME="TOC28" HREF="#SEC28">RECURSIVE PATTERNS</A>
-<LI><A NAME="TOC29" HREF="#SEC29">PERFORMANCE</A>
-<LI><A NAME="TOC30" HREF="#SEC30">UTF-8 SUPPORT</A>
-<LI><A NAME="TOC31" HREF="#SEC31">SAMPLE PROGRAM</A>
-<LI><A NAME="TOC32" HREF="#SEC32">AUTHOR</A>
-</UL>
-<LI><A NAME="SEC1" HREF="#TOC1">NAME</A>
-<P>
-pcre - Perl-compatible regular expressions.
-</P>
-<LI><A NAME="SEC2" HREF="#TOC1">SYNOPSIS</A>
-<P>
-<B>#include <pcre.h></B>
-</P>
-<P>
-<B>pcre *pcre_compile(const char *<I>pattern</I>, int <I>options</I>,</B>
-<B>const char **<I>errptr</I>, int *<I>erroffset</I>,</B>
-<B>const unsigned char *<I>tableptr</I>);</B>
-</P>
-<P>
-<B>pcre_extra *pcre_study(const pcre *<I>code</I>, int <I>options</I>,</B>
-<B>const char **<I>errptr</I>);</B>
-</P>
-<P>
-<B>int pcre_exec(const pcre *<I>code</I>, const pcre_extra *<I>extra</I>,</B>
-<B>const char *<I>subject</I>, int <I>length</I>, int <I>startoffset</I>,</B>
-<B>int <I>options</I>, int *<I>ovector</I>, int <I>ovecsize</I>);</B>
-</P>
-<P>
-<B>int pcre_copy_substring(const char *<I>subject</I>, int *<I>ovector</I>,</B>
-<B>int <I>stringcount</I>, int <I>stringnumber</I>, char *<I>buffer</I>,</B>
-<B>int <I>buffersize</I>);</B>
-</P>
-<P>
-<B>int pcre_get_substring(const char *<I>subject</I>, int *<I>ovector</I>,</B>
-<B>int <I>stringcount</I>, int <I>stringnumber</I>,</B>
-<B>const char **<I>stringptr</I>);</B>
-</P>
-<P>
-<B>int pcre_get_substring_list(const char *<I>subject</I>,</B>
-<B>int *<I>ovector</I>, int <I>stringcount</I>, const char ***<I>listptr</I>);</B>
-</P>
-<P>
-<B>void pcre_free_substring(const char *<I>stringptr</I>);</B>
-</P>
-<P>
-<B>void pcre_free_substring_list(const char **<I>stringptr</I>);</B>
-</P>
-<P>
-<B>const unsigned char *pcre_maketables(void);</B>
-</P>
-<P>
-<B>int pcre_fullinfo(const pcre *<I>code</I>, const pcre_extra *<I>extra</I>,</B>
-<B>int <I>what</I>, void *<I>where</I>);</B>
-</P>
-<P>
-<B>int pcre_info(const pcre *<I>code</I>, int *<I>optptr</I>, int</B>
-<B>*<I>firstcharptr</I>);</B>
-</P>
-<P>
-<B>char *pcre_version(void);</B>
-</P>
-<P>
-<B>void *(*pcre_malloc)(size_t);</B>
-</P>
-<P>
-<B>void (*pcre_free)(void *);</B>
-</P>
-<LI><A NAME="SEC3" HREF="#TOC1">DESCRIPTION</A>
-<P>
-The PCRE library is a set of functions that implement regular expression
-pattern matching using the same syntax and semantics as Perl 5, with just a few
-differences (see below). The current implementation corresponds to Perl 5.005,
-with some additional features from later versions. This includes some
-experimental, incomplete support for UTF-8 encoded strings. Details of exactly
-what is and what is not supported are given below.
-</P>
-<P>
-PCRE has its own native API, which is described in this document. There is also
-a set of wrapper functions that correspond to the POSIX regular expression API.
-These are described in the <B>pcreposix</B> documentation.
-</P>
-<P>
-The native API function prototypes are defined in the header file <B>pcre.h</B>,
-and on Unix systems the library itself is called <B>libpcre.a</B>, so can be
-accessed by adding <B>-lpcre</B> to the command for linking an application which
-calls it. The header file defines the macros PCRE_MAJOR and PCRE_MINOR to
-contain the major and minor release numbers for the library. Applications can
-use these to include support for different releases.
-</P>
-<P>
-The functions <B>pcre_compile()</B>, <B>pcre_study()</B>, and <B>pcre_exec()</B>
-are used for compiling and matching regular expressions. A sample program that
-demonstrates the simplest way of using them is given in the file
-<I>pcredemo.c</I>. The last section of this man page describes how to run it.
-</P>
-<P>
-The functions <B>pcre_copy_substring()</B>, <B>pcre_get_substring()</B>, and
-<B>pcre_get_substring_list()</B> are convenience functions for extracting
-captured substrings from a matched subject string; <B>pcre_free_substring()</B>
-and <B>pcre_free_substring_list()</B> are also provided, to free the memory used
-for extracted strings.
-</P>
-<P>
-The function <B>pcre_maketables()</B> is used (optionally) to build a set of
-character tables in the current locale for passing to <B>pcre_compile()</B>.
-</P>
-<P>
-The function <B>pcre_fullinfo()</B> is used to find out information about a
-compiled pattern; <B>pcre_info()</B> is an obsolete version which returns only
-some of the available information, but is retained for backwards compatibility.
-The function <B>pcre_version()</B> returns a pointer to a string containing the
-version of PCRE and its date of release.
-</P>
-<P>
-The global variables <B>pcre_malloc</B> and <B>pcre_free</B> initially contain
-the entry points of the standard <B>malloc()</B> and <B>free()</B> functions
-respectively. PCRE calls the memory management functions via these variables,
-so a calling program can replace them if it wishes to intercept the calls. This
-should be done before calling any PCRE functions.
-</P>
-<LI><A NAME="SEC4" HREF="#TOC1">MULTI-THREADING</A>
-<P>
-The PCRE functions can be used in multi-threading applications, with the
-proviso that the memory management functions pointed to by <B>pcre_malloc</B>
-and <B>pcre_free</B> are shared by all threads.
-</P>
-<P>
-The compiled form of a regular expression is not altered during matching, so
-the same compiled pattern can safely be used by several threads at once.
-</P>
-<LI><A NAME="SEC5" HREF="#TOC1">COMPILING A PATTERN</A>
-<P>
-The function <B>pcre_compile()</B> is called to compile a pattern into an
-internal form. The pattern is a C string terminated by a binary zero, and
-is passed in the argument <I>pattern</I>. A pointer to a single block of memory
-that is obtained via <B>pcre_malloc</B> is returned. This contains the compiled
-code and related data. The <B>pcre</B> type is defined for the returned block;
-this is a typedef for a structure whose contents are not externally defined. It
-is up to the caller to free the memory when it is no longer required.
-</P>
-<P>
-Although the compiled code of a PCRE regex is relocatable, that is, it does not
-depend on memory location, the complete <B>pcre</B> data block is not
-fully relocatable, because it contains a copy of the <I>tableptr</I> argument,
-which is an address (see below).
-</P>
-<P>
-The size of a compiled pattern is roughly proportional to the length of the
-pattern string, except that each character class (other than those containing
-just a single character, negated or not) requires 33 bytes, and repeat
-quantifiers with a minimum greater than one or a bounded maximum cause the
-relevant portions of the compiled pattern to be replicated.
-</P>
-<P>
-The <I>options</I> argument contains independent bits that affect the
-compilation. It should be zero if no options are required. Some of the options,
-in particular, those that are compatible with Perl, can also be set and unset
-from within the pattern (see the detailed description of regular expressions
-below). For these options, the contents of the <I>options</I> argument specifies
-their initial settings at the start of compilation and execution. The
-PCRE_ANCHORED option can be set at the time of matching as well as at compile
-time.
-</P>
-<P>
-If <I>errptr</I> is NULL, <B>pcre_compile()</B> returns NULL immediately.
-Otherwise, if compilation of a pattern fails, <B>pcre_compile()</B> returns
-NULL, and sets the variable pointed to by <I>errptr</I> to point to a textual
-error message. The offset from the start of the pattern to the character where
-the error was discovered is placed in the variable pointed to by
-<I>erroffset</I>, which must not be NULL. If it is, an immediate error is given.
-</P>
-<P>
-If the final argument, <I>tableptr</I>, is NULL, PCRE uses a default set of
-character tables which are built when it is compiled, using the default C
-locale. Otherwise, <I>tableptr</I> must be the result of a call to
-<B>pcre_maketables()</B>. See the section on locale support below.
-</P>
-<P>
-This code fragment shows a typical straightforward call to <B>pcre_compile()</B>:
-</P>
-<P>
-<PRE>
- pcre *re;
- const char *error;
- int erroffset;
- re = pcre_compile(
- "^A.*Z", /* the pattern */
- 0, /* default options */
- &error, /* for error message */
- &erroffset, /* for error offset */
- NULL); /* use default character tables */
-</PRE>
-</P>
-<P>
-The following option bits are defined in the header file:
-</P>
-<P>
-<PRE>
- PCRE_ANCHORED
-</PRE>
-</P>
-<P>
-If this bit is set, the pattern is forced to be "anchored", that is, it is
-constrained to match only at the start of the string which is being searched
-(the "subject string"). This effect can also be achieved by appropriate
-constructs in the pattern itself, which is the only way to do it in Perl.
-</P>
-<P>
-<PRE>
- PCRE_CASELESS
-</PRE>
-</P>
-<P>
-If this bit is set, letters in the pattern match both upper and lower case
-letters. It is equivalent to Perl's /i option.
-</P>
-<P>
-<PRE>
- PCRE_DOLLAR_ENDONLY
-</PRE>
-</P>
-<P>
-If this bit is set, a dollar metacharacter in the pattern matches only at the
-end of the subject string. Without this option, a dollar also matches
-immediately before the final character if it is a newline (but not before any
-other newlines). The PCRE_DOLLAR_ENDONLY option is ignored if PCRE_MULTILINE is
-set. There is no equivalent to this option in Perl.
-</P>
-<P>
-<PRE>
- PCRE_DOTALL
-</PRE>
-</P>
-<P>
-If this bit is set, a dot metacharater in the pattern matches all characters,
-including newlines. Without it, newlines are excluded. This option is
-equivalent to Perl's /s option. A negative class such as [^a] always matches a
-newline character, independent of the setting of this option.
-</P>
-<P>
-<PRE>
- PCRE_EXTENDED
-</PRE>
-</P>
-<P>
-If this bit is set, whitespace data characters in the pattern are totally
-ignored except when escaped or inside a character class, and characters between
-an unescaped # outside a character class and the next newline character,
-inclusive, are also ignored. This is equivalent to Perl's /x option, and makes
-it possible to include comments inside complicated patterns. Note, however,
-that this applies only to data characters. Whitespace characters may never
-appear within special character sequences in a pattern, for example within the
-sequence (?( which introduces a conditional subpattern.
-</P>
-<P>
-<PRE>
- PCRE_EXTRA
-</PRE>
-</P>
-<P>
-This option was invented in order to turn on additional functionality of PCRE
-that is incompatible with Perl, but it is currently of very little use. When
-set, any backslash in a pattern that is followed by a letter that has no
-special meaning causes an error, thus reserving these combinations for future
-expansion. By default, as in Perl, a backslash followed by a letter with no
-special meaning is treated as a literal. There are at present no other features
-controlled by this option. It can also be set by a (?X) option setting within a
-pattern.
-</P>
-<P>
-<PRE>
- PCRE_MULTILINE
-</PRE>
-</P>
-<P>
-By default, PCRE treats the subject string as consisting of a single "line" of
-characters (even if it actually contains several newlines). The "start of line"
-metacharacter (^) matches only at the start of the string, while the "end of
-line" metacharacter ($) matches only at the end of the string, or before a
-terminating newline (unless PCRE_DOLLAR_ENDONLY is set). This is the same as
-Perl.
-</P>
-<P>
-When PCRE_MULTILINE it is set, the "start of line" and "end of line" constructs
-match immediately following or immediately before any newline in the subject
-string, respectively, as well as at the very start and end. This is equivalent
-to Perl's /m option. If there are no "\n" characters in a subject string, or
-no occurrences of ^ or $ in a pattern, setting PCRE_MULTILINE has no
-effect.
-</P>
-<P>
-<PRE>
- PCRE_UNGREEDY
-</PRE>
-</P>
-<P>
-This option inverts the "greediness" of the quantifiers so that they are not
-greedy by default, but become greedy if followed by "?". It is not compatible
-with Perl. It can also be set by a (?U) option setting within the pattern.
-</P>
-<P>
-<PRE>
- PCRE_UTF8
-</PRE>
-</P>
-<P>
-This option causes PCRE to regard both the pattern and the subject as strings
-of UTF-8 characters instead of just byte strings. However, it is available only
-if PCRE has been built to include UTF-8 support. If not, the use of this option
-provokes an error. Support for UTF-8 is new, experimental, and incomplete.
-Details of exactly what it entails are given below.
-</P>
-<LI><A NAME="SEC6" HREF="#TOC1">STUDYING A PATTERN</A>
-<P>
-When a pattern is going to be used several times, it is worth spending more
-time analyzing it in order to speed up the time taken for matching. The
-function <B>pcre_study()</B> takes a pointer to a compiled pattern as its first
-argument, and returns a pointer to a <B>pcre_extra</B> block (another typedef
-for a structure with hidden contents) containing additional information about
-the pattern; this can be passed to <B>pcre_exec()</B>. If no additional
-information is available, NULL is returned.
-</P>
-<P>
-The second argument contains option bits. At present, no options are defined
-for <B>pcre_study()</B>, and this argument should always be zero.
-</P>
-<P>
-The third argument for <B>pcre_study()</B> is a pointer to an error message. If
-studying succeeds (even if no data is returned), the variable it points to is
-set to NULL. Otherwise it points to a textual error message.
-</P>
-<P>
-This is a typical call to <B>pcre_study</B>():
-</P>
-<P>
-<PRE>
- pcre_extra *pe;
- pe = pcre_study(
- re, /* result of pcre_compile() */
- 0, /* no options exist */
- &error); /* set to NULL or points to a message */
-</PRE>
-</P>
-<P>
-At present, studying a pattern is useful only for non-anchored patterns that do
-not have a single fixed starting character. A bitmap of possible starting
-characters is created.
-</P>
-<LI><A NAME="SEC7" HREF="#TOC1">LOCALE SUPPORT</A>
-<P>
-PCRE handles caseless matching, and determines whether characters are letters,
-digits, or whatever, by reference to a set of tables. The library contains a
-default set of tables which is created in the default C locale when PCRE is
-compiled. This is used when the final argument of <B>pcre_compile()</B> is NULL,
-and is sufficient for many applications.
-</P>
-<P>
-An alternative set of tables can, however, be supplied. Such tables are built
-by calling the <B>pcre_maketables()</B> function, which has no arguments, in the
-relevant locale. The result can then be passed to <B>pcre_compile()</B> as often
-as necessary. For example, to build and use tables that are appropriate for the
-French locale (where accented characters with codes greater than 128 are
-treated as letters), the following code could be used:
-</P>
-<P>
-<PRE>
- setlocale(LC_CTYPE, "fr");
- tables = pcre_maketables();
- re = pcre_compile(..., tables);
-</PRE>
-</P>
-<P>
-The tables are built in memory that is obtained via <B>pcre_malloc</B>. The
-pointer that is passed to <B>pcre_compile</B> is saved with the compiled
-pattern, and the same tables are used via this pointer by <B>pcre_study()</B>
-and <B>pcre_exec()</B>. Thus for any single pattern, compilation, studying and
-matching all happen in the same locale, but different patterns can be compiled
-in different locales. It is the caller's responsibility to ensure that the
-memory containing the tables remains available for as long as it is needed.
-</P>
-<LI><A NAME="SEC8" HREF="#TOC1">INFORMATION ABOUT A PATTERN</A>
-<P>
-The <B>pcre_fullinfo()</B> function returns information about a compiled
-pattern. It replaces the obsolete <B>pcre_info()</B> function, which is
-nevertheless retained for backwards compability (and is documented below).
-</P>
-<P>
-The first argument for <B>pcre_fullinfo()</B> is a pointer to the compiled
-pattern. The second argument is the result of <B>pcre_study()</B>, or NULL if
-the pattern was not studied. The third argument specifies which piece of
-information is required, while the fourth argument is a pointer to a variable
-to receive the data. The yield of the function is zero for success, or one of
-the following negative numbers:
-</P>
-<P>
-<PRE>
- PCRE_ERROR_NULL the argument <I>code</I> was NULL
- the argument <I>where</I> was NULL
- PCRE_ERROR_BADMAGIC the "magic number" was not found
- PCRE_ERROR_BADOPTION the value of <I>what</I> was invalid
-</PRE>
-</P>
-<P>
-Here is a typical call of <B>pcre_fullinfo()</B>, to obtain the length of the
-compiled pattern:
-</P>
-<P>
-<PRE>
- int rc;
- unsigned long int length;
- rc = pcre_fullinfo(
- re, /* result of pcre_compile() */
- pe, /* result of pcre_study(), or NULL */
- PCRE_INFO_SIZE, /* what is required */
- &length); /* where to put the data */
-</PRE>
-</P>
-<P>
-The possible values for the third argument are defined in <B>pcre.h</B>, and are
-as follows:
-</P>
-<P>
-<PRE>
- PCRE_INFO_OPTIONS
-</PRE>
-</P>
-<P>
-Return a copy of the options with which the pattern was compiled. The fourth
-argument should point to an <B>unsigned long int</B> variable. These option bits
-are those specified in the call to <B>pcre_compile()</B>, modified by any
-top-level option settings within the pattern itself, and with the PCRE_ANCHORED
-bit forcibly set if the form of the pattern implies that it can match only at
-the start of a subject string.
-</P>
-<P>
-<PRE>
- PCRE_INFO_SIZE
-</PRE>
-</P>
-<P>
-Return the size of the compiled pattern, that is, the value that was passed as
-the argument to <B>pcre_malloc()</B> when PCRE was getting memory in which to
-place the compiled data. The fourth argument should point to a <B>size_t</B>
-variable.
-</P>
-<P>
-<PRE>
- PCRE_INFO_CAPTURECOUNT
-</PRE>
-</P>
-<P>
-Return the number of capturing subpatterns in the pattern. The fourth argument
-should point to an \fbint\fR variable.
-</P>
-<P>
-<PRE>
- PCRE_INFO_BACKREFMAX
-</PRE>
-</P>
-<P>
-Return the number of the highest back reference in the pattern. The fourth
-argument should point to an <B>int</B> variable. Zero is returned if there are
-no back references.
-</P>
-<P>
-<PRE>
- PCRE_INFO_FIRSTCHAR
-</PRE>
-</P>
-<P>
-Return information about the first character of any matched string, for a
-non-anchored pattern. If there is a fixed first character, e.g. from a pattern
-such as (cat|cow|coyote), it is returned in the integer pointed to by
-<I>where</I>. Otherwise, if either
-</P>
-<P>
-(a) the pattern was compiled with the PCRE_MULTILINE option, and every branch
-starts with "^", or
-</P>
-<P>
-(b) every branch of the pattern starts with ".*" and PCRE_DOTALL is not set
-(if it were set, the pattern would be anchored),
-</P>
-<P>
--1 is returned, indicating that the pattern matches only at the start of a
-subject string or after any "\n" within the string. Otherwise -2 is returned.
-For anchored patterns, -2 is returned.
-</P>
-<P>
-<PRE>
- PCRE_INFO_FIRSTTABLE
-</PRE>
-</P>
-<P>
-If the pattern was studied, and this resulted in the construction of a 256-bit
-table indicating a fixed set of characters for the first character in any
-matching string, a pointer to the table is returned. Otherwise NULL is
-returned. The fourth argument should point to an <B>unsigned char *</B>
-variable.
-</P>
-<P>
-<PRE>
- PCRE_INFO_LASTLITERAL
-</PRE>
-</P>
-<P>
-For a non-anchored pattern, return the value of the rightmost literal character
-which must exist in any matched string, other than at its start. The fourth
-argument should point to an <B>int</B> variable. If there is no such character,
-or if the pattern is anchored, -1 is returned. For example, for the pattern
-/a\d+z\d+/ the returned value is 'z'.
-</P>
-<P>
-The <B>pcre_info()</B> function is now obsolete because its interface is too
-restrictive to return all the available data about a compiled pattern. New
-programs should use <B>pcre_fullinfo()</B> instead. The yield of
-<B>pcre_info()</B> is the number of capturing subpatterns, or one of the
-following negative numbers:
-</P>
-<P>
-<PRE>
- PCRE_ERROR_NULL the argument <I>code</I> was NULL
- PCRE_ERROR_BADMAGIC the "magic number" was not found
-</PRE>
-</P>
-<P>
-If the <I>optptr</I> argument is not NULL, a copy of the options with which the
-pattern was compiled is placed in the integer it points to (see
-PCRE_INFO_OPTIONS above).
-</P>
-<P>
-If the pattern is not anchored and the <I>firstcharptr</I> argument is not NULL,
-it is used to pass back information about the first character of any matched
-string (see PCRE_INFO_FIRSTCHAR above).
-</P>
-<LI><A NAME="SEC9" HREF="#TOC1">MATCHING A PATTERN</A>
-<P>
-The function <B>pcre_exec()</B> is called to match a subject string against a
-pre-compiled pattern, which is passed in the <I>code</I> argument. If the
-pattern has been studied, the result of the study should be passed in the
-<I>extra</I> argument. Otherwise this must be NULL.
-</P>
-<P>
-Here is an example of a simple call to <B>pcre_exec()</B>:
-</P>
-<P>
-<PRE>
- int rc;
- int ovector[30];
- rc = pcre_exec(
- re, /* result of pcre_compile() */
- NULL, /* we didn't study the pattern */
- "some string", /* the subject string */
- 11, /* the length of the subject string */
- 0, /* start at offset 0 in the subject */
- 0, /* default options */
- ovector, /* vector for substring information */
- 30); /* number of elements in the vector */
-</PRE>
-</P>
-<P>
-The PCRE_ANCHORED option can be passed in the <I>options</I> argument, whose
-unused bits must be zero. However, if a pattern was compiled with
-PCRE_ANCHORED, or turned out to be anchored by virtue of its contents, it
-cannot be made unachored at matching time.
-</P>
-<P>
-There are also three further options that can be set only at matching time:
-</P>
-<P>
-<PRE>
- PCRE_NOTBOL
-</PRE>
-</P>
-<P>
-The first character of the string is not the beginning of a line, so the
-circumflex metacharacter should not match before it. Setting this without
-PCRE_MULTILINE (at compile time) causes circumflex never to match.
-</P>
-<P>
-<PRE>
- PCRE_NOTEOL
-</PRE>
-</P>
-<P>
-The end of the string is not the end of a line, so the dollar metacharacter
-should not match it nor (except in multiline mode) a newline immediately before
-it. Setting this without PCRE_MULTILINE (at compile time) causes dollar never
-to match.
-</P>
-<P>
-<PRE>
- PCRE_NOTEMPTY
-</PRE>
-</P>
-<P>
-An empty string is not considered to be a valid match if this option is set. If
-there are alternatives in the pattern, they are tried. If all the alternatives
-match the empty string, the entire match fails. For example, if the pattern
-</P>
-<P>
-<PRE>
- a?b?
-</PRE>
-</P>
-<P>
-is applied to a string not beginning with "a" or "b", it matches the empty
-string at the start of the subject. With PCRE_NOTEMPTY set, this match is not
-valid, so PCRE searches further into the string for occurrences of "a" or "b".
-</P>
-<P>
-Perl has no direct equivalent of PCRE_NOTEMPTY, but it does make a special case
-of a pattern match of the empty string within its <B>split()</B> function, and
-when using the /g modifier. It is possible to emulate Perl's behaviour after
-matching a null string by first trying the match again at the same offset with
-PCRE_NOTEMPTY set, and then if that fails by advancing the starting offset (see
-below) and trying an ordinary match again.
-</P>
-<P>
-The subject string is passed as a pointer in <I>subject</I>, a length in
-<I>length</I>, and a starting offset in <I>startoffset</I>. Unlike the pattern
-string, the subject may contain binary zero characters. When the starting
-offset is zero, the search for a match starts at the beginning of the subject,
-and this is by far the most common case.
-</P>
-<P>
-A non-zero starting offset is useful when searching for another match in the
-same subject by calling <B>pcre_exec()</B> again after a previous success.
-Setting <I>startoffset</I> differs from just passing over a shortened string and
-setting PCRE_NOTBOL in the case of a pattern that begins with any kind of
-lookbehind. For example, consider the pattern
-</P>
-<P>
-<PRE>
- \Biss\B
-</PRE>
-</P>
-<P>
-which finds occurrences of "iss" in the middle of words. (\B matches only if
-the current position in the subject is not a word boundary.) When applied to
-the string "Mississipi" the first call to <B>pcre_exec()</B> finds the first
-occurrence. If <B>pcre_exec()</B> is called again with just the remainder of the
-subject, namely "issipi", it does not match, because \B is always false at the
-start of the subject, which is deemed to be a word boundary. However, if
-<B>pcre_exec()</B> is passed the entire string again, but with <I>startoffset</I>
-set to 4, it finds the second occurrence of "iss" because it is able to look
-behind the starting point to discover that it is preceded by a letter.
-</P>
-<P>
-If a non-zero starting offset is passed when the pattern is anchored, one
-attempt to match at the given offset is tried. This can only succeed if the
-pattern does not require the match to be at the start of the subject.
-</P>
-<P>
-In general, a pattern matches a certain portion of the subject, and in
-addition, further substrings from the subject may be picked out by parts of the
-pattern. Following the usage in Jeffrey Friedl's book, this is called
-"capturing" in what follows, and the phrase "capturing subpattern" is used for
-a fragment of a pattern that picks out a substring. PCRE supports several other
-kinds of parenthesized subpattern that do not cause substrings to be captured.
-</P>
-<P>
-Captured substrings are returned to the caller via a vector of integer offsets
-whose address is passed in <I>ovector</I>. The number of elements in the vector
-is passed in <I>ovecsize</I>. The first two-thirds of the vector is used to pass
-back captured substrings, each substring using a pair of integers. The
-remaining third of the vector is used as workspace by <B>pcre_exec()</B> while
-matching capturing subpatterns, and is not available for passing back
-information. The length passed in <I>ovecsize</I> should always be a multiple of
-three. If it is not, it is rounded down.
-</P>
-<P>
-When a match has been successful, information about captured substrings is
-returned in pairs of integers, starting at the beginning of <I>ovector</I>, and
-continuing up to two-thirds of its length at the most. The first element of a
-pair is set to the offset of the first character in a substring, and the second
-is set to the offset of the first character after the end of a substring. The
-first pair, <I>ovector[0]</I> and <I>ovector[1]</I>, identify the portion of the
-subject string matched by the entire pattern. The next pair is used for the
-first capturing subpattern, and so on. The value returned by <B>pcre_exec()</B>
-is the number of pairs that have been set. If there are no capturing
-subpatterns, the return value from a successful match is 1, indicating that
-just the first pair of offsets has been set.
-</P>
-<P>
-Some convenience functions are provided for extracting the captured substrings
-as separate strings. These are described in the following section.
-</P>
-<P>
-It is possible for an capturing subpattern number <I>n+1</I> to match some
-part of the subject when subpattern <I>n</I> has not been used at all. For
-example, if the string "abc" is matched against the pattern (a|(z))(bc)
-subpatterns 1 and 3 are matched, but 2 is not. When this happens, both offset
-values corresponding to the unused subpattern are set to -1.
-</P>
-<P>
-If a capturing subpattern is matched repeatedly, it is the last portion of the
-string that it matched that gets returned.
-</P>
-<P>
-If the vector is too small to hold all the captured substrings, it is used as
-far as possible (up to two-thirds of its length), and the function returns a
-value of zero. In particular, if the substring offsets are not of interest,
-<B>pcre_exec()</B> may be called with <I>ovector</I> passed as NULL and
-<I>ovecsize</I> as zero. However, if the pattern contains back references and
-the <I>ovector</I> isn't big enough to remember the related substrings, PCRE has
-to get additional memory for use during matching. Thus it is usually advisable
-to supply an <I>ovector</I>.
-</P>
-<P>
-Note that <B>pcre_info()</B> can be used to find out how many capturing
-subpatterns there are in a compiled pattern. The smallest size for
-<I>ovector</I> that will allow for <I>n</I> captured substrings in addition to
-the offsets of the substring matched by the whole pattern is (<I>n</I>+1)*3.
-</P>
-<P>
-If <B>pcre_exec()</B> fails, it returns a negative number. The following are
-defined in the header file:
-</P>
-<P>
-<PRE>
- PCRE_ERROR_NOMATCH (-1)
-</PRE>
-</P>
-<P>
-The subject string did not match the pattern.
-</P>
-<P>
-<PRE>
- PCRE_ERROR_NULL (-2)
-</PRE>
-</P>
-<P>
-Either <I>code</I> or <I>subject</I> was passed as NULL, or <I>ovector</I> was
-NULL and <I>ovecsize</I> was not zero.
-</P>
-<P>
-<PRE>
- PCRE_ERROR_BADOPTION (-3)
-</PRE>
-</P>
-<P>
-An unrecognized bit was set in the <I>options</I> argument.
-</P>
-<P>
-<PRE>
- PCRE_ERROR_BADMAGIC (-4)
-</PRE>
-</P>
-<P>
-PCRE stores a 4-byte "magic number" at the start of the compiled code, to catch
-the case when it is passed a junk pointer. This is the error it gives when the
-magic number isn't present.
-</P>
-<P>
-<PRE>
- PCRE_ERROR_UNKNOWN_NODE (-5)
-</PRE>
-</P>
-<P>
-While running the pattern match, an unknown item was encountered in the
-compiled pattern. This error could be caused by a bug in PCRE or by overwriting
-of the compiled pattern.
-</P>
-<P>
-<PRE>
- PCRE_ERROR_NOMEMORY (-6)
-</PRE>
-</P>
-<P>
-If a pattern contains back references, but the <I>ovector</I> that is passed to
-<B>pcre_exec()</B> is not big enough to remember the referenced substrings, PCRE
-gets a block of memory at the start of matching to use for this purpose. If the
-call via <B>pcre_malloc()</B> fails, this error is given. The memory is freed at
-the end of matching.
-</P>
-<LI><A NAME="SEC10" HREF="#TOC1">EXTRACTING CAPTURED SUBSTRINGS</A>
-<P>
-Captured substrings can be accessed directly by using the offsets returned by
-<B>pcre_exec()</B> in <I>ovector</I>. For convenience, the functions
-<B>pcre_copy_substring()</B>, <B>pcre_get_substring()</B>, and
-<B>pcre_get_substring_list()</B> are provided for extracting captured substrings
-as new, separate, zero-terminated strings. A substring that contains a binary
-zero is correctly extracted and has a further zero added on the end, but the
-result does not, of course, function as a C string.
-</P>
-<P>
-The first three arguments are the same for all three functions: <I>subject</I>
-is the subject string which has just been successfully matched, <I>ovector</I>
-is a pointer to the vector of integer offsets that was passed to
-<B>pcre_exec()</B>, and <I>stringcount</I> is the number of substrings that
-were captured by the match, including the substring that matched the entire
-regular expression. This is the value returned by <B>pcre_exec</B> if it
-is greater than zero. If <B>pcre_exec()</B> returned zero, indicating that it
-ran out of space in <I>ovector</I>, the value passed as <I>stringcount</I> should
-be the size of the vector divided by three.
-</P>
-<P>
-The functions <B>pcre_copy_substring()</B> and <B>pcre_get_substring()</B>
-extract a single substring, whose number is given as <I>stringnumber</I>. A
-value of zero extracts the substring that matched the entire pattern, while
-higher values extract the captured substrings. For <B>pcre_copy_substring()</B>,
-the string is placed in <I>buffer</I>, whose length is given by
-<I>buffersize</I>, while for <B>pcre_get_substring()</B> a new block of memory is
-obtained via <B>pcre_malloc</B>, and its address is returned via
-<I>stringptr</I>. The yield of the function is the length of the string, not
-including the terminating zero, or one of
-</P>
-<P>
-<PRE>
- PCRE_ERROR_NOMEMORY (-6)
-</PRE>
-</P>
-<P>
-The buffer was too small for <B>pcre_copy_substring()</B>, or the attempt to get
-memory failed for <B>pcre_get_substring()</B>.
-</P>
-<P>
-<PRE>
- PCRE_ERROR_NOSUBSTRING (-7)
-</PRE>
-</P>
-<P>
-There is no substring whose number is <I>stringnumber</I>.
-</P>
-<P>
-The <B>pcre_get_substring_list()</B> function extracts all available substrings
-and builds a list of pointers to them. All this is done in a single block of
-memory which is obtained via <B>pcre_malloc</B>. The address of the memory block
-is returned via <I>listptr</I>, which is also the start of the list of string
-pointers. The end of the list is marked by a NULL pointer. The yield of the
-function is zero if all went well, or
-</P>
-<P>
-<PRE>
- PCRE_ERROR_NOMEMORY (-6)
-</PRE>
-</P>
-<P>
-if the attempt to get the memory block failed.
-</P>
-<P>
-When any of these functions encounter a substring that is unset, which can
-happen when capturing subpattern number <I>n+1</I> matches some part of the
-subject, but subpattern <I>n</I> has not been used at all, they return an empty
-string. This can be distinguished from a genuine zero-length substring by
-inspecting the appropriate offset in <I>ovector</I>, which is negative for unset
-substrings.
-</P>
-<P>
-The two convenience functions <B>pcre_free_substring()</B> and
-<B>pcre_free_substring_list()</B> can be used to free the memory returned by
-a previous call of <B>pcre_get_substring()</B> or
-<B>pcre_get_substring_list()</B>, respectively. They do nothing more than call
-the function pointed to by <B>pcre_free</B>, which of course could be called
-directly from a C program. However, PCRE is used in some situations where it is
-linked via a special interface to another programming language which cannot use
-<B>pcre_free</B> directly; it is for these cases that the functions are
-provided.
-</P>
-<LI><A NAME="SEC11" HREF="#TOC1">LIMITATIONS</A>
-<P>
-There are some size limitations in PCRE but it is hoped that they will never in
-practice be relevant.
-The maximum length of a compiled pattern is 65539 (sic) bytes.
-All values in repeating quantifiers must be less than 65536.
-There maximum number of capturing subpatterns is 65535.
-There is no limit to the number of non-capturing subpatterns, but the maximum
-depth of nesting of all kinds of parenthesized subpattern, including capturing
-subpatterns, assertions, and other types of subpattern, is 200.
-</P>
-<P>
-The maximum length of a subject string is the largest positive number that an
-integer variable can hold. However, PCRE uses recursion to handle subpatterns
-and indefinite repetition. This means that the available stack space may limit
-the size of a subject string that can be processed by certain patterns.
-</P>
-<LI><A NAME="SEC12" HREF="#TOC1">DIFFERENCES FROM PERL</A>
-<P>
-The differences described here are with respect to Perl 5.005.
-</P>
-<P>
-1. By default, a whitespace character is any character that the C library
-function <B>isspace()</B> recognizes, though it is possible to compile PCRE with
-alternative character type tables. Normally <B>isspace()</B> matches space,
-formfeed, newline, carriage return, horizontal tab, and vertical tab. Perl 5
-no longer includes vertical tab in its set of whitespace characters. The \v
-escape that was in the Perl documentation for a long time was never in fact
-recognized. However, the character itself was treated as whitespace at least
-up to 5.002. In 5.004 and 5.005 it does not match \s.
-</P>
-<P>
-2. PCRE does not allow repeat quantifiers on lookahead assertions. Perl permits
-them, but they do not mean what you might think. For example, (?!a){3} does
-not assert that the next three characters are not "a". It just asserts that the
-next character is not "a" three times.
-</P>
-<P>
-3. Capturing subpatterns that occur inside negative lookahead assertions are
-counted, but their entries in the offsets vector are never set. Perl sets its
-numerical variables from any such patterns that are matched before the
-assertion fails to match something (thereby succeeding), but only if the
-negative lookahead assertion contains just one branch.
-</P>
-<P>
-4. Though binary zero characters are supported in the subject string, they are
-not allowed in a pattern string because it is passed as a normal C string,
-terminated by zero. The escape sequence "\0" can be used in the pattern to
-represent a binary zero.
-</P>
-<P>
-5. The following Perl escape sequences are not supported: \l, \u, \L, \U,
-\E, \Q. In fact these are implemented by Perl's general string-handling and
-are not part of its pattern matching engine.
-</P>
-<P>
-6. The Perl \G assertion is not supported as it is not relevant to single
-pattern matches.
-</P>
-<P>
-7. Fairly obviously, PCRE does not support the (?{code}) and (?p{code})
-constructions. However, there is some experimental support for recursive
-patterns using the non-Perl item (?R).
-</P>
-<P>
-8. There are at the time of writing some oddities in Perl 5.005_02 concerned
-with the settings of captured strings when part of a pattern is repeated. For
-example, matching "aba" against the pattern /^(a(b)?)+$/ sets $2 to the value
-"b", but matching "aabbaa" against /^(aa(bb)?)+$/ leaves $2 unset. However, if
-the pattern is changed to /^(aa(b(b))?)+$/ then $2 (and $3) are set.
-</P>
-<P>
-In Perl 5.004 $2 is set in both cases, and that is also true of PCRE. If in the
-future Perl changes to a consistent state that is different, PCRE may change to
-follow.
-</P>
-<P>
-9. Another as yet unresolved discrepancy is that in Perl 5.005_02 the pattern
-/^(a)?(?(1)a|b)+$/ matches the string "a", whereas in PCRE it does not.
-However, in both Perl and PCRE /^(a)?a/ matched against "a" leaves $1 unset.
-</P>
-<P>
-10. PCRE provides some extensions to the Perl regular expression facilities:
-</P>
-<P>
-(a) Although lookbehind assertions must match fixed length strings, each
-alternative branch of a lookbehind assertion can match a different length of
-string. Perl 5.005 requires them all to have the same length.
-</P>
-<P>
-(b) If PCRE_DOLLAR_ENDONLY is set and PCRE_MULTILINE is not set, the $ meta-
-character matches only at the very end of the string.
-</P>
-<P>
-(c) If PCRE_EXTRA is set, a backslash followed by a letter with no special
-meaning is faulted.
-</P>
-<P>
-(d) If PCRE_UNGREEDY is set, the greediness of the repetition quantifiers is
-inverted, that is, by default they are not greedy, but if followed by a
-question mark they are.
-</P>
-<P>
-(e) PCRE_ANCHORED can be used to force a pattern to be tried only at the start
-of the subject.
-</P>
-<P>
-(f) The PCRE_NOTBOL, PCRE_NOTEOL, and PCRE_NOTEMPTY options for
-<B>pcre_exec()</B> have no Perl equivalents.
-</P>
-<P>
-(g) The (?R) construct allows for recursive pattern matching (Perl 5.6 can do
-this using the (?p{code}) construct, which PCRE cannot of course support.)
-</P>
-<LI><A NAME="SEC13" HREF="#TOC1">REGULAR EXPRESSION DETAILS</A>
-<P>
-The syntax and semantics of the regular expressions supported by PCRE are
-described below. Regular expressions are also described in the Perl
-documentation and in a number of other books, some of which have copious
-examples. Jeffrey Friedl's "Mastering Regular Expressions", published by
-O'Reilly (ISBN 1-56592-257), covers them in great detail.
-</P>
-<P>
-The description here is intended as reference documentation. The basic
-operation of PCRE is on strings of bytes. However, there is the beginnings of
-some support for UTF-8 character strings. To use this support you must
-configure PCRE to include it, and then call <B>pcre_compile()</B> with the
-PCRE_UTF8 option. How this affects the pattern matching is described in the
-final section of this document.
-</P>
-<P>
-A regular expression is a pattern that is matched against a subject string from
-left to right. Most characters stand for themselves in a pattern, and match the
-corresponding characters in the subject. As a trivial example, the pattern
-</P>
-<P>
-<PRE>
- The quick brown fox
-</PRE>
-</P>
-<P>
-matches a portion of a subject string that is identical to itself. The power of
-regular expressions comes from the ability to include alternatives and
-repetitions in the pattern. These are encoded in the pattern by the use of
-<I>meta-characters</I>, which do not stand for themselves but instead are
-interpreted in some special way.
-</P>
-<P>
-There are two different sets of meta-characters: those that are recognized
-anywhere in the pattern except within square brackets, and those that are
-recognized in square brackets. Outside square brackets, the meta-characters are
-as follows:
-</P>
-<P>
-<PRE>
- \ general escape character with several uses
- ^ assert start of subject (or line, in multiline mode)
- $ assert end of subject (or line, in multiline mode)
- . match any character except newline (by default)
- [ start character class definition
- | start of alternative branch
- ( start subpattern
- ) end subpattern
- ? extends the meaning of (
- also 0 or 1 quantifier
- also quantifier minimizer
- * 0 or more quantifier
- + 1 or more quantifier
- { start min/max quantifier
-</PRE>
-</P>
-<P>
-Part of a pattern that is in square brackets is called a "character class". In
-a character class the only meta-characters are:
-</P>
-<P>
-<PRE>
- \ general escape character
- ^ negate the class, but only if the first character
- - indicates character range
- ] terminates the character class
-</PRE>
-</P>
-<P>
-The following sections describe the use of each of the meta-characters.
-</P>
-<LI><A NAME="SEC14" HREF="#TOC1">BACKSLASH</A>
-<P>
-The backslash character has several uses. Firstly, if it is followed by a
-non-alphameric character, it takes away any special meaning that character may
-have. This use of backslash as an escape character applies both inside and
-outside character classes.
-</P>
-<P>
-For example, if you want to match a "*" character, you write "\*" in the
-pattern. This applies whether or not the following character would otherwise be
-interpreted as a meta-character, so it is always safe to precede a
-non-alphameric with "\" to specify that it stands for itself. In particular,
-if you want to match a backslash, you write "\\".
-</P>
-<P>
-If a pattern is compiled with the PCRE_EXTENDED option, whitespace in the
-pattern (other than in a character class) and characters between a "#" outside
-a character class and the next newline character are ignored. An escaping
-backslash can be used to include a whitespace or "#" character as part of the
-pattern.
-</P>
-<P>
-A second use of backslash provides a way of encoding non-printing characters
-in patterns in a visible manner. There is no restriction on the appearance of
-non-printing characters, apart from the binary zero that terminates a pattern,
-but when a pattern is being prepared by text editing, it is usually easier to
-use one of the following escape sequences than the binary character it
-represents:
-</P>
-<P>
-<PRE>
- \a alarm, that is, the BEL character (hex 07)
- \cx "control-x", where x is any character
- \e escape (hex 1B)
- \f formfeed (hex 0C)
- \n newline (hex 0A)
- \r carriage return (hex 0D)
- \t tab (hex 09)
- \xhh character with hex code hh
- \ddd character with octal code ddd, or backreference
-</PRE>
-</P>
-<P>
-The precise effect of "\cx" is as follows: if "x" is a lower case letter, it
-is converted to upper case. Then bit 6 of the character (hex 40) is inverted.
-Thus "\cz" becomes hex 1A, but "\c{" becomes hex 3B, while "\c;" becomes hex
-7B.
-</P>
-<P>
-After "\x", up to two hexadecimal digits are read (letters can be in upper or
-lower case).
-</P>
-<P>
-After "\0" up to two further octal digits are read. In both cases, if there
-are fewer than two digits, just those that are present are used. Thus the
-sequence "\0\x\07" specifies two binary zeros followed by a BEL character.
-Make sure you supply two digits after the initial zero if the character that
-follows is itself an octal digit.
-</P>
-<P>
-The handling of a backslash followed by a digit other than 0 is complicated.
-Outside a character class, PCRE reads it and any following digits as a decimal
-number. If the number is less than 10, or if there have been at least that many
-previous capturing left parentheses in the expression, the entire sequence is
-taken as a <I>back reference</I>. A description of how this works is given
-later, following the discussion of parenthesized subpatterns.
-</P>
-<P>
-Inside a character class, or if the decimal number is greater than 9 and there
-have not been that many capturing subpatterns, PCRE re-reads up to three octal
-digits following the backslash, and generates a single byte from the least
-significant 8 bits of the value. Any subsequent digits stand for themselves.
-For example:
-</P>
-<P>
-<PRE>
- \040 is another way of writing a space
- \40 is the same, provided there are fewer than 40
- previous capturing subpatterns
- \7 is always a back reference
- \11 might be a back reference, or another way of
- writing a tab
- \011 is always a tab
- \0113 is a tab followed by the character "3"
- \113 is the character with octal code 113 (since there
- can be no more than 99 back references)
- \377 is a byte consisting entirely of 1 bits
- \81 is either a back reference, or a binary zero
- followed by the two characters "8" and "1"
-</PRE>
-</P>
-<P>
-Note that octal values of 100 or greater must not be introduced by a leading
-zero, because no more than three octal digits are ever read.
-</P>
-<P>
-All the sequences that define a single byte value can be used both inside and
-outside character classes. In addition, inside a character class, the sequence
-"\b" is interpreted as the backspace character (hex 08). Outside a character
-class it has a different meaning (see below).
-</P>
-<P>
-The third use of backslash is for specifying generic character types:
-</P>
-<P>
-<PRE>
- \d any decimal digit
- \D any character that is not a decimal digit
- \s any whitespace character
- \S any character that is not a whitespace character
- \w any "word" character
- \W any "non-word" character
-</PRE>
-</P>
-<P>
-Each pair of escape sequences partitions the complete set of characters into
-two disjoint sets. Any given character matches one, and only one, of each pair.
-</P>
-<P>
-A "word" character is any letter or digit or the underscore character, that is,
-any character which can be part of a Perl "word". The definition of letters and
-digits is controlled by PCRE's character tables, and may vary if locale-
-specific matching is taking place (see "Locale support" above). For example, in
-the "fr" (French) locale, some character codes greater than 128 are used for
-accented letters, and these are matched by \w.
-</P>
-<P>
-These character type sequences can appear both inside and outside character
-classes. They each match one character of the appropriate type. If the current
-matching point is at the end of the subject string, all of them fail, since
-there is no character to match.
-</P>
-<P>
-The fourth use of backslash is for certain simple assertions. An assertion
-specifies a condition that has to be met at a particular point in a match,
-without consuming any characters from the subject string. The use of
-subpatterns for more complicated assertions is described below. The backslashed
-assertions are
-</P>
-<P>
-<PRE>
- \b word boundary
- \B not a word boundary
- \A start of subject (independent of multiline mode)
- \Z end of subject or newline at end (independent of multiline mode)
- \z end of subject (independent of multiline mode)
-</PRE>
-</P>
-<P>
-These assertions may not appear in character classes (but note that "\b" has a
-different meaning, namely the backspace character, inside a character class).
-</P>
-<P>
-A word boundary is a position in the subject string where the current character
-and the previous character do not both match \w or \W (i.e. one matches
-\w and the other matches \W), or the start or end of the string if the
-first or last character matches \w, respectively.
-</P>
-<P>
-The \A, \Z, and \z assertions differ from the traditional circumflex and
-dollar (described below) in that they only ever match at the very start and end
-of the subject string, whatever options are set. They are not affected by the
-PCRE_NOTBOL or PCRE_NOTEOL options. If the <I>startoffset</I> argument of
-<B>pcre_exec()</B> is non-zero, \A can never match. The difference between \Z
-and \z is that \Z matches before a newline that is the last character of the
-string as well as at the end of the string, whereas \z matches only at the
-end.
-</P>
-<LI><A NAME="SEC15" HREF="#TOC1">CIRCUMFLEX AND DOLLAR</A>
-<P>
-Outside a character class, in the default matching mode, the circumflex
-character is an assertion which is true only if the current matching point is
-at the start of the subject string. If the <I>startoffset</I> argument of
-<B>pcre_exec()</B> is non-zero, circumflex can never match. Inside a character
-class, circumflex has an entirely different meaning (see below).
-</P>
-<P>
-Circumflex need not be the first character of the pattern if a number of
-alternatives are involved, but it should be the first thing in each alternative
-in which it appears if the pattern is ever to match that branch. If all
-possible alternatives start with a circumflex, that is, if the pattern is
-constrained to match only at the start of the subject, it is said to be an
-"anchored" pattern. (There are also other constructs that can cause a pattern
-to be anchored.)
-</P>
-<P>
-A dollar character is an assertion which is true only if the current matching
-point is at the end of the subject string, or immediately before a newline
-character that is the last character in the string (by default). Dollar need
-not be the last character of the pattern if a number of alternatives are
-involved, but it should be the last item in any branch in which it appears.
-Dollar has no special meaning in a character class.
-</P>
-<P>
-The meaning of dollar can be changed so that it matches only at the very end of
-the string, by setting the PCRE_DOLLAR_ENDONLY option at compile or matching
-time. This does not affect the \Z assertion.
-</P>
-<P>
-The meanings of the circumflex and dollar characters are changed if the
-PCRE_MULTILINE option is set. When this is the case, they match immediately
-after and immediately before an internal "\n" character, respectively, in
-addition to matching at the start and end of the subject string. For example,
-the pattern /^abc$/ matches the subject string "def\nabc" in multiline mode,
-but not otherwise. Consequently, patterns that are anchored in single line mode
-because all branches start with "^" are not anchored in multiline mode, and a
-match for circumflex is possible when the <I>startoffset</I> argument of
-<B>pcre_exec()</B> is non-zero. The PCRE_DOLLAR_ENDONLY option is ignored if
-PCRE_MULTILINE is set.
-</P>
-<P>
-Note that the sequences \A, \Z, and \z can be used to match the start and
-end of the subject in both modes, and if all branches of a pattern start with
-\A it is always anchored, whether PCRE_MULTILINE is set or not.
-</P>
-<LI><A NAME="SEC16" HREF="#TOC1">FULL STOP (PERIOD, DOT)</A>
-<P>
-Outside a character class, a dot in the pattern matches any one character in
-the subject, including a non-printing character, but not (by default) newline.
-If the PCRE_DOTALL option is set, dots match newlines as well. The handling of
-dot is entirely independent of the handling of circumflex and dollar, the only
-relationship being that they both involve newline characters. Dot has no
-special meaning in a character class.
-</P>
-<LI><A NAME="SEC17" HREF="#TOC1">SQUARE BRACKETS</A>
-<P>
-An opening square bracket introduces a character class, terminated by a closing
-square bracket. A closing square bracket on its own is not special. If a
-closing square bracket is required as a member of the class, it should be the
-first data character in the class (after an initial circumflex, if present) or
-escaped with a backslash.
-</P>
-<P>
-A character class matches a single character in the subject; the character must
-be in the set of characters defined by the class, unless the first character in
-the class is a circumflex, in which case the subject character must not be in
-the set defined by the class. If a circumflex is actually required as a member
-of the class, ensure it is not the first character, or escape it with a
-backslash.
-</P>
-<P>
-For example, the character class [aeiou] matches any lower case vowel, while
-[^aeiou] matches any character that is not a lower case vowel. Note that a
-circumflex is just a convenient notation for specifying the characters which
-are in the class by enumerating those that are not. It is not an assertion: it
-still consumes a character from the subject string, and fails if the current
-pointer is at the end of the string.
-</P>
-<P>
-When caseless matching is set, any letters in a class represent both their
-upper case and lower case versions, so for example, a caseless [aeiou] matches
-"A" as well as "a", and a caseless [^aeiou] does not match "A", whereas a
-caseful version would.
-</P>
-<P>
-The newline character is never treated in any special way in character classes,
-whatever the setting of the PCRE_DOTALL or PCRE_MULTILINE options is. A class
-such as [^a] will always match a newline.
-</P>
-<P>
-The minus (hyphen) character can be used to specify a range of characters in a
-character class. For example, [d-m] matches any letter between d and m,
-inclusive. If a minus character is required in a class, it must be escaped with
-a backslash or appear in a position where it cannot be interpreted as
-indicating a range, typically as the first or last character in the class.
-</P>
-<P>
-It is not possible to have the literal character "]" as the end character of a
-range. A pattern such as [W-]46] is interpreted as a class of two characters
-("W" and "-") followed by a literal string "46]", so it would match "W46]" or
-"-46]". However, if the "]" is escaped with a backslash it is interpreted as
-the end of range, so [W-\]46] is interpreted as a single class containing a
-range followed by two separate characters. The octal or hexadecimal
-representation of "]" can also be used to end a range.
-</P>
-<P>
-Ranges operate in ASCII collating sequence. They can also be used for
-characters specified numerically, for example [\000-\037]. 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 [][\^_`wxyzabc], matched
-caselessly, and if character tables for the "fr" locale are in use,
-[\xc8-\xcb] matches accented E characters in both cases.
-</P>
-<P>
-The character types \d, \D, \s, \S, \w, and \W may also appear in a
-character class, and add the characters that they match to the class. For
-example, [\dABCDEF] matches any hexadecimal digit. A circumflex can
-conveniently be used with the upper case character types to specify a more
-restricted set of characters than the matching lower case type. For example,
-the class [^\W_] matches any letter or digit, but not underscore.
-</P>
-<P>
-All non-alphameric characters other than \, -, ^ (at the start) and the
-terminating ] are non-special in character classes, but it does no harm if they
-are escaped.
-</P>
-<LI><A NAME="SEC18" HREF="#TOC1">POSIX CHARACTER CLASSES</A>
-<P>
-Perl 5.6 (not yet released at the time of writing) is going to support the
-POSIX notation for character classes, which uses names enclosed by [: and :]
-within the enclosing square brackets. PCRE supports this notation. For example,
-</P>
-<P>
-<PRE>
- [01[:alpha:]%]
-</PRE>
-</P>
-<P>
-matches "0", "1", any alphabetic character, or "%". The supported class names
-are
-</P>
-<P>
-<PRE>
- alnum letters and digits
- alpha letters
- ascii character codes 0 - 127
- cntrl control characters
- digit decimal digits (same as \d)
- graph printing characters, excluding space
- lower lower case letters
- print printing characters, including space
- punct printing characters, excluding letters and digits
- space white space (same as \s)
- upper upper case letters
- word "word" characters (same as \w)
- xdigit hexadecimal digits
-</PRE>
-</P>
-<P>
-The names "ascii" and "word" are Perl extensions. Another Perl extension is
-negation, which is indicated by a ^ character after the colon. For example,
-</P>
-<P>
-<PRE>
- [12[:^digit:]]
-</PRE>
-</P>
-<P>
-matches "1", "2", or any non-digit. PCRE (and Perl) also recognize the POSIX
-syntax [.ch.] and [=ch=] where "ch" is a "collating element", but these are not
-supported, and an error is given if they are encountered.
-</P>
-<LI><A NAME="SEC19" HREF="#TOC1">VERTICAL BAR</A>
-<P>
-Vertical bar characters are used to separate alternative patterns. For example,
-the pattern
-</P>
-<P>
-<PRE>
- gilbert|sullivan
-</PRE>
-</P>
-<P>
-matches either "gilbert" or "sullivan". Any number of alternatives may appear,
-and an empty alternative is permitted (matching the empty string).
-The matching process tries each alternative in turn, from left to right,
-and the first one that succeeds is used. If the alternatives are within a
-subpattern (defined below), "succeeds" means matching the rest of the main
-pattern as well as the alternative in the subpattern.
-</P>
-<LI><A NAME="SEC20" HREF="#TOC1">INTERNAL OPTION SETTING</A>
-<P>
-The settings of PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, and PCRE_EXTENDED
-can be changed from within the pattern by a sequence of Perl option letters
-enclosed between "(?" and ")". The option letters are
-</P>
-<P>
-<PRE>
- i for PCRE_CASELESS
- m for PCRE_MULTILINE
- s for PCRE_DOTALL
- x for PCRE_EXTENDED
-</PRE>
-</P>
-<P>
-For example, (?im) sets caseless, multiline matching. It is also possible to
-unset these options by preceding the letter with a hyphen, and a combined
-setting and unsetting such as (?im-sx), which sets PCRE_CASELESS and
-PCRE_MULTILINE while unsetting PCRE_DOTALL and PCRE_EXTENDED, is also
-permitted. If a letter appears both before and after the hyphen, the option is
-unset.
-</P>
-<P>
-The scope of these option changes depends on where in the pattern the setting
-occurs. For settings that are outside any subpattern (defined below), the
-effect is the same as if the options were set or unset at the start of
-matching. The following patterns all behave in exactly the same way:
-</P>
-<P>
-<PRE>
- (?i)abc
- a(?i)bc
- ab(?i)c
- abc(?i)
-</PRE>
-</P>
-<P>
-which in turn is the same as compiling the pattern abc with PCRE_CASELESS set.
-In other words, such "top level" settings apply to the whole pattern (unless
-there are other changes inside subpatterns). If there is more than one setting
-of the same option at top level, the rightmost setting is used.
-</P>
-<P>
-If an option change occurs inside a subpattern, the effect is different. This
-is a change of behaviour in Perl 5.005. An option change inside a subpattern
-affects only that part of the subpattern that follows it, so
-</P>
-<P>
-<PRE>
- (a(?i)b)c
-</PRE>
-</P>
-<P>
-matches abc and aBc and no other strings (assuming PCRE_CASELESS is not used).
-By this means, options can be made to have different settings in different
-parts of the pattern. Any changes made in one alternative do carry on
-into subsequent branches within the same subpattern. For example,
-</P>
-<P>
-<PRE>
- (a(?i)b|c)
-</PRE>
-</P>
-<P>
-matches "ab", "aB", "c", and "C", even though when matching "C" the first
-branch is abandoned before the option setting. This is because the effects of
-option settings happen at compile time. There would be some very weird
-behaviour otherwise.
-</P>
-<P>
-The PCRE-specific options PCRE_UNGREEDY and PCRE_EXTRA can be changed in the
-same way as the Perl-compatible options by using the characters U and X
-respectively. The (?X) flag setting is special in that it must always occur
-earlier in the pattern than any of the additional features it turns on, even
-when it is at top level. It is best put at the start.
-</P>
-<LI><A NAME="SEC21" HREF="#TOC1">SUBPATTERNS</A>
-<P>
-Subpatterns are delimited by parentheses (round brackets), which can be nested.
-Marking part of a pattern as a subpattern does two things:
-</P>
-<P>
-1. It localizes a set of alternatives. For example, the pattern
-</P>
-<P>
-<PRE>
- cat(aract|erpillar|)
-</PRE>
-</P>
-<P>
-matches one of the words "cat", "cataract", or "caterpillar". Without the
-parentheses, it would match "cataract", "erpillar" or the empty string.
-</P>
-<P>
-2. It sets up the subpattern as a capturing subpattern (as defined above).
-When the whole pattern matches, that portion of the subject string that matched
-the subpattern is passed back to the caller via the <I>ovector</I> argument of
-<B>pcre_exec()</B>. Opening parentheses are counted from left to right (starting
-from 1) to obtain the numbers of the capturing subpatterns.
-</P>
-<P>
-For example, if the string "the red king" is matched against the pattern
-</P>
-<P>
-<PRE>
- the ((red|white) (king|queen))
-</PRE>
-</P>
-<P>
-the captured substrings are "red king", "red", and "king", and are numbered 1,
-2, and 3, respectively.
-</P>
-<P>
-The fact that plain parentheses fulfil two functions is not always helpful.
-There are often times when a grouping subpattern is required without a
-capturing requirement. If an opening parenthesis is followed by "?:", the
-subpattern does not do any capturing, and is not counted when computing the
-number of any subsequent capturing subpatterns. For example, if the string "the
-white queen" is matched against the pattern
-</P>
-<P>
-<PRE>
- the ((?:red|white) (king|queen))
-</PRE>
-</P>
-<P>
-the captured substrings are "white queen" and "queen", and are numbered 1 and
-2. The maximum number of captured substrings is 99, and the maximum number of
-all subpatterns, both capturing and non-capturing, is 200.
-</P>
-<P>
-As a convenient shorthand, if any option settings are required at the start of
-a non-capturing subpattern, the option letters may appear between the "?" and
-the ":". Thus the two patterns
-</P>
-<P>
-<PRE>
- (?i:saturday|sunday)
- (?:(?i)saturday|sunday)
-</PRE>
-</P>
-<P>
-match exactly the same set of strings. Because alternative branches are tried
-from left to right, and options are not reset until the end of the subpattern
-is reached, an option setting in one branch does affect subsequent branches, so
-the above patterns match "SUNDAY" as well as "Saturday".
-</P>
-<LI><A NAME="SEC22" HREF="#TOC1">REPETITION</A>
-<P>
-Repetition is specified by quantifiers, which can follow any of the following
-items:
-</P>
-<P>
-<PRE>
- a single character, possibly escaped
- the . metacharacter
- a character class
- a back reference (see next section)
- a parenthesized subpattern (unless it is an assertion - see below)
-</PRE>
-</P>
-<P>
-The general repetition quantifier specifies a minimum and maximum number of
-permitted matches, by giving the two numbers in curly brackets (braces),
-separated by a comma. The numbers must be less than 65536, and the first must
-be less than or equal to the second. For example:
-</P>
-<P>
-<PRE>
- z{2,4}
-</PRE>
-</P>
-<P>
-matches "zz", "zzz", or "zzzz". A closing brace on its own is not a special
-character. If the second number is omitted, but the comma is present, there is
-no upper limit; if the second number and the comma are both omitted, the
-quantifier specifies an exact number of required matches. Thus
-</P>
-<P>
-<PRE>
- [aeiou]{3,}
-</PRE>
-</P>
-<P>
-matches at least 3 successive vowels, but may match many more, while
-</P>
-<P>
-<PRE>
- \d{8}
-</PRE>
-</P>
-<P>
-matches exactly 8 digits. An opening curly bracket that appears in a position
-where a quantifier is not allowed, or one that does not match the syntax of a
-quantifier, is taken as a literal character. For example, {,6} is not a
-quantifier, but a literal string of four characters.
-</P>
-<P>
-The quantifier {0} is permitted, causing the expression to behave as if the
-previous item and the quantifier were not present.
-</P>
-<P>
-For convenience (and historical compatibility) the three most common
-quantifiers have single-character abbreviations:
-</P>
-<P>
-<PRE>
- * is equivalent to {0,}
- + is equivalent to {1,}
- ? is equivalent to {0,1}
-</PRE>
-</P>
-<P>
-It is possible to construct infinite loops by following a subpattern that can
-match no characters with a quantifier that has no upper limit, for example:
-</P>
-<P>
-<PRE>
- (a?)*
-</PRE>
-</P>
-<P>
-Earlier versions of Perl and PCRE used to give an error at compile time for
-such patterns. However, because there are cases where this can be useful, such
-patterns are now accepted, but if any repetition of the subpattern does in fact
-match no characters, the loop is forcibly broken.
-</P>
-<P>
-By default, the quantifiers are "greedy", that is, they match as much as
-possible (up to the maximum number of permitted times), without causing the
-rest of the pattern to fail. The classic example of where this gives problems
-is in trying to match comments in C programs. These appear between the
-sequences /* and */ and within the sequence, individual * and / characters may
-appear. An attempt to match C comments by applying the pattern
-</P>
-<P>
-<PRE>
- /\*.*\*/
-</PRE>
-</P>
-<P>
-to the string
-</P>
-<P>
-<PRE>
- /* first command */ not comment /* second comment */
-</PRE>
-</P>
-<P>
-fails, because it matches the entire string owing to the greediness of the .*
-item.
-</P>
-<P>
-However, if a quantifier is followed by a question mark, it ceases to be
-greedy, and instead matches the minimum number of times possible, so the
-pattern
-</P>
-<P>
-<PRE>
- /\*.*?\*/
-</PRE>
-</P>
-<P>
-does the right thing with the C comments. The meaning of the various
-quantifiers is not otherwise changed, just the preferred number of matches.
-Do not confuse this use of question mark with its use as a quantifier in its
-own right. Because it has two uses, it can sometimes appear doubled, as in
-</P>
-<P>
-<PRE>
- \d??\d
-</PRE>
-</P>
-<P>
-which matches one digit by preference, but can match two if that is the only
-way the rest of the pattern matches.
-</P>
-<P>
-If the PCRE_UNGREEDY option is set (an option which is not available in Perl),
-the quantifiers are not greedy by default, but individual ones can be made
-greedy by following them with a question mark. In other words, it inverts the
-default behaviour.
-</P>
-<P>
-When a parenthesized subpattern is quantified with a minimum repeat count that
-is greater than 1 or with a limited maximum, more store is required for the
-compiled pattern, in proportion to the size of the minimum or maximum.
-</P>
-<P>
-If a pattern starts with .* or .{0,} and the PCRE_DOTALL option (equivalent
-to Perl's /s) is set, thus allowing the . to match newlines, the pattern is
-implicitly anchored, because whatever follows will be tried against every
-character position in the subject string, so there is no point in retrying the
-overall match at any position after the first. PCRE treats such a pattern as
-though it were preceded by \A. In cases where it is known that the subject
-string contains no newlines, it is worth setting PCRE_DOTALL when the pattern
-begins with .* in order to obtain this optimization, or alternatively using ^
-to indicate anchoring explicitly.
-</P>
-<P>
-When a capturing subpattern is repeated, the value captured is the substring
-that matched the final iteration. For example, after
-</P>
-<P>
-<PRE>
- (tweedle[dume]{3}\s*)+
-</PRE>
-</P>
-<P>
-has matched "tweedledum tweedledee" the value of the captured substring is
-"tweedledee". However, if there are nested capturing subpatterns, the
-corresponding captured values may have been set in previous iterations. For
-example, after
-</P>
-<P>
-<PRE>
- /(a|(b))+/
-</PRE>
-</P>
-<P>
-matches "aba" the value of the second captured substring is "b".
-</P>
-<LI><A NAME="SEC23" HREF="#TOC1">BACK REFERENCES</A>
-<P>
-Outside a character class, a backslash followed by a digit greater than 0 (and
-possibly further digits) is a back reference to a capturing subpattern earlier
-(i.e. to its left) in the pattern, provided there have been that many previous
-capturing left parentheses.
-</P>
-<P>
-However, if the decimal number following the backslash is less than 10, it is
-always taken as a back reference, and causes an error only if there are not
-that many capturing left parentheses in the entire pattern. In other words, the
-parentheses that are referenced need not be to the left of the reference for
-numbers less than 10. See the section entitled "Backslash" above for further
-details of the handling of digits following a backslash.
-</P>
-<P>
-A back reference matches whatever actually matched the capturing subpattern in
-the current subject string, rather than anything matching the subpattern
-itself. So the pattern
-</P>
-<P>
-<PRE>
- (sens|respons)e and \1ibility
-</PRE>
-</P>
-<P>
-matches "sense and sensibility" and "response and responsibility", but not
-"sense and responsibility". If caseful matching is in force at the time of the
-back reference, the case of letters is relevant. For example,
-</P>
-<P>
-<PRE>
- ((?i)rah)\s+\1
-</PRE>
-</P>
-<P>
-matches "rah rah" and "RAH RAH", but not "RAH rah", even though the original
-capturing subpattern is matched caselessly.
-</P>
-<P>
-There may be more than one back reference to the same subpattern. If a
-subpattern has not actually been used in a particular match, any back
-references to it always fail. For example, the pattern
-</P>
-<P>
-<PRE>
- (a|(bc))\2
-</PRE>
-</P>
-<P>
-always fails if it starts to match "a" rather than "bc". Because there may be
-up to 99 back references, all digits following the backslash are taken
-as part of a potential back reference number. If the pattern continues with a
-digit character, some delimiter must be used to terminate the back reference.
-If the PCRE_EXTENDED option is set, this can be whitespace. Otherwise an empty
-comment can be used.
-</P>
-<P>
-A back reference that occurs inside the parentheses to which it refers fails
-when the subpattern is first used, so, for example, (a\1) never matches.
-However, such references can be useful inside repeated subpatterns. For
-example, the pattern
-</P>
-<P>
-<PRE>
- (a|b\1)+
-</PRE>
-</P>
-<P>
-matches any number of "a"s and also "aba", "ababbaa" etc. At each iteration of
-the subpattern, the back reference matches the character string corresponding
-to the previous iteration. In order for this to work, the pattern must be such
-that the first iteration does not need to match the back reference. This can be
-done using alternation, as in the example above, or by a quantifier with a
-minimum of zero.
-</P>
-<LI><A NAME="SEC24" HREF="#TOC1">ASSERTIONS</A>
-<P>
-An assertion is a test on the characters following or preceding the current
-matching point that does not actually consume any characters. The simple
-assertions coded as \b, \B, \A, \Z, \z, ^ and $ are described above. More
-complicated assertions are coded as subpatterns. There are two kinds: those
-that look ahead of the current position in the subject string, and those that
-look behind it.
-</P>
-<P>
-An assertion subpattern is matched in the normal way, except that it does not
-cause the current matching position to be changed. Lookahead assertions start
-with (?= for positive assertions and (?! for negative assertions. For example,
-</P>
-<P>
-<PRE>
- \w+(?=;)
-</PRE>
-</P>
-<P>
-matches a word followed by a semicolon, but does not include the semicolon in
-the match, and
-</P>
-<P>
-<PRE>
- foo(?!bar)
-</PRE>
-</P>
-<P>
-matches any occurrence of "foo" that is not followed by "bar". Note that the
-apparently similar pattern
-</P>
-<P>
-<PRE>
- (?!foo)bar
-</PRE>
-</P>
-<P>
-does not find an occurrence of "bar" that is preceded by something other than
-"foo"; it finds any occurrence of "bar" whatsoever, because the assertion
-(?!foo) is always true when the next three characters are "bar". A
-lookbehind assertion is needed to achieve this effect.
-</P>
-<P>
-Lookbehind assertions start with (?<= for positive assertions and (?<! for
-negative assertions. For example,
-</P>
-<P>
-<PRE>
- (?<!foo)bar
-</PRE>
-</P>
-<P>
-does find an occurrence of "bar" that is not preceded by "foo". The contents of
-a lookbehind assertion are restricted such that all the strings it matches must
-have a fixed length. However, if there are several alternatives, they do not
-all have to have the same fixed length. Thus
-</P>
-<P>
-<PRE>
- (?<=bullock|donkey)
-</PRE>
-</P>
-<P>
-is permitted, but
-</P>
-<P>
-<PRE>
- (?<!dogs?|cats?)
-</PRE>
-</P>
-<P>
-causes an error at compile time. Branches that match different length strings
-are permitted only at the top level of a lookbehind assertion. This is an
-extension compared with Perl 5.005, which requires all branches to match the
-same length of string. An assertion such as
-</P>
-<P>
-<PRE>
- (?<=ab(c|de))
-</PRE>
-</P>
-<P>
-is not permitted, because its single top-level branch can match two different
-lengths, but it is acceptable if rewritten to use two top-level branches:
-</P>
-<P>
-<PRE>
- (?<=abc|abde)
-</PRE>
-</P>
-<P>
-The implementation of lookbehind assertions is, for each alternative, to
-temporarily move the current position back by the fixed width and then try to
-match. If there are insufficient characters before the current position, the
-match is deemed to fail. Lookbehinds in conjunction with once-only subpatterns
-can be particularly useful for matching at the ends of strings; an example is
-given at the end of the section on once-only subpatterns.
-</P>
-<P>
-Several assertions (of any sort) may occur in succession. For example,
-</P>
-<P>
-<PRE>
- (?<=\d{3})(?<!999)foo
-</PRE>
-</P>
-<P>
-matches "foo" preceded by three digits that are not "999". Notice that each of
-the assertions is applied independently at the same point in the subject
-string. First there is a check that the previous three characters are all
-digits, and then there is a check that the same three characters are not "999".
-This pattern does <I>not</I> match "foo" preceded by six characters, the first
-of which are digits and the last three of which are not "999". For example, it
-doesn't match "123abcfoo". A pattern to do that is
-</P>
-<P>
-<PRE>
- (?<=\d{3}...)(?<!999)foo
-</PRE>
-</P>
-<P>
-This time the first assertion looks at the preceding six characters, checking
-that the first three are digits, and then the second assertion checks that the
-preceding three characters are not "999".
-</P>
-<P>
-Assertions can be nested in any combination. For example,
-</P>
-<P>
-<PRE>
- (?<=(?<!foo)bar)baz
-</PRE>
-</P>
-<P>
-matches an occurrence of "baz" that is preceded by "bar" which in turn is not
-preceded by "foo", while
-</P>
-<P>
-<PRE>
- (?<=\d{3}(?!999)...)foo
-</PRE>
-</P>
-<P>
-is another pattern which matches "foo" preceded by three digits and any three
-characters that are not "999".
-</P>
-<P>
-Assertion subpatterns are not capturing subpatterns, and may not be repeated,
-because it makes no sense to assert the same thing several times. If any kind
-of assertion contains capturing subpatterns within it, these are counted for
-the purposes of numbering the capturing subpatterns in the whole pattern.
-However, substring capturing is carried out only for positive assertions,
-because it does not make sense for negative assertions.
-</P>
-<P>
-Assertions count towards the maximum of 200 parenthesized subpatterns.
-</P>
-<LI><A NAME="SEC25" HREF="#TOC1">ONCE-ONLY SUBPATTERNS</A>
-<P>
-With both maximizing and minimizing repetition, failure of what follows
-normally causes the repeated item to be re-evaluated to see if a different
-number of repeats allows the rest of the pattern to match. Sometimes it is
-useful to prevent this, either to change the nature of the match, or to cause
-it fail earlier than it otherwise might, when the author of the pattern knows
-there is no point in carrying on.
-</P>
-<P>
-Consider, for example, the pattern \d+foo when applied to the subject line
-</P>
-<P>
-<PRE>
- 123456bar
-</PRE>
-</P>
-<P>
-After matching all 6 digits and then failing to match "foo", the normal
-action of the matcher is to try again with only 5 digits matching the \d+
-item, and then with 4, and so on, before ultimately failing. Once-only
-subpatterns provide the means for specifying that once a portion of the pattern
-has matched, it is not to be re-evaluated in this way, so the matcher would
-give up immediately on failing to match "foo" the first time. The notation is
-another kind of special parenthesis, starting with (?> as in this example:
-</P>
-<P>
-<PRE>
- (?>\d+)bar
-</PRE>
-</P>
-<P>
-This kind of parenthesis "locks up" the part of the pattern it contains once
-it has matched, and a failure further into the pattern is prevented from
-backtracking into it. Backtracking past it to previous items, however, works as
-normal.
-</P>
-<P>
-An alternative description is that a subpattern of this type matches the string
-of characters that an identical standalone pattern would match, if anchored at
-the current point in the subject string.
-</P>
-<P>
-Once-only subpatterns are not capturing subpatterns. Simple cases such as the
-above example can be thought of as a maximizing repeat that must swallow
-everything it can. So, while both \d+ and \d+? are prepared to adjust the
-number of digits they match in order to make the rest of the pattern match,
-(?>\d+) can only match an entire sequence of digits.
-</P>
-<P>
-This construction can of course contain arbitrarily complicated subpatterns,
-and it can be nested.
-</P>
-<P>
-Once-only subpatterns can be used in conjunction with lookbehind assertions to
-specify efficient matching at the end of the subject string. Consider a simple
-pattern such as
-</P>
-<P>
-<PRE>
- abcd$
-</PRE>
-</P>
-<P>
-when applied to a long string which does not match. Because matching proceeds
-from left to right, PCRE will look for each "a" in the subject and then see if
-what follows matches the rest of the pattern. If the pattern is specified as
-</P>
-<P>
-<PRE>
- ^.*abcd$
-</PRE>
-</P>
-<P>
-the initial .* matches the entire string at first, but when this fails (because
-there is no following "a"), it backtracks to match all but the last character,
-then all but the last two characters, and so on. Once again the search for "a"
-covers the entire string, from right to left, so we are no better off. However,
-if the pattern is written as
-</P>
-<P>
-<PRE>
- ^(?>.*)(?<=abcd)
-</PRE>
-</P>
-<P>
-there can be no backtracking for the .* item; it can match only the entire
-string. The subsequent lookbehind assertion does a single test on the last four
-characters. If it fails, the match fails immediately. For long strings, this
-approach makes a significant difference to the processing time.
-</P>
-<P>
-When a pattern contains an unlimited repeat inside a subpattern that can itself
-be repeated an unlimited number of times, the use of a once-only subpattern is
-the only way to avoid some failing matches taking a very long time indeed.
-The pattern
-</P>
-<P>
-<PRE>
- (\D+|<\d+>)*[!?]
-</PRE>
-</P>
-<P>
-matches an unlimited number of substrings that either consist of non-digits, or
-digits enclosed in <>, followed by either ! or ?. When it matches, it runs
-quickly. However, if it is applied to
-</P>
-<P>
-<PRE>
- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-</PRE>
-</P>
-<P>
-it takes a long time before reporting failure. This is because the string can
-be divided between the two repeats in a large number of ways, and all have to
-be tried. (The example used [!?] rather than a single character at the end,
-because both PCRE and Perl have an optimization that allows for fast failure
-when a single character is used. They remember the last single character that
-is required for a match, and fail early if it is not present in the string.)
-If the pattern is changed to
-</P>
-<P>
-<PRE>
- ((?>\D+)|<\d+>)*[!?]
-</PRE>
-</P>
-<P>
-sequences of non-digits cannot be broken, and failure happens quickly.
-</P>
-<LI><A NAME="SEC26" HREF="#TOC1">CONDITIONAL SUBPATTERNS</A>
-<P>
-It is possible to cause the matching process to obey a subpattern
-conditionally or to choose between two alternative subpatterns, depending on
-the result of an assertion, or whether a previous capturing subpattern matched
-or not. The two possible forms of conditional subpattern are
-</P>
-<P>
-<PRE>
- (?(condition)yes-pattern)
- (?(condition)yes-pattern|no-pattern)
-</PRE>
-</P>
-<P>
-If the condition is satisfied, the yes-pattern is used; otherwise the
-no-pattern (if present) is used. If there are more than two alternatives in the
-subpattern, a compile-time error occurs.
-</P>
-<P>
-There are two kinds of condition. If the text between the parentheses consists
-of a sequence of digits, the condition is satisfied if the capturing subpattern
-of that number has previously matched. The number must be greater than zero.
-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
-three parts for ease of discussion:
-</P>
-<P>
-<PRE>
- ( \( )? [^()]+ (?(1) \) )
-</PRE>
-</P>
-<P>
-The first part matches an optional opening parenthesis, and if that
-character is present, sets it as the first captured substring. The second part
-matches one or more characters that are not parentheses. The third part is a
-conditional subpattern that tests whether the first set of parentheses matched
-or not. If they did, that is, if subject started with an opening parenthesis,
-the condition is true, and so the yes-pattern is executed and a closing
-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>
-<P>
-If the condition is not a sequence of digits, it must be an assertion. This may
-be a positive or negative lookahead or lookbehind assertion. Consider this
-pattern, again containing non-significant white space, and with the two
-alternatives on the second line:
-</P>
-<P>
-<PRE>
- (?(?=[^a-z]*[a-z])
- \d{2}-[a-z]{3}-\d{2} | \d{2}-\d{2}-\d{2} )
-</PRE>
-</P>
-<P>
-The condition is a positive lookahead assertion that matches an optional
-sequence of non-letters followed by a letter. In other words, it tests for the
-presence of at least one letter in the subject. If a letter is found, the
-subject is matched against the first alternative; otherwise it is matched
-against the second. This pattern matches strings in one of the two forms
-dd-aaa-dd or dd-dd-dd, where aaa are letters and dd are digits.
-</P>
-<LI><A NAME="SEC27" HREF="#TOC1">COMMENTS</A>
-<P>
-The sequence (?# marks the start of a comment which continues up to the next
-closing parenthesis. Nested parentheses are not permitted. The characters
-that make up a comment play no part in the pattern matching at all.
-</P>
-<P>
-If the PCRE_EXTENDED option is set, an unescaped # character outside a
-character class introduces a comment that continues up to the next newline
-character in the pattern.
-</P>
-<LI><A NAME="SEC28" HREF="#TOC1">RECURSIVE PATTERNS</A>
-<P>
-Consider the problem of matching a string in parentheses, allowing for
-unlimited nested parentheses. Without the use of recursion, the best that can
-be done is to use a pattern that matches up to some fixed depth of nesting. It
-is not possible to handle an arbitrary nesting depth. Perl 5.6 has provided an
-experimental facility that allows regular expressions to recurse (amongst other
-things). It does this by interpolating Perl code in the expression at run time,
-and the code can refer to the expression itself. A Perl pattern to solve the
-parentheses problem can be created like this:
-</P>
-<P>
-<PRE>
- $re = qr{\( (?: (?>[^()]+) | (?p{$re}) )* \)}x;
-</PRE>
-</P>
-<P>
-The (?p{...}) item interpolates Perl code at run time, and in this case refers
-recursively to the pattern in which it appears. Obviously, PCRE cannot support
-the interpolation of Perl code. Instead, the special item (?R) is provided for
-the specific case of recursion. This PCRE pattern solves the parentheses
-problem (assume the PCRE_EXTENDED option is set so that white space is
-ignored):
-</P>
-<P>
-<PRE>
- \( ( (?>[^()]+) | (?R) )* \)
-</PRE>
-</P>
-<P>
-First it matches an opening parenthesis. Then it matches any number of
-substrings which can either be a sequence of non-parentheses, or a recursive
-match of the pattern itself (i.e. a correctly parenthesized substring). Finally
-there is a closing parenthesis.
-</P>
-<P>
-This particular example pattern contains nested unlimited repeats, and so the
-use of a once-only subpattern for matching strings of non-parentheses is
-important when applying the pattern to strings that do not match. For example,
-when it is applied to
-</P>
-<P>
-<PRE>
- (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()
-</PRE>
-</P>
-<P>
-it yields "no match" quickly. However, if a once-only subpattern is not used,
-the match runs for a very long time indeed because there are so many different
-ways the + and * repeats can carve up the subject, and all have to be tested
-before failure can be reported.
-</P>
-<P>
-The values set for any capturing subpatterns are those from the outermost level
-of the recursion at which the subpattern value is set. If the pattern above is
-matched against
-</P>
-<P>
-<PRE>
- (ab(cd)ef)
-</PRE>
-</P>
-<P>
-the value for the capturing parentheses is "ef", which is the last value taken
-on at the top level. If additional parentheses are added, giving
-</P>
-<P>
-<PRE>
- \( ( ( (?>[^()]+) | (?R) )* ) \)
- ^ ^
- ^ ^
-</PRE>
-the string they capture is "ab(cd)ef", the contents of the top level
-parentheses. If there are more than 15 capturing parentheses in a pattern, PCRE
-has to obtain extra memory to store data during a recursion, which it does by
-using <B>pcre_malloc</B>, freeing it via <B>pcre_free</B> afterwards. If no
-memory can be obtained, it saves data for the first 15 capturing parentheses
-only, as there is no way to give an out-of-memory error from within a
-recursion.
-</P>
-<LI><A NAME="SEC29" HREF="#TOC1">PERFORMANCE</A>
-<P>
-Certain items that may appear in patterns are more efficient than others. It is
-more efficient to use a character class like [aeiou] than a set of alternatives
-such as (a|e|i|o|u). In general, the simplest construction that provides the
-required behaviour is usually the most efficient. Jeffrey Friedl's book
-contains a lot of discussion about optimizing regular expressions for efficient
-performance.
-</P>
-<P>
-When a pattern begins with .* and the PCRE_DOTALL option is set, the pattern is
-implicitly anchored by PCRE, since it can match only at the start of a subject
-string. However, if PCRE_DOTALL is not set, PCRE cannot make this optimization,
-because the . metacharacter does not then match a newline, and if the subject
-string contains newlines, the pattern may match from the character immediately
-following one of them instead of from the very start. For example, the pattern
-</P>
-<P>
-<PRE>
- (.*) second
-</PRE>
-</P>
-<P>
-matches the subject "first\nand second" (where \n stands for a newline
-character) with the first captured substring being "and". In order to do this,
-PCRE has to retry the match starting after every newline in the subject.
-</P>
-<P>
-If you are using such a pattern with subject strings that do not contain
-newlines, the best performance is obtained by setting PCRE_DOTALL, or starting
-the pattern with ^.* to indicate explicit anchoring. That saves PCRE from
-having to scan along the subject looking for a newline to restart at.
-</P>
-<P>
-Beware of patterns that contain nested indefinite repeats. These can take a
-long time to run when applied to a string that does not match. Consider the
-pattern fragment
-</P>
-<P>
-<PRE>
- (a+)*
-</PRE>
-</P>
-<P>
-This can match "aaaa" in 33 different ways, and this number increases very
-rapidly as the string gets longer. (The * repeat can match 0, 1, 2, 3, or 4
-times, and for each of those cases other than 0, the + repeats can match
-different numbers of times.) When the remainder of the pattern is such that the
-entire match is going to fail, PCRE has in principle to try every possible
-variation, and this can take an extremely long time.
-</P>
-<P>
-An optimization catches some of the more simple cases such as
-</P>
-<P>
-<PRE>
- (a+)*b
-</PRE>
-</P>
-<P>
-where a literal character follows. Before embarking on the standard matching
-procedure, PCRE checks that there is a "b" later in the subject string, and if
-there is not, it fails the match immediately. However, when there is no
-following literal this optimization cannot be used. You can see the difference
-by comparing the behaviour of
-</P>
-<P>
-<PRE>
- (a+)*\d
-</PRE>
-</P>
-<P>
-with the pattern above. The former gives a failure almost instantly when
-applied to a whole line of "a" characters, whereas the latter takes an
-appreciable time with strings longer than about 20 characters.
-</P>
-<LI><A NAME="SEC30" HREF="#TOC1">UTF-8 SUPPORT</A>
-<P>
-Starting at release 3.3, PCRE has some support for character strings encoded
-in the UTF-8 format. This is incomplete, and is regarded as experimental. In
-order to use it, you must configure PCRE to include UTF-8 support in the code,
-and, in addition, you must call <B>pcre_compile()</B> with the PCRE_UTF8 option
-flag. When you do this, both the pattern and any subject strings that are
-matched against it are treated as UTF-8 strings instead of just strings of
-bytes, but only in the cases that are mentioned below.
-</P>
-<P>
-If you compile PCRE with UTF-8 support, but do not use it at run time, the
-library will be a bit bigger, but the additional run time overhead is limited
-to testing the PCRE_UTF8 flag in several places, so should not be very large.
-</P>
-<P>
-PCRE assumes that the strings it is given contain valid UTF-8 codes. It does
-not diagnose invalid UTF-8 strings. If you pass invalid UTF-8 strings to PCRE,
-the results are undefined.
-</P>
-<P>
-Running with PCRE_UTF8 set causes these changes in the way PCRE works:
-</P>
-<P>
-1. In a pattern, the escape sequence \x{...}, where the contents of the braces
-is a string of hexadecimal digits, is interpreted as a UTF-8 character whose
-code number is the given hexadecimal number, for example: \x{1234}. This
-inserts from one to six literal bytes into the pattern, using the UTF-8
-encoding. If a non-hexadecimal digit appears between the braces, the item is
-not recognized.
-</P>
-<P>
-2. The original hexadecimal escape sequence, \xhh, generates a two-byte UTF-8
-character if its value is greater than 127.
-</P>
-<P>
-3. Repeat quantifiers are NOT correctly handled if they follow a multibyte
-character. For example, \x{100}* and \xc3+ do not work. If you want to
-repeat such characters, you must enclose them in non-capturing parentheses,
-for example (?:\x{100}), at present.
-</P>
-<P>
-4. The dot metacharacter matches one UTF-8 character instead of a single byte.
-</P>
-<P>
-5. Unlike literal UTF-8 characters, the dot metacharacter followed by a
-repeat quantifier does operate correctly on UTF-8 characters instead of
-single bytes.
-</P>
-<P>
-4. Although the \x{...} escape is permitted in a character class, characters
-whose values are greater than 255 cannot be included in a class.
-</P>
-<P>
-5. A class is matched against a UTF-8 character instead of just a single byte,
-but it can match only characters whose values are less than 256. Characters
-with greater values always fail to match a class.
-</P>
-<P>
-6. Repeated classes work correctly on multiple characters.
-</P>
-<P>
-7. Classes containing just a single character whose value is greater than 127
-(but less than 256), for example, [\x80] or [^\x{93}], do not work because
-these are optimized into single byte matches. In the first case, of course,
-the class brackets are just redundant.
-</P>
-<P>
-8. Lookbehind assertions move backwards in the subject by a fixed number of
-characters instead of a fixed number of bytes. Simple cases have been tested
-to work correctly, but there may be hidden gotchas herein.
-</P>
-<P>
-9. The character types such as \d and \w do not work correctly with UTF-8
-characters. They continue to test a single byte.
-</P>
-<P>
-10. Anything not explicitly mentioned here continues to work in bytes rather
-than in characters.
-</P>
-<P>
-The following UTF-8 features of Perl 5.6 are not implemented:
-</P>
-<P>
-1. The escape sequence \C to match a single byte.
-</P>
-<P>
-2. The use of Unicode tables and properties and escapes \p, \P, and \X.
-</P>
-<LI><A NAME="SEC31" HREF="#TOC1">SAMPLE PROGRAM</A>
-<P>
-The code below is a simple, complete demonstration program, to get you started
-with using PCRE. This code is also supplied in the file <I>pcredemo.c</I> in the
-PCRE distribution.
-</P>
-<P>
-The program compiles the regular expression that is its first argument, and
-matches it against the subject string in its second argument. No options are
-set, and default character tables are used. If matching succeeds, the program
-outputs the portion of the subject that matched, together with the contents of
-any captured substrings.
-</P>
-<P>
-On a Unix system that has PCRE installed in <I>/usr/local</I>, you can compile
-the demonstration program using a command like this:
-</P>
-<P>
-<PRE>
- gcc -o pcredemo pcredemo.c -I/usr/local/include -L/usr/local/lib -lpcre
-</PRE>
-</P>
-<P>
-Then you can run simple tests like this:
-</P>
-<P>
-<PRE>
- ./pcredemo 'cat|dog' 'the cat sat on the mat'
-</PRE>
-</P>
-<P>
-Note that there is a much more comprehensive test program, called
-<B>pcretest</B>, which supports many more facilities for testing regular
-expressions. The <B>pcredemo</B> program is provided as a simple coding example.
-</P>
-<P>
-On some operating systems (e.g. Solaris) you may get an error like this when
-you try to run <B>pcredemo</B>:
-</P>
-<P>
-<PRE>
- ld.so.1: a.out: fatal: libpcre.so.0: open failed: No such file or directory
-</PRE>
-</P>
-<P>
-This is caused by the way shared library support works on those systems. You
-need to add
-</P>
-<P>
-<PRE>
- -R/usr/local/lib
-</PRE>
-</P>
-<P>
-to the compile command to get round this problem. Here's the code:
-</P>
-<P>
-<PRE>
- #include <stdio.h>
- #include <string.h>
- #include <pcre.h>
-</PRE>
-</P>
-<P>
-<PRE>
- #define OVECCOUNT 30 /* should be a multiple of 3 */
-</PRE>
-</P>
-<P>
-<PRE>
- int main(int argc, char **argv)
- {
- pcre *re;
- const char *error;
- int erroffset;
- int ovector[OVECCOUNT];
- int rc, i;
-</PRE>
-</P>
-<P>
-<PRE>
- if (argc != 3)
- {
- printf("Two arguments required: a regex and a "
- "subject string\n");
- return 1;
- }
-</PRE>
-</P>
-<P>
-<PRE>
- /* Compile the regular expression in the first argument */
-</PRE>
-</P>
-<P>
-<PRE>
- re = pcre_compile(
- argv[1], /* the pattern */
- 0, /* default options */
- &error, /* for error message */
- &erroffset, /* for error offset */
- NULL); /* use default character tables */
-</PRE>
-</P>
-<P>
-<PRE>
- /* Compilation failed: print the error message and exit */
-</PRE>
-</P>
-<P>
-<PRE>
- if (re == NULL)
- {
- printf("PCRE compilation failed at offset %d: %s\n",
- erroffset, error);
- return 1;
- }
-</PRE>
-</P>
-<P>
-<PRE>
- /* Compilation succeeded: match the subject in the second
- argument */
-</PRE>
-</P>
-<P>
-<PRE>
- rc = pcre_exec(
- re, /* the compiled pattern */
- NULL, /* we didn't study the pattern */
- argv[2], /* the subject string */
- (int)strlen(argv[2]), /* the length of the subject */
- 0, /* start at offset 0 in the subject */
- 0, /* default options */
- ovector, /* vector for substring information */
- OVECCOUNT); /* number of elements in the vector */
-</PRE>
-</P>
-<P>
-<PRE>
- /* Matching failed: handle error cases */
-</PRE>
-</P>
-<P>
-<PRE>
- if (rc < 0)
- {
- switch(rc)
- {
- case PCRE_ERROR_NOMATCH: printf("No match\n"); break;
- /*
- Handle other special cases if you like
- */
- default: printf("Matching error %d\n", rc); break;
- }
- return 1;
- }
-</PRE>
-</P>
-<P>
-<PRE>
- /* Match succeded */
-</PRE>
-</P>
-<P>
-<PRE>
- printf("Match succeeded\n");
-</PRE>
-</P>
-<P>
-<PRE>
- /* The output vector wasn't big enough */
-</PRE>
-</P>
-<P>
-<PRE>
- if (rc == 0)
- {
- rc = OVECCOUNT/3;
- printf("ovector only has room for %d captured "
- substrings\n", rc - 1);
- }
-</PRE>
-</P>
-<P>
-<PRE>
- /* Show substrings stored in the output vector */
-</PRE>
-</P>
-<P>
-<PRE>
- for (i = 0; i < rc; i++)
- {
- char *substring_start = argv[2] + ovector[2*i];
- int substring_length = ovector[2*i+1] - ovector[2*i];
- printf("%2d: %.*s\n", i, substring_length,
- substring_start);
- }
-</PRE>
-</P>
-<P>
-<PRE>
- return 0;
- }
-</PRE>
-</P>
-<LI><A NAME="SEC32" HREF="#TOC1">AUTHOR</A>
-<P>
-Philip Hazel <ph10@cam.ac.uk>
-<BR>
-University Computing Service,
-<BR>
-New Museums Site,
-<BR>
-Cambridge CB2 3QG, England.
-<BR>
-Phone: +44 1223 334714
-</P>
-<P>
-Last updated: 15 August 2001
-<BR>
-Copyright (c) 1997-2001 University of Cambridge.
+++ /dev/null
------------------------------------------------------------------------------
-This file contains a concatenation of the PCRE man pages, converted to plain
-text format for ease of searching with a text editor, or for use on systems
-that do not have a man page processor. The small individual files that give
-synopses of each function in the library have not been included. There are
-separate text files for the pcregrep and pcretest commands.
------------------------------------------------------------------------------
-
-PCRE(3) PCRE(3)
-
-
-
-NAME
- PCRE - Perl-compatible regular expressions
-
-INTRODUCTION
-
- The PCRE library is a set of functions that implement regular expres-
- sion pattern matching using the same syntax and semantics as Perl, with
- just a few differences. The current implementation of PCRE (release
- 5.x) corresponds approximately with Perl 5.8, including support for
- UTF-8 encoded strings and Unicode general category properties. However,
- this support has to be explicitly enabled; it is not the default.
-
- PCRE is written in C and released as a C library. A number of people
- have written wrappers and interfaces of various kinds. A C++ class is
- included in these contributions, which can be found in the Contrib
- directory at the primary FTP site, which is:
-
- ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre
-
- Details of exactly which Perl regular expression features are and are
- not supported by PCRE are given in separate documents. See the pcrepat-
- tern and pcrecompat pages.
-
- Some features of PCRE can be included, excluded, or changed when the
- library is built. The pcre_config() function makes it possible for a
- client to discover which features are available. The features them-
- selves are described in the pcrebuild page. Documentation about build-
- ing PCRE for various operating systems can be found in the README file
- in the source distribution.
-
-
-USER DOCUMENTATION
-
- The user documentation for PCRE comprises a number of different sec-
- tions. In the "man" format, each of these is a separate "man page". In
- the HTML format, each is a separate page, linked from the index page.
- In the plain text format, all the sections are concatenated, for ease
- of searching. The sections are as follows:
-
- pcre this document
- pcreapi details of PCRE's native API
- pcrebuild options for building PCRE
- pcrecallout details of the callout feature
- pcrecompat discussion of Perl compatibility
- pcregrep description of the pcregrep command
- pcrepartial details of the partial matching facility
- pcrepattern syntax and semantics of supported
- regular expressions
- pcreperform discussion of performance issues
- pcreposix the POSIX-compatible API
- pcreprecompile details of saving and re-using precompiled patterns
- pcresample discussion of the sample program
- pcretest description of the pcretest testing command
-
- In addition, in the "man" and HTML formats, there is a short page for
- each library function, listing its arguments and results.
-
-
-LIMITATIONS
-
- There are some size limitations in PCRE but it is hoped that they will
- never in practice be relevant.
-
- The maximum length of a compiled pattern is 65539 (sic) bytes if PCRE
- is compiled with the default internal linkage size of 2. If you want to
- process regular expressions that are truly enormous, you can compile
- PCRE with an internal linkage size of 3 or 4 (see the README file in
- the source distribution and the pcrebuild documentation for details).
- In these cases the limit is substantially larger. However, the speed
- of execution will be slower.
-
- All values in repeating quantifiers must be less than 65536. The maxi-
- mum number of capturing subpatterns is 65535.
-
- There is no limit to the number of non-capturing subpatterns, but the
- maximum depth of nesting of all kinds of parenthesized subpattern,
- including capturing subpatterns, assertions, and other types of subpat-
- tern, is 200.
-
- The maximum length of a subject string is the largest positive number
- that an integer variable can hold. However, PCRE uses recursion to han-
- dle subpatterns and indefinite repetition. This means that the avail-
- able stack space may limit the size of a subject string that can be
- processed by certain patterns.
-
-
-UTF-8 AND UNICODE PROPERTY SUPPORT
-
- From release 3.3, PCRE has had some support for character strings
- encoded in the UTF-8 format. For release 4.0 this was greatly extended
- to cover most common requirements, and in release 5.0 additional sup-
- port for Unicode general category properties was added.
-
- In order process UTF-8 strings, you must build PCRE to include UTF-8
- support in the code, and, in addition, you must call pcre_compile()
- with the PCRE_UTF8 option flag. When you do this, both the pattern and
- any subject strings that are matched against it are treated as UTF-8
- strings instead of just strings of bytes.
-
- If you compile PCRE with UTF-8 support, but do not use it at run time,
- the library will be a bit bigger, but the additional run time overhead
- is limited to testing the PCRE_UTF8 flag in several places, so should
- not be very large.
-
- If PCRE is built with Unicode character property support (which implies
- UTF-8 support), the escape sequences \p{..}, \P{..}, and \X are sup-
- ported. The available properties that can be tested are limited to the
- general category properties such as Lu for an upper case letter or Nd
- for a decimal number. A full list is given in the pcrepattern documen-
- tation. The PCRE library is increased in size by about 90K when Unicode
- property support is included.
-
- The following comments apply when PCRE is running in UTF-8 mode:
-
- 1. When you set the PCRE_UTF8 flag, the strings passed as patterns and
- subjects are checked for validity on entry to the relevant functions.
- If an invalid UTF-8 string is passed, an error return is given. In some
- situations, you may already know that your strings are valid, and
- therefore want to skip these checks in order to improve performance. If
- you set the PCRE_NO_UTF8_CHECK flag at compile time or at run time,
- PCRE assumes that the pattern or subject it is given (respectively)
- contains only valid UTF-8 codes. In this case, it does not diagnose an
- invalid UTF-8 string. If you pass an invalid UTF-8 string to PCRE when
- PCRE_NO_UTF8_CHECK is set, the results are undefined. Your program may
- crash.
-
- 2. In a pattern, the escape sequence \x{...}, where the contents of the
- braces is a string of hexadecimal digits, is interpreted as a UTF-8
- character whose code number is the given hexadecimal number, for exam-
- ple: \x{1234}. If a non-hexadecimal digit appears between the braces,
- the item is not recognized. This escape sequence can be used either as
- a literal, or within a character class.
-
- 3. The original hexadecimal escape sequence, \xhh, matches a two-byte
- UTF-8 character if the value is greater than 127.
-
- 4. Repeat quantifiers apply to complete UTF-8 characters, not to indi-
- vidual bytes, for example: \x{100}{3}.
-
- 5. The dot metacharacter matches one UTF-8 character instead of a sin-
- gle byte.
-
- 6. The escape sequence \C can be used to match a single byte in UTF-8
- mode, but its use can lead to some strange effects.
-
- 7. The character escapes \b, \B, \d, \D, \s, \S, \w, and \W correctly
- test characters of any code value, but the characters that PCRE recog-
- nizes as digits, spaces, or word characters remain the same set as
- before, all with values less than 256. This remains true even when PCRE
- includes Unicode property support, because to do otherwise would slow
- down PCRE in many common cases. If you really want to test for a wider
- sense of, say, "digit", you must use Unicode property tests such as
- \p{Nd}.
-
- 8. Similarly, characters that match the POSIX named character classes
- are all low-valued characters.
-
- 9. Case-insensitive matching applies only to characters whose values
- are less than 128, unless PCRE is built with Unicode property support.
- Even when Unicode property support is available, PCRE still uses its
- own character tables when checking the case of low-valued characters,
- so as not to degrade performance. The Unicode property information is
- used only for characters with higher values.
-
-
-AUTHOR
-
- Philip Hazel <ph10@cam.ac.uk>
- University Computing Service,
- Cambridge CB2 3QG, England.
- Phone: +44 1223 334714
-
-Last updated: 09 September 2004
-Copyright (c) 1997-2004 University of Cambridge.
------------------------------------------------------------------------------
-
-PCRE(3) PCRE(3)
-
-
-
-NAME
- PCRE - Perl-compatible regular expressions
-
-PCRE BUILD-TIME OPTIONS
-
- This document describes the optional features of PCRE that can be
- selected when the library is compiled. They are all selected, or dese-
- lected, by providing options to the configure script that is run before
- the make command. The complete list of options for configure (which
- includes the standard ones such as the selection of the installation
- directory) can be obtained by running
-
- ./configure --help
-
- The following sections describe certain options whose names begin with
- --enable or --disable. These settings specify changes to the defaults
- for the configure command. Because of the way that configure works,
- --enable and --disable always come in pairs, so the complementary
- option always exists as well, but as it specifies the default, it is
- not described.
-
-
-UTF-8 SUPPORT
-
- To build PCRE with support for UTF-8 character strings, add
-
- --enable-utf8
-
- to the configure command. Of itself, this does not make PCRE treat
- strings as UTF-8. As well as compiling PCRE with this option, you also
- have have to set the PCRE_UTF8 option when you call the pcre_compile()
- function.
-
-
-UNICODE CHARACTER PROPERTY SUPPORT
-
- UTF-8 support allows PCRE to process character values greater than 255
- in the strings that it handles. On its own, however, it does not pro-
- vide any facilities for accessing the properties of such characters. If
- you want to be able to use the pattern escapes \P, \p, and \X, which
- refer to Unicode character properties, you must add
-
- --enable-unicode-properties
-
- to the configure command. This implies UTF-8 support, even if you have
- not explicitly requested it.
-
- Including Unicode property support adds around 90K of tables to the
- PCRE library, approximately doubling its size. Only the general cate-
- gory properties such as Lu and Nd are supported. Details are given in
- the pcrepattern documentation.
-
-
-CODE VALUE OF NEWLINE
-
- By default, PCRE treats character 10 (linefeed) as the newline charac-
- ter. This is the normal newline character on Unix-like systems. You can
- compile PCRE to use character 13 (carriage return) instead by adding
-
- --enable-newline-is-cr
-
- to the configure command. For completeness there is also a --enable-
- newline-is-lf option, which explicitly specifies linefeed as the new-
- line character.
-
-
-BUILDING SHARED AND STATIC LIBRARIES
-
- The PCRE building process uses libtool to build both shared and static
- Unix libraries by default. You can suppress one of these by adding one
- of
-
- --disable-shared
- --disable-static
-
- to the configure command, as required.
-
-
-POSIX MALLOC USAGE
-
- When PCRE is called through the POSIX interface (see the pcreposix doc-
- umentation), additional working storage is required for holding the
- pointers to capturing substrings, because PCRE requires three integers
- per substring, whereas the POSIX interface provides only two. If the
- number of expected substrings is small, the wrapper function uses space
- on the stack, because this is faster than using malloc() for each call.
- The default threshold above which the stack is no longer used is 10; it
- can be changed by adding a setting such as
-
- --with-posix-malloc-threshold=20
-
- to the configure command.
-
-
-LIMITING PCRE RESOURCE USAGE
-
- Internally, PCRE has a function called match(), which it calls repeat-
- edly (possibly recursively) when matching a pattern. By controlling the
- maximum number of times this function may be called during a single
- matching operation, a limit can be placed on the resources used by a
- single call to pcre_exec(). The limit can be changed at run time, as
- described in the pcreapi documentation. The default is 10 million, but
- this can be changed by adding a setting such as
-
- --with-match-limit=500000
-
- to the configure command.
-
-
-HANDLING VERY LARGE PATTERNS
-
- Within a compiled pattern, offset values are used to point from one
- part to another (for example, from an opening parenthesis to an alter-
- nation metacharacter). By default, two-byte values are used for these
- offsets, leading to a maximum size for a compiled pattern of around
- 64K. This is sufficient to handle all but the most gigantic patterns.
- Nevertheless, some people do want to process enormous patterns, so it
- is possible to compile PCRE to use three-byte or four-byte offsets by
- adding a setting such as
-
- --with-link-size=3
-
- to the configure command. The value given must be 2, 3, or 4. Using
- longer offsets slows down the operation of PCRE because it has to load
- additional bytes when handling them.
-
- If you build PCRE with an increased link size, test 2 (and test 5 if
- you are using UTF-8) will fail. Part of the output of these tests is a
- representation of the compiled pattern, and this changes with the link
- size.
-
-
-AVOIDING EXCESSIVE STACK USAGE
-
- PCRE implements backtracking while matching by making recursive calls
- to an internal function called match(). In environments where the size
- of the stack is limited, this can severely limit PCRE's operation. (The
- Unix environment does not usually suffer from this problem.) An alter-
- native approach that uses memory from the heap to remember data,
- instead of using recursive function calls, has been implemented to work
- round this problem. If you want to build a version of PCRE that works
- this way, add
-
- --disable-stack-for-recursion
-
- to the configure command. With this configuration, PCRE will use the
- pcre_stack_malloc and pcre_stack_free variables to call memory manage-
- ment functions. Separate functions are provided because the usage is
- very predictable: the block sizes requested are always the same, and
- the blocks are always freed in reverse order. A calling program might
- be able to implement optimized functions that perform better than the
- standard malloc() and free() functions. PCRE runs noticeably more
- slowly when built in this way.
-
-
-USING EBCDIC CODE
-
- PCRE assumes by default that it will run in an environment where the
- character code is ASCII (or Unicode, which is a superset of ASCII).
- PCRE can, however, be compiled to run in an EBCDIC environment by
- adding
-
- --enable-ebcdic
-
- to the configure command.
-
-Last updated: 09 September 2004
-Copyright (c) 1997-2004 University of Cambridge.
------------------------------------------------------------------------------
-
-PCRE(3) PCRE(3)
-
-
-
-NAME
- PCRE - Perl-compatible regular expressions
-
-PCRE NATIVE API
-
- #include <pcre.h>
-
- pcre *pcre_compile(const char *pattern, int options,
- const char **errptr, int *erroffset,
- const unsigned char *tableptr);
-
- pcre_extra *pcre_study(const pcre *code, int options,
- const char **errptr);
-
- int pcre_exec(const pcre *code, const pcre_extra *extra,
- const char *subject, int length, int startoffset,
- int options, int *ovector, int ovecsize);
-
- int pcre_copy_named_substring(const pcre *code,
- const char *subject, int *ovector,
- int stringcount, const char *stringname,
- char *buffer, int buffersize);
-
- int pcre_copy_substring(const char *subject, int *ovector,
- int stringcount, int stringnumber, char *buffer,
- int buffersize);
-
- int pcre_get_named_substring(const pcre *code,
- const char *subject, int *ovector,
- int stringcount, const char *stringname,
- const char **stringptr);
-
- int pcre_get_stringnumber(const pcre *code,
- const char *name);
-
- int pcre_get_substring(const char *subject, int *ovector,
- int stringcount, int stringnumber,
- const char **stringptr);
-
- int pcre_get_substring_list(const char *subject,
- int *ovector, int stringcount, const char ***listptr);
-
- void pcre_free_substring(const char *stringptr);
-
- void pcre_free_substring_list(const char **stringptr);
-
- const unsigned char *pcre_maketables(void);
-
- int pcre_fullinfo(const pcre *code, const pcre_extra *extra,
- int what, void *where);
-
- int pcre_info(const pcre *code, int *optptr, int *firstcharptr);
-
- int pcre_config(int what, void *where);
-
- char *pcre_version(void);
-
- void *(*pcre_malloc)(size_t);
-
- void (*pcre_free)(void *);
-
- void *(*pcre_stack_malloc)(size_t);
-
- void (*pcre_stack_free)(void *);
-
- int (*pcre_callout)(pcre_callout_block *);
-
-
-PCRE API OVERVIEW
-
- PCRE has its own native API, which is described in this document. There
- is also a set of wrapper functions that correspond to the POSIX regular
- expression API. These are described in the pcreposix documentation.
-
- The native API function prototypes are defined in the header file
- pcre.h, and on Unix systems the library itself is called libpcre. It
- can normally be accessed by adding -lpcre to the command for linking an
- application that uses PCRE. The header file defines the macros
- PCRE_MAJOR and PCRE_MINOR to contain the major and minor release num-
- bers for the library. Applications can use these to include support
- for different releases of PCRE.
-
- The functions pcre_compile(), pcre_study(), and pcre_exec() are used
- for compiling and matching regular expressions. A sample program that
- demonstrates the simplest way of using them is provided in the file
- called pcredemo.c in the source distribution. The pcresample documenta-
- tion describes how to run it.
-
- In addition to the main compiling and matching functions, there are
- convenience functions for extracting captured substrings from a matched
- subject string. They are:
-
- pcre_copy_substring()
- pcre_copy_named_substring()
- pcre_get_substring()
- pcre_get_named_substring()
- pcre_get_substring_list()
- pcre_get_stringnumber()
-
- pcre_free_substring() and pcre_free_substring_list() are also provided,
- to free the memory used for extracted strings.
-
- The function pcre_maketables() is used to build a set of character
- tables in the current locale for passing to pcre_compile() or
- pcre_exec(). This is an optional facility that is provided for spe-
- cialist use. Most commonly, no special tables are passed, in which case
- internal tables that are generated when PCRE is built are used.
-
- The function pcre_fullinfo() is used to find out information about a
- compiled pattern; pcre_info() is an obsolete version that returns only
- some of the available information, but is retained for backwards com-
- patibility. The function pcre_version() returns a pointer to a string
- containing the version of PCRE and its date of release.
-
- The global variables pcre_malloc and pcre_free initially contain the
- entry points of the standard malloc() and free() functions, respec-
- tively. PCRE calls the memory management functions via these variables,
- so a calling program can replace them if it wishes to intercept the
- calls. This should be done before calling any PCRE functions.
-
- The global variables pcre_stack_malloc and pcre_stack_free are also
- indirections to memory management functions. These special functions
- are used only when PCRE is compiled to use the heap for remembering
- data, instead of recursive function calls. This is a non-standard way
- of building PCRE, for use in environments that have limited stacks.
- Because of the greater use of memory management, it runs more slowly.
- Separate functions are provided so that special-purpose external code
- can be used for this case. When used, these functions are always called
- in a stack-like manner (last obtained, first freed), and always for
- memory blocks of the same size.
-
- The global variable pcre_callout initially contains NULL. It can be set
- by the caller to a "callout" function, which PCRE will then call at
- specified points during a matching operation. Details are given in the
- pcrecallout documentation.
-
-
-MULTITHREADING
-
- The PCRE functions can be used in multi-threading applications, with
- the proviso that the memory management functions pointed to by
- pcre_malloc, pcre_free, pcre_stack_malloc, and pcre_stack_free, and the
- callout function pointed to by pcre_callout, are shared by all threads.
-
- The compiled form of a regular expression is not altered during match-
- ing, so the same compiled pattern can safely be used by several threads
- at once.
-
-
-SAVING PRECOMPILED PATTERNS FOR LATER USE
-
- The compiled form of a regular expression can be saved and re-used at a
- later time, possibly by a different program, and even on a host other
- than the one on which it was compiled. Details are given in the
- pcreprecompile documentation.
-
-
-CHECKING BUILD-TIME OPTIONS
-
- int pcre_config(int what, void *where);
-
- The function pcre_config() makes it possible for a PCRE client to dis-
- cover which optional features have been compiled into the PCRE library.
- The pcrebuild documentation has more details about these optional fea-
- tures.
-
- The first argument for pcre_config() is an integer, specifying which
- information is required; the second argument is a pointer to a variable
- into which the information is placed. The following information is
- available:
-
- PCRE_CONFIG_UTF8
-
- The output is an integer that is set to one if UTF-8 support is avail-
- able; otherwise it is set to zero.
-
- PCRE_CONFIG_UNICODE_PROPERTIES
-
- The output is an integer that is set to one if support for Unicode
- character properties is available; otherwise it is set to zero.
-
- PCRE_CONFIG_NEWLINE
-
- The output is an integer that is set to the value of the code that is
- used for the newline character. It is either linefeed (10) or carriage
- return (13), and should normally be the standard character for your
- operating system.
-
- PCRE_CONFIG_LINK_SIZE
-
- The output is an integer that contains the number of bytes used for
- internal linkage in compiled regular expressions. The value is 2, 3, or
- 4. Larger values allow larger regular expressions to be compiled, at
- the expense of slower matching. The default value of 2 is sufficient
- for all but the most massive patterns, since it allows the compiled
- pattern to be up to 64K in size.
-
- PCRE_CONFIG_POSIX_MALLOC_THRESHOLD
-
- The output is an integer that contains the threshold above which the
- POSIX interface uses malloc() for output vectors. Further details are
- given in the pcreposix documentation.
-
- PCRE_CONFIG_MATCH_LIMIT
-
- The output is an integer that gives the default limit for the number of
- internal matching function calls in a pcre_exec() execution. Further
- details are given with pcre_exec() below.
-
- PCRE_CONFIG_STACKRECURSE
-
- The output is an integer that is set to one if internal recursion is
- implemented by recursive function calls that use the stack to remember
- their state. This is the usual way that PCRE is compiled. The output is
- zero if PCRE was compiled to use blocks of data on the heap instead of
- recursive function calls. In this case, pcre_stack_malloc and
- pcre_stack_free are called to manage memory blocks on the heap, thus
- avoiding the use of the stack.
-
-
-COMPILING A PATTERN
-
- pcre *pcre_compile(const char *pattern, int options,
- const char **errptr, int *erroffset,
- const unsigned char *tableptr);
-
- The function pcre_compile() is called to compile a pattern into an
- internal form. The pattern is a C string terminated by a binary zero,
- and is passed in the pattern argument. A pointer to a single block of
- memory that is obtained via pcre_malloc is returned. This contains the
- compiled code and related data. The pcre type is defined for the
- returned block; this is a typedef for a structure whose contents are
- not externally defined. It is up to the caller to free the memory when
- it is no longer required.
-
- Although the compiled code of a PCRE regex is relocatable, that is, it
- does not depend on memory location, the complete pcre data block is not
- fully relocatable, because it may contain a copy of the tableptr argu-
- ment, which is an address (see below).
-
- The options argument contains independent bits that affect the compila-
- tion. It should be zero if no options are required. The available
- options are described below. Some of them, in particular, those that
- are compatible with Perl, can also be set and unset from within the
- pattern (see the detailed description in the pcrepattern documenta-
- tion). For these options, the contents of the options argument speci-
- fies their initial settings at the start of compilation and execution.
- The PCRE_ANCHORED option can be set at the time of matching as well as
- at compile time.
-
- If errptr is NULL, pcre_compile() returns NULL immediately. Otherwise,
- if compilation of a pattern fails, pcre_compile() returns NULL, and
- sets the variable pointed to by errptr to point to a textual error mes-
- sage. The offset from the start of the pattern to the character where
- the error was discovered is placed in the variable pointed to by
- erroffset, which must not be NULL. If it is, an immediate error is
- given.
-
- If the final argument, tableptr, is NULL, PCRE uses a default set of
- character tables that are built when PCRE is compiled, using the
- default C locale. Otherwise, tableptr must be an address that is the
- result of a call to pcre_maketables(). This value is stored with the
- compiled pattern, and used again by pcre_exec(), unless another table
- pointer is passed to it. For more discussion, see the section on locale
- support below.
-
- This code fragment shows a typical straightforward call to pcre_com-
- pile():
-
- pcre *re;
- const char *error;
- int erroffset;
- re = pcre_compile(
- "^A.*Z", /* the pattern */
- 0, /* default options */
- &error, /* for error message */
- &erroffset, /* for error offset */
- NULL); /* use default character tables */
-
- The following names for option bits are defined in the pcre.h header
- file:
-
- PCRE_ANCHORED
-
- If this bit is set, the pattern is forced to be "anchored", that is, it
- is constrained to match only at the first matching point in the string
- that is being searched (the "subject string"). This effect can also be
- achieved by appropriate constructs in the pattern itself, which is the
- only way to do it in Perl.
-
- PCRE_AUTO_CALLOUT
-
- If this bit is set, pcre_compile() automatically inserts callout items,
- all with number 255, before each pattern item. For discussion of the
- callout facility, see the pcrecallout documentation.
-
- PCRE_CASELESS
-
- If this bit is set, letters in the pattern match both upper and lower
- case letters. It is equivalent to Perl's /i option, and it can be
- changed within a pattern by a (?i) option setting. When running in
- UTF-8 mode, case support for high-valued characters is available only
- when PCRE is built with Unicode character property support.
-
- PCRE_DOLLAR_ENDONLY
-
- If this bit is set, a dollar metacharacter in the pattern matches only
- at the end of the subject string. Without this option, a dollar also
- matches immediately before the final character if it is a newline (but
- not before any other newlines). The PCRE_DOLLAR_ENDONLY option is
- ignored if PCRE_MULTILINE is set. There is no equivalent to this option
- in Perl, and no way to set it within a pattern.
-
- PCRE_DOTALL
-
- If this bit is set, a dot metacharater in the pattern matches all char-
- acters, including newlines. Without it, newlines are excluded. This
- option is equivalent to Perl's /s option, and it can be changed within
- a pattern by a (?s) option setting. A negative class such as [^a]
- always matches a newline character, independent of the setting of this
- option.
-
- PCRE_EXTENDED
-
- If this bit is set, whitespace data characters in the pattern are
- totally ignored except when escaped or inside a character class.
- Whitespace does not include the VT character (code 11). In addition,
- characters between an unescaped # outside a character class and the
- next newline character, inclusive, are also ignored. This is equivalent
- to Perl's /x option, and it can be changed within a pattern by a (?x)
- option setting.
-
- This option makes it possible to include comments inside complicated
- patterns. Note, however, that this applies only to data characters.
- Whitespace characters may never appear within special character
- sequences in a pattern, for example within the sequence (?( which
- introduces a conditional subpattern.
-
- PCRE_EXTRA
-
- This option was invented in order to turn on additional functionality
- of PCRE that is incompatible with Perl, but it is currently of very
- little use. When set, any backslash in a pattern that is followed by a
- letter that has no special meaning causes an error, thus reserving
- these combinations for future expansion. By default, as in Perl, a
- backslash followed by a letter with no special meaning is treated as a
- literal. There are at present no other features controlled by this
- option. It can also be set by a (?X) option setting within a pattern.
-
- PCRE_MULTILINE
-
- By default, PCRE treats the subject string as consisting of a single
- line of characters (even if it actually contains newlines). The "start
- of line" metacharacter (^) matches only at the start of the string,
- while the "end of line" metacharacter ($) matches only at the end of
- the string, or before a terminating newline (unless PCRE_DOLLAR_ENDONLY
- is set). This is the same as Perl.
-
- When PCRE_MULTILINE it is set, the "start of line" and "end of line"
- constructs match immediately following or immediately before any new-
- line in the subject string, respectively, as well as at the very start
- and end. This is equivalent to Perl's /m option, and it can be changed
- within a pattern by a (?m) option setting. If there are no "\n" charac-
- ters in a subject string, or no occurrences of ^ or $ in a pattern,
- setting PCRE_MULTILINE has no effect.
-
- PCRE_NO_AUTO_CAPTURE
-
- If this option is set, it disables the use of numbered capturing paren-
- theses in the pattern. Any opening parenthesis that is not followed by
- ? behaves as if it were followed by ?: but named parentheses can still
- be used for capturing (and they acquire numbers in the usual way).
- There is no equivalent of this option in Perl.
-
- PCRE_UNGREEDY
-
- This option inverts the "greediness" of the quantifiers so that they
- are not greedy by default, but become greedy if followed by "?". It is
- not compatible with Perl. It can also be set by a (?U) option setting
- within the pattern.
-
- PCRE_UTF8
-
- This option causes PCRE to regard both the pattern and the subject as
- strings of UTF-8 characters instead of single-byte character strings.
- However, it is available only when PCRE is built to include UTF-8 sup-
- port. If not, the use of this option provokes an error. Details of how
- this option changes the behaviour of PCRE are given in the section on
- UTF-8 support in the main pcre page.
-
- PCRE_NO_UTF8_CHECK
-
- When PCRE_UTF8 is set, the validity of the pattern as a UTF-8 string is
- automatically checked. If an invalid UTF-8 sequence of bytes is found,
- pcre_compile() returns an error. If you already know that your pattern
- is valid, and you want to skip this check for performance reasons, you
- can set the PCRE_NO_UTF8_CHECK option. When it is set, the effect of
- passing an invalid UTF-8 string as a pattern is undefined. It may cause
- your program to crash. Note that this option can also be passed to
- pcre_exec(), to suppress the UTF-8 validity checking of subject
- strings.
-
-
-STUDYING A PATTERN
-
- pcre_extra *pcre_study(const pcre *code, int options,
- const char **errptr);
-
- If a compiled pattern is going to be used several times, it is worth
- spending more time analyzing it in order to speed up the time taken for
- matching. The function pcre_study() takes a pointer to a compiled pat-
- tern as its first argument. If studying the pattern produces additional
- information that will help speed up matching, pcre_study() returns a
- pointer to a pcre_extra block, in which the study_data field points to
- the results of the study.
-
- The returned value from pcre_study() can be passed directly to
- pcre_exec(). However, a pcre_extra block also contains other fields
- that can be set by the caller before the block is passed; these are
- described below in the section on matching a pattern.
-
- If studying the pattern does not produce any additional information,
- pcre_study() returns NULL. In that circumstance, if the calling program
- wants to pass any of the other fields to pcre_exec(), it must set up
- its own pcre_extra block.
-
- The second argument of pcre_study() contains option bits. At present,
- no options are defined, and this argument should always be zero.
-
- The third argument for pcre_study() is a pointer for an error message.
- If studying succeeds (even if no data is returned), the variable it
- points to is set to NULL. Otherwise it points to a textual error mes-
- sage. You should therefore test the error pointer for NULL after call-
- ing pcre_study(), to be sure that it has run successfully.
-
- This is a typical call to pcre_study():
-
- pcre_extra *pe;
- pe = pcre_study(
- re, /* result of pcre_compile() */
- 0, /* no options exist */
- &error); /* set to NULL or points to a message */
-
- At present, studying a pattern is useful only for non-anchored patterns
- that do not have a single fixed starting character. A bitmap of possi-
- ble starting bytes is created.
-
-
-LOCALE SUPPORT
-
- PCRE handles caseless matching, and determines whether characters are
- letters, digits, or whatever, by reference to a set of tables, indexed
- by character value. (When running in UTF-8 mode, this applies only to
- characters with codes less than 128. Higher-valued codes never match
- escapes such as \w or \d, but can be tested with \p if PCRE is built
- with Unicode character property support.)
-
- An internal set of tables is created in the default C locale when PCRE
- is built. This is used when the final argument of pcre_compile() is
- NULL, and is sufficient for many applications. An alternative set of
- tables can, however, be supplied. These may be created in a different
- locale from the default. As more and more applications change to using
- Unicode, the need for this locale support is expected to die away.
-
- External tables are built by calling the pcre_maketables() function,
- which has no arguments, in the relevant locale. The result can then be
- passed to pcre_compile() or pcre_exec() as often as necessary. For
- example, to build and use tables that are appropriate for the French
- locale (where accented characters with values greater than 128 are
- treated as letters), the following code could be used:
-
- setlocale(LC_CTYPE, "fr_FR");
- tables = pcre_maketables();
- re = pcre_compile(..., tables);
-
- When pcre_maketables() runs, the tables are built in memory that is
- obtained via pcre_malloc. It is the caller's responsibility to ensure
- that the memory containing the tables remains available for as long as
- it is needed.
-
- The pointer that is passed to pcre_compile() is saved with the compiled
- pattern, and the same tables are used via this pointer by pcre_study()
- and normally also by pcre_exec(). Thus, by default, for any single pat-
- tern, compilation, studying and matching all happen in the same locale,
- but different patterns can be compiled in different locales.
-
- It is possible to pass a table pointer or NULL (indicating the use of
- the internal tables) to pcre_exec(). Although not intended for this
- purpose, this facility could be used to match a pattern in a different
- locale from the one in which it was compiled. Passing table pointers at
- run time is discussed below in the section on matching a pattern.
-
-
-INFORMATION ABOUT A PATTERN
-
- int pcre_fullinfo(const pcre *code, const pcre_extra *extra,
- int what, void *where);
-
- The pcre_fullinfo() function returns information about a compiled pat-
- tern. It replaces the obsolete pcre_info() function, which is neverthe-
- less retained for backwards compability (and is documented below).
-
- The first argument for pcre_fullinfo() is a pointer to the compiled
- pattern. The second argument is the result of pcre_study(), or NULL if
- the pattern was not studied. The third argument specifies which piece
- of information is required, and the fourth argument is a pointer to a
- variable to receive the data. The yield of the function is zero for
- success, or one of the following negative numbers:
-
- PCRE_ERROR_NULL the argument code was NULL
- the argument where was NULL
- PCRE_ERROR_BADMAGIC the "magic number" was not found
- PCRE_ERROR_BADOPTION the value of what was invalid
-
- The "magic number" is placed at the start of each compiled pattern as
- an simple check against passing an arbitrary memory pointer. Here is a
- typical call of pcre_fullinfo(), to obtain the length of the compiled
- pattern:
-
- int rc;
- unsigned long int length;
- rc = pcre_fullinfo(
- re, /* result of pcre_compile() */
- pe, /* result of pcre_study(), or NULL */
- PCRE_INFO_SIZE, /* what is required */
- &length); /* where to put the data */
-
- The possible values for the third argument are defined in pcre.h, and
- are as follows:
-
- PCRE_INFO_BACKREFMAX
-
- Return the number of the highest back reference in the pattern. The
- fourth argument should point to an int variable. Zero is returned if
- there are no back references.
-
- PCRE_INFO_CAPTURECOUNT
-
- Return the number of capturing subpatterns in the pattern. The fourth
- argument should point to an int variable.
-
- PCRE_INFO_DEFAULTTABLES
-
- Return a pointer to the internal default character tables within PCRE.
- The fourth argument should point to an unsigned char * variable. This
- information call is provided for internal use by the pcre_study() func-
- tion. External callers can cause PCRE to use its internal tables by
- passing a NULL table pointer.
-
- PCRE_INFO_FIRSTBYTE
-
- Return information about the first byte of any matched string, for a
- non-anchored pattern. (This option used to be called
- PCRE_INFO_FIRSTCHAR; the old name is still recognized for backwards
- compatibility.)
-
- If there is a fixed first byte, for example, from a pattern such as
- (cat|cow|coyote), it is returned in the integer pointed to by where.
- Otherwise, if either
-
- (a) the pattern was compiled with the PCRE_MULTILINE option, and every
- branch starts with "^", or
-
- (b) every branch of the pattern starts with ".*" and PCRE_DOTALL is not
- set (if it were set, the pattern would be anchored),
-
- -1 is returned, indicating that the pattern matches only at the start
- of a subject string or after any newline within the string. Otherwise
- -2 is returned. For anchored patterns, -2 is returned.
-
- PCRE_INFO_FIRSTTABLE
-
- If the pattern was studied, and this resulted in the construction of a
- 256-bit table indicating a fixed set of bytes for the first byte in any
- matching string, a pointer to the table is returned. Otherwise NULL is
- returned. The fourth argument should point to an unsigned char * vari-
- able.
-
- PCRE_INFO_LASTLITERAL
-
- Return the value of the rightmost literal byte that must exist in any
- matched string, other than at its start, if such a byte has been
- recorded. The fourth argument should point to an int variable. If there
- is no such byte, -1 is returned. For anchored patterns, a last literal
- byte is recorded only if it follows something of variable length. For
- example, for the pattern /^a\d+z\d+/ the returned value is "z", but for
- /^a\dz\d/ the returned value is -1.
-
- PCRE_INFO_NAMECOUNT
- PCRE_INFO_NAMEENTRYSIZE
- PCRE_INFO_NAMETABLE
-
- PCRE supports the use of named as well as numbered capturing parenthe-
- ses. The names are just an additional way of identifying the parenthe-
- ses, which still acquire numbers. A convenience function called
- pcre_get_named_substring() is provided for extracting an individual
- captured substring by name. It is also possible to extract the data
- directly, by first converting the name to a number in order to access
- the correct pointers in the output vector (described with pcre_exec()
- below). To do the conversion, you need to use the name-to-number map,
- which is described by these three values.
-
- The map consists of a number of fixed-size entries. PCRE_INFO_NAMECOUNT
- gives the number of entries, and PCRE_INFO_NAMEENTRYSIZE gives the size
- of each entry; both of these return an int value. The entry size
- depends on the length of the longest name. PCRE_INFO_NAMETABLE returns
- a pointer to the first entry of the table (a pointer to char). The
- first two bytes of each entry are the number of the capturing parenthe-
- sis, most significant byte first. The rest of the entry is the corre-
- sponding name, zero terminated. The names are in alphabetical order.
- For example, consider the following pattern (assume PCRE_EXTENDED is
- set, so white space - including newlines - is ignored):
-
- (?P<date> (?P<year>(\d\d)?\d\d) -
- (?P<month>\d\d) - (?P<day>\d\d) )
-
- There are four named subpatterns, so the table has four entries, and
- each entry in the table is eight bytes long. The table is as follows,
- with non-printing bytes shows in hexadecimal, and undefined bytes shown
- as ??:
-
- 00 01 d a t e 00 ??
- 00 05 d a y 00 ?? ??
- 00 04 m o n t h 00
- 00 02 y e a r 00 ??
-
- When writing code to extract data from named subpatterns using the
- name-to-number map, remember that the length of each entry is likely to
- be different for each compiled pattern.
-
- PCRE_INFO_OPTIONS
-
- Return a copy of the options with which the pattern was compiled. The
- fourth argument should point to an unsigned long int variable. These
- option bits are those specified in the call to pcre_compile(), modified
- by any top-level option settings within the pattern itself.
-
- A pattern is automatically anchored by PCRE if all of its top-level
- alternatives begin with one of the following:
-
- ^ unless PCRE_MULTILINE is set
- \A always
- \G always
- .* if PCRE_DOTALL is set and there are no back
- references to the subpattern in which .* appears
-
- For such patterns, the PCRE_ANCHORED bit is set in the options returned
- by pcre_fullinfo().
-
- PCRE_INFO_SIZE
-
- Return the size of the compiled pattern, that is, the value that was
- passed as the argument to pcre_malloc() when PCRE was getting memory in
- which to place the compiled data. The fourth argument should point to a
- size_t variable.
-
- PCRE_INFO_STUDYSIZE
-
- Return the size of the data block pointed to by the study_data field in
- a pcre_extra block. That is, it is the value that was passed to
- pcre_malloc() when PCRE was getting memory into which to place the data
- created by pcre_study(). The fourth argument should point to a size_t
- variable.
-
-
-OBSOLETE INFO FUNCTION
-
- int pcre_info(const pcre *code, int *optptr, int *firstcharptr);
-
- The pcre_info() function is now obsolete because its interface is too
- restrictive to return all the available data about a compiled pattern.
- New programs should use pcre_fullinfo() instead. The yield of
- pcre_info() is the number of capturing subpatterns, or one of the fol-
- lowing negative numbers:
-
- PCRE_ERROR_NULL the argument code was NULL
- PCRE_ERROR_BADMAGIC the "magic number" was not found
-
- If the optptr argument is not NULL, a copy of the options with which
- the pattern was compiled is placed in the integer it points to (see
- PCRE_INFO_OPTIONS above).
-
- If the pattern is not anchored and the firstcharptr argument is not
- NULL, it is used to pass back information about the first character of
- any matched string (see PCRE_INFO_FIRSTBYTE above).
-
-
-MATCHING A PATTERN
-
- int pcre_exec(const pcre *code, const pcre_extra *extra,
- const char *subject, int length, int startoffset,
- int options, int *ovector, int ovecsize);
-
- The function pcre_exec() is called to match a subject string against a
- compiled pattern, which is passed in the code argument. If the pattern
- has been studied, the result of the study should be passed in the extra
- argument.
-
- In most applications, the pattern will have been compiled (and option-
- ally studied) in the same process that calls pcre_exec(). However, it
- is possible to save compiled patterns and study data, and then use them
- later in different processes, possibly even on different hosts. For a
- discussion about this, see the pcreprecompile documentation.
-
- Here is an example of a simple call to pcre_exec():
-
- int rc;
- int ovector[30];
- rc = pcre_exec(
- re, /* result of pcre_compile() */
- NULL, /* we didn't study the pattern */
- "some string", /* the subject string */
- 11, /* the length of the subject string */
- 0, /* start at offset 0 in the subject */
- 0, /* default options */
- ovector, /* vector of integers for substring information */
- 30); /* number of elements in the vector (NOT size in
- bytes) */
-
- Extra data for pcre_exec()
-
- If the extra argument is not NULL, it must point to a pcre_extra data
- block. The pcre_study() function returns such a block (when it doesn't
- return NULL), but you can also create one for yourself, and pass addi-
- tional information in it. The fields in a pcre_extra block are as fol-
- lows:
-
- unsigned long int flags;
- void *study_data;
- unsigned long int match_limit;
- void *callout_data;
- const unsigned char *tables;
-
- The flags field is a bitmap that specifies which of the other fields
- are set. The flag bits are:
-
- PCRE_EXTRA_STUDY_DATA
- PCRE_EXTRA_MATCH_LIMIT
- PCRE_EXTRA_CALLOUT_DATA
- PCRE_EXTRA_TABLES
-
- Other flag bits should be set to zero. The study_data field is set in
- the pcre_extra block that is returned by pcre_study(), together with
- the appropriate flag bit. You should not set this yourself, but you may
- add to the block by setting the other fields and their corresponding
- flag bits.
-
- The match_limit field provides a means of preventing PCRE from using up
- a vast amount of resources when running patterns that are not going to
- match, but which have a very large number of possibilities in their
- search trees. The classic example is the use of nested unlimited
- repeats.
-
- Internally, PCRE uses a function called match() which it calls repeat-
- edly (sometimes recursively). The limit is imposed on the number of
- times this function is called during a match, which has the effect of
- limiting the amount of recursion and backtracking that can take place.
- For patterns that are not anchored, the count starts from zero for each
- position in the subject string.
-
- The default limit for the library can be set when PCRE is built; the
- default default is 10 million, which handles all but the most extreme
- cases. You can reduce the default by suppling pcre_exec() with a
- pcre_extra block in which match_limit is set to a smaller value, and
- PCRE_EXTRA_MATCH_LIMIT is set in the flags field. If the limit is
- exceeded, pcre_exec() returns PCRE_ERROR_MATCHLIMIT.
-
- The pcre_callout field is used in conjunction with the "callout" fea-
- ture, which is described in the pcrecallout documentation.
-
- The tables field is used to pass a character tables pointer to
- pcre_exec(); this overrides the value that is stored with the compiled
- pattern. A non-NULL value is stored with the compiled pattern only if
- custom tables were supplied to pcre_compile() via its tableptr argu-
- ment. If NULL is passed to pcre_exec() using this mechanism, it forces
- PCRE's internal tables to be used. This facility is helpful when re-
- using patterns that have been saved after compiling with an external
- set of tables, because the external tables might be at a different
- address when pcre_exec() is called. See the pcreprecompile documenta-
- tion for a discussion of saving compiled patterns for later use.
-
- Option bits for pcre_exec()
-
- The unused bits of the options argument for pcre_exec() must be zero.
- The only bits that may be set are PCRE_ANCHORED, PCRE_NOTBOL,
- PCRE_NOTEOL, PCRE_NOTEMPTY, PCRE_NO_UTF8_CHECK and PCRE_PARTIAL.
-
- PCRE_ANCHORED
-
- The PCRE_ANCHORED option limits pcre_exec() to matching at the first
- matching position. If a pattern was compiled with PCRE_ANCHORED, or
- turned out to be anchored by virtue of its contents, it cannot be made
- unachored at matching time.
-
- PCRE_NOTBOL
-
- This option specifies that first character of the subject string is not
- the beginning of a line, so the circumflex metacharacter should not
- match before it. Setting this without PCRE_MULTILINE (at compile time)
- causes circumflex never to match. This option affects only the
- behaviour of the circumflex metacharacter. It does not affect \A.
-
- PCRE_NOTEOL
-
- This option specifies that the end of the subject string is not the end
- of a line, so the dollar metacharacter should not match it nor (except
- in multiline mode) a newline immediately before it. Setting this with-
- out PCRE_MULTILINE (at compile time) causes dollar never to match. This
- option affects only the behaviour of the dollar metacharacter. It does
- not affect \Z or \z.
-
- PCRE_NOTEMPTY
-
- An empty string is not considered to be a valid match if this option is
- set. If there are alternatives in the pattern, they are tried. If all
- the alternatives match the empty string, the entire match fails. For
- example, if the pattern
-
- a?b?
-
- is applied to a string not beginning with "a" or "b", it matches the
- empty string at the start of the subject. With PCRE_NOTEMPTY set, this
- match is not valid, so PCRE searches further into the string for occur-
- rences of "a" or "b".
-
- Perl has no direct equivalent of PCRE_NOTEMPTY, but it does make a spe-
- cial case of a pattern match of the empty string within its split()
- function, and when using the /g modifier. It is possible to emulate
- Perl's behaviour after matching a null string by first trying the match
- again at the same offset with PCRE_NOTEMPTY and PCRE_ANCHORED, and then
- if that fails by advancing the starting offset (see below) and trying
- an ordinary match again. There is some code that demonstrates how to do
- this in the pcredemo.c sample program.
-
- PCRE_NO_UTF8_CHECK
-
- When PCRE_UTF8 is set at compile time, the validity of the subject as a
- UTF-8 string is automatically checked when pcre_exec() is subsequently
- called. The value of startoffset is also checked to ensure that it
- points to the start of a UTF-8 character. If an invalid UTF-8 sequence
- of bytes is found, pcre_exec() returns the error PCRE_ERROR_BADUTF8. If
- startoffset contains an invalid value, PCRE_ERROR_BADUTF8_OFFSET is
- returned.
-
- If you already know that your subject is valid, and you want to skip
- these checks for performance reasons, you can set the
- PCRE_NO_UTF8_CHECK option when calling pcre_exec(). You might want to
- do this for the second and subsequent calls to pcre_exec() if you are
- making repeated calls to find all the matches in a single subject
- string. However, you should be sure that the value of startoffset
- points to the start of a UTF-8 character. When PCRE_NO_UTF8_CHECK is
- set, the effect of passing an invalid UTF-8 string as a subject, or a
- value of startoffset that does not point to the start of a UTF-8 char-
- acter, is undefined. Your program may crash.
-
- PCRE_PARTIAL
-
- This option turns on the partial matching feature. If the subject
- string fails to match the pattern, but at some point during the match-
- ing process the end of the subject was reached (that is, the subject
- partially matches the pattern and the failure to match occurred only
- because there were not enough subject characters), pcre_exec() returns
- PCRE_ERROR_PARTIAL instead of PCRE_ERROR_NOMATCH. When PCRE_PARTIAL is
- used, there are restrictions on what may appear in the pattern. These
- are discussed in the pcrepartial documentation.
-
- The string to be matched by pcre_exec()
-
- The subject string is passed to pcre_exec() as a pointer in subject, a
- length in length, and a starting byte offset in startoffset. In UTF-8
- mode, the byte offset must point to the start of a UTF-8 character.
- Unlike the pattern string, the subject may contain binary zero bytes.
- When the starting offset is zero, the search for a match starts at the
- beginning of the subject, and this is by far the most common case.
-
- A non-zero starting offset is useful when searching for another match
- in the same subject by calling pcre_exec() again after a previous suc-
- cess. Setting startoffset differs from just passing over a shortened
- string and setting PCRE_NOTBOL in the case of a pattern that begins
- with any kind of lookbehind. For example, consider the pattern
-
- \Biss\B
-
- which finds occurrences of "iss" in the middle of words. (\B matches
- only if the current position in the subject is not a word boundary.)
- When applied to the string "Mississipi" the first call to pcre_exec()
- finds the first occurrence. If pcre_exec() is called again with just
- the remainder of the subject, namely "issipi", it does not match,
- because \B is always false at the start of the subject, which is deemed
- to be a word boundary. However, if pcre_exec() is passed the entire
- string again, but with startoffset set to 4, it finds the second occur-
- rence of "iss" because it is able to look behind the starting point to
- discover that it is preceded by a letter.
-
- If a non-zero starting offset is passed when the pattern is anchored,
- one attempt to match at the given offset is made. This can only succeed
- if the pattern does not require the match to be at the start of the
- subject.
-
- How pcre_exec() returns captured substrings
-
- In general, a pattern matches a certain portion of the subject, and in
- addition, further substrings from the subject may be picked out by
- parts of the pattern. Following the usage in Jeffrey Friedl's book,
- this is called "capturing" in what follows, and the phrase "capturing
- subpattern" is used for a fragment of a pattern that picks out a sub-
- string. PCRE supports several other kinds of parenthesized subpattern
- that do not cause substrings to be captured.
-
- Captured substrings are returned to the caller via a vector of integer
- offsets whose address is passed in ovector. The number of elements in
- the vector is passed in ovecsize, which must be a non-negative number.
- Note: this argument is NOT the size of ovector in bytes.
-
- The first two-thirds of the vector is used to pass back captured sub-
- strings, each substring using a pair of integers. The remaining third
- of the vector is used as workspace by pcre_exec() while matching cap-
- turing subpatterns, and is not available for passing back information.
- The length passed in ovecsize should always be a multiple of three. If
- it is not, it is rounded down.
-
- When a match is successful, information about captured substrings is
- returned in pairs of integers, starting at the beginning of ovector,
- and continuing up to two-thirds of its length at the most. The first
- element of a pair is set to the offset of the first character in a sub-
- string, and the second is set to the offset of the first character
- after the end of a substring. The first pair, ovector[0] and ovec-
- tor[1], identify the portion of the subject string matched by the
- entire pattern. The next pair is used for the first capturing subpat-
- tern, and so on. The value returned by pcre_exec() is the number of
- pairs that have been set. If there are no capturing subpatterns, the
- return value from a successful match is 1, indicating that just the
- first pair of offsets has been set.
-
- Some convenience functions are provided for extracting the captured
- substrings as separate strings. These are described in the following
- section.
-
- It is possible for an capturing subpattern number n+1 to match some
- part of the subject when subpattern n has not been used at all. For
- example, if the string "abc" is matched against the pattern (a|(z))(bc)
- subpatterns 1 and 3 are matched, but 2 is not. When this happens, both
- offset values corresponding to the unused subpattern are set to -1.
-
- If a capturing subpattern is matched repeatedly, it is the last portion
- of the string that it matched that is returned.
-
- If the vector is too small to hold all the captured substring offsets,
- it is used as far as possible (up to two-thirds of its length), and the
- function returns a value of zero. In particular, if the substring off-
- sets are not of interest, pcre_exec() may be called with ovector passed
- as NULL and ovecsize as zero. However, if the pattern contains back
- references and the ovector is not big enough to remember the related
- substrings, PCRE has to get additional memory for use during matching.
- Thus it is usually advisable to supply an ovector.
-
- Note that pcre_info() can be used to find out how many capturing sub-
- patterns there are in a compiled pattern. The smallest size for ovector
- that will allow for n captured substrings, in addition to the offsets
- of the substring matched by the whole pattern, is (n+1)*3.
-
- Return values from pcre_exec()
-
- If pcre_exec() fails, it returns a negative number. The following are
- defined in the header file:
-
- PCRE_ERROR_NOMATCH (-1)
-
- The subject string did not match the pattern.
-
- PCRE_ERROR_NULL (-2)
-
- Either code or subject was passed as NULL, or ovector was NULL and
- ovecsize was not zero.
-
- PCRE_ERROR_BADOPTION (-3)
-
- An unrecognized bit was set in the options argument.
-
- PCRE_ERROR_BADMAGIC (-4)
-
- PCRE stores a 4-byte "magic number" at the start of the compiled code,
- to catch the case when it is passed a junk pointer and to detect when a
- pattern that was compiled in an environment of one endianness is run in
- an environment with the other endianness. This is the error that PCRE
- gives when the magic number is not present.
-
- PCRE_ERROR_UNKNOWN_NODE (-5)
-
- While running the pattern match, an unknown item was encountered in the
- compiled pattern. This error could be caused by a bug in PCRE or by
- overwriting of the compiled pattern.
-
- PCRE_ERROR_NOMEMORY (-6)
-
- If a pattern contains back references, but the ovector that is passed
- to pcre_exec() is not big enough to remember the referenced substrings,
- PCRE gets a block of memory at the start of matching to use for this
- purpose. If the call via pcre_malloc() fails, this error is given. The
- memory is automatically freed at the end of matching.
-
- PCRE_ERROR_NOSUBSTRING (-7)
-
- This error is used by the pcre_copy_substring(), pcre_get_substring(),
- and pcre_get_substring_list() functions (see below). It is never
- returned by pcre_exec().
-
- PCRE_ERROR_MATCHLIMIT (-8)
-
- The recursion and backtracking limit, as specified by the match_limit
- field in a pcre_extra structure (or defaulted) was reached. See the
- description above.
-
- PCRE_ERROR_CALLOUT (-9)
-
- This error is never generated by pcre_exec() itself. It is provided for
- use by callout functions that want to yield a distinctive error code.
- See the pcrecallout documentation for details.
-
- PCRE_ERROR_BADUTF8 (-10)
-
- A string that contains an invalid UTF-8 byte sequence was passed as a
- subject.
-
- PCRE_ERROR_BADUTF8_OFFSET (-11)
-
- The UTF-8 byte sequence that was passed as a subject was valid, but the
- value of startoffset did not point to the beginning of a UTF-8 charac-
- ter.
-
- PCRE_ERROR_PARTIAL (-12)
-
- The subject string did not match, but it did match partially. See the
- pcrepartial documentation for details of partial matching.
-
- PCRE_ERROR_BAD_PARTIAL (-13)
-
- The PCRE_PARTIAL option was used with a compiled pattern containing
- items that are not supported for partial matching. See the pcrepartial
- documentation for details of partial matching.
-
- PCRE_ERROR_INTERNAL (-14)
-
- An unexpected internal error has occurred. This error could be caused
- by a bug in PCRE or by overwriting of the compiled pattern.
-
- PCRE_ERROR_BADCOUNT (-15)
-
- This error is given if the value of the ovecsize argument is negative.
-
-
-EXTRACTING CAPTURED SUBSTRINGS BY NUMBER
-
- int pcre_copy_substring(const char *subject, int *ovector,
- int stringcount, int stringnumber, char *buffer,
- int buffersize);
-
- int pcre_get_substring(const char *subject, int *ovector,
- int stringcount, int stringnumber,
- const char **stringptr);
-
- int pcre_get_substring_list(const char *subject,
- int *ovector, int stringcount, const char ***listptr);
-
- Captured substrings can be accessed directly by using the offsets
- returned by pcre_exec() in ovector. For convenience, the functions
- pcre_copy_substring(), pcre_get_substring(), and pcre_get_sub-
- string_list() are provided for extracting captured substrings as new,
- separate, zero-terminated strings. These functions identify substrings
- by number. The next section describes functions for extracting named
- substrings. A substring that contains a binary zero is correctly
- extracted and has a further zero added on the end, but the result is
- not, of course, a C string.
-
- The first three arguments are the same for all three of these func-
- tions: subject is the subject string that has just been successfully
- matched, ovector is a pointer to the vector of integer offsets that was
- passed to pcre_exec(), and stringcount is the number of substrings that
- were captured by the match, including the substring that matched the
- entire regular expression. This is the value returned by pcre_exec() if
- it is greater than zero. If pcre_exec() returned zero, indicating that
- it ran out of space in ovector, the value passed as stringcount should
- be the number of elements in the vector divided by three.
-
- The functions pcre_copy_substring() and pcre_get_substring() extract a
- single substring, whose number is given as stringnumber. A value of
- zero extracts the substring that matched the entire pattern, whereas
- higher values extract the captured substrings. For pcre_copy_sub-
- string(), the string is placed in buffer, whose length is given by
- buffersize, while for pcre_get_substring() a new block of memory is
- obtained via pcre_malloc, and its address is returned via stringptr.
- The yield of the function is the length of the string, not including
- the terminating zero, or one of
-
- PCRE_ERROR_NOMEMORY (-6)
-
- The buffer was too small for pcre_copy_substring(), or the attempt to
- get memory failed for pcre_get_substring().
-
- PCRE_ERROR_NOSUBSTRING (-7)
-
- There is no substring whose number is stringnumber.
-
- The pcre_get_substring_list() function extracts all available sub-
- strings and builds a list of pointers to them. All this is done in a
- single block of memory that is obtained via pcre_malloc. The address of
- the memory block is returned via listptr, which is also the start of
- the list of string pointers. The end of the list is marked by a NULL
- pointer. The yield of the function is zero if all went well, or
-
- PCRE_ERROR_NOMEMORY (-6)
-
- if the attempt to get the memory block failed.
-
- When any of these functions encounter a substring that is unset, which
- can happen when capturing subpattern number n+1 matches some part of
- the subject, but subpattern n has not been used at all, they return an
- empty string. This can be distinguished from a genuine zero-length sub-
- string by inspecting the appropriate offset in ovector, which is nega-
- tive for unset substrings.
-
- The two convenience functions pcre_free_substring() and pcre_free_sub-
- string_list() can be used to free the memory returned by a previous
- call of pcre_get_substring() or pcre_get_substring_list(), respec-
- tively. They do nothing more than call the function pointed to by
- pcre_free, which of course could be called directly from a C program.
- However, PCRE is used in some situations where it is linked via a spe-
- cial interface to another programming language which cannot use
- pcre_free directly; it is for these cases that the functions are
- provided.
-
-
-EXTRACTING CAPTURED SUBSTRINGS BY NAME
-
- int pcre_get_stringnumber(const pcre *code,
- const char *name);
-
- int pcre_copy_named_substring(const pcre *code,
- const char *subject, int *ovector,
- int stringcount, const char *stringname,
- char *buffer, int buffersize);
-
- int pcre_get_named_substring(const pcre *code,
- const char *subject, int *ovector,
- int stringcount, const char *stringname,
- const char **stringptr);
-
- To extract a substring by name, you first have to find associated num-
- ber. For example, for this pattern
-
- (a+)b(?<xxx>\d+)...
-
- the number of the subpattern called "xxx" is 2. You can find the number
- from the name by calling pcre_get_stringnumber(). The first argument is
- the compiled pattern, and the second is the name. The yield of the
- function is the subpattern number, or PCRE_ERROR_NOSUBSTRING (-7) if
- there is no subpattern of that name.
-
- Given the number, you can extract the substring directly, or use one of
- the functions described in the previous section. For convenience, there
- are also two functions that do the whole job.
-
- Most of the arguments of pcre_copy_named_substring() and
- pcre_get_named_substring() are the same as those for the similarly
- named functions that extract by number. As these are described in the
- previous section, they are not re-described here. There are just two
- differences:
-
- First, instead of a substring number, a substring name is given. Sec-
- ond, there is an extra argument, given at the start, which is a pointer
- to the compiled pattern. This is needed in order to gain access to the
- name-to-number translation table.
-
- These functions call pcre_get_stringnumber(), and if it succeeds, they
- then call pcre_copy_substring() or pcre_get_substring(), as appropri-
- ate.
-
-Last updated: 09 September 2004
-Copyright (c) 1997-2004 University of Cambridge.
------------------------------------------------------------------------------
-
-PCRE(3) PCRE(3)
-
-
-
-NAME
- PCRE - Perl-compatible regular expressions
-
-PCRE CALLOUTS
-
- int (*pcre_callout)(pcre_callout_block *);
-
- PCRE provides a feature called "callout", which is a means of temporar-
- ily passing control to the caller of PCRE in the middle of pattern
- matching. The caller of PCRE provides an external function by putting
- its entry point in the global variable pcre_callout. By default, this
- variable contains NULL, which disables all calling out.
-
- Within a regular expression, (?C) indicates the points at which the
- external function is to be called. Different callout points can be
- identified by putting a number less than 256 after the letter C. The
- default value is zero. For example, this pattern has two callout
- points:
-
- (?C1)eabc(?C2)def
-
- If the PCRE_AUTO_CALLOUT option bit is set when pcre_compile() is
- called, PCRE automatically inserts callouts, all with number 255,
- before each item in the pattern. For example, if PCRE_AUTO_CALLOUT is
- used with the pattern
-
- A(\d{2}|--)
-
- it is processed as if it were
-
- (?C255)A(?C255)((?C255)\d{2}(?C255)|(?C255)-(?C255)-(?C255))(?C255)
-
- Notice that there is a callout before and after each parenthesis and
- alternation bar. Automatic callouts can be used for tracking the
- progress of pattern matching. The pcretest command has an option that
- sets automatic callouts; when it is used, the output indicates how the
- pattern is matched. This is useful information when you are trying to
- optimize the performance of a particular pattern.
-
-
-MISSING CALLOUTS
-
- You should be aware that, because of optimizations in the way PCRE
- matches patterns, callouts sometimes do not happen. For example, if the
- pattern is
-
- ab(?C4)cd
-
- PCRE knows that any matching string must contain the letter "d". If the
- subject string is "abyz", the lack of "d" means that matching doesn't
- ever start, and the callout is never reached. However, with "abyd",
- though the result is still no match, the callout is obeyed.
-
-
-THE CALLOUT INTERFACE
-
- During matching, when PCRE reaches a callout point, the external func-
- tion defined by pcre_callout is called (if it is set). The only argu-
- ment is a pointer to a pcre_callout block. This structure contains the
- following fields:
-
- int version;
- int callout_number;
- int *offset_vector;
- const char *subject;
- int subject_length;
- int start_match;
- int current_position;
- int capture_top;
- int capture_last;
- void *callout_data;
- int pattern_position;
- int next_item_length;
-
- The version field is an integer containing the version number of the
- block format. The initial version was 0; the current version is 1. The
- version number will change again in future if additional fields are
- added, but the intention is never to remove any of the existing fields.
-
- The callout_number field contains the number of the callout, as com-
- piled into the pattern (that is, the number after ?C for manual call-
- outs, and 255 for automatically generated callouts).
-
- The offset_vector field is a pointer to the vector of offsets that was
- passed by the caller to pcre_exec(). The contents can be inspected in
- order to extract substrings that have been matched so far, in the same
- way as for extracting substrings after a match has completed.
-
- The subject and subject_length fields contain copies of the values that
- were passed to pcre_exec().
-
- The start_match field contains the offset within the subject at which
- the current match attempt started. If the pattern is not anchored, the
- callout function may be called several times from the same point in the
- pattern for different starting points in the subject.
-
- The current_position field contains the offset within the subject of
- the current match pointer.
-
- The capture_top field contains one more than the number of the highest
- numbered captured substring so far. If no substrings have been cap-
- tured, the value of capture_top is one.
-
- The capture_last field contains the number of the most recently cap-
- tured substring. If no substrings have been captured, its value is -1.
-
- The callout_data field contains a value that is passed to pcre_exec()
- by the caller specifically so that it can be passed back in callouts.
- It is passed in the pcre_callout field of the pcre_extra data struc-
- ture. If no such data was passed, the value of callout_data in a
- pcre_callout block is NULL. There is a description of the pcre_extra
- structure in the pcreapi documentation.
-
- The pattern_position field is present from version 1 of the pcre_call-
- out structure. It contains the offset to the next item to be matched in
- the pattern string.
-
- The next_item_length field is present from version 1 of the pcre_call-
- out structure. It contains the length of the next item to be matched in
- the pattern string. When the callout immediately precedes an alterna-
- tion bar, a closing parenthesis, or the end of the pattern, the length
- is zero. When the callout precedes an opening parenthesis, the length
- is that of the entire subpattern.
-
- The pattern_position and next_item_length fields are intended to help
- in distinguishing between different automatic callouts, which all have
- the same callout number. However, they are set for all callouts.
-
-
-RETURN VALUES
-
- The external callout function returns an integer to PCRE. If the value
- is zero, matching proceeds as normal. If the value is greater than
- zero, matching fails at the current point, but backtracking to test
- other matching possibilities goes ahead, just as if a lookahead asser-
- tion had failed. If the value is less than zero, the match is aban-
- doned, and pcre_exec() returns the negative value.
-
- Negative values should normally be chosen from the set of
- PCRE_ERROR_xxx values. In particular, PCRE_ERROR_NOMATCH forces a stan-
- dard "no match" failure. The error number PCRE_ERROR_CALLOUT is
- reserved for use by callout functions; it will never be used by PCRE
- itself.
-
-Last updated: 09 September 2004
-Copyright (c) 1997-2004 University of Cambridge.
------------------------------------------------------------------------------
-
-PCRE(3) PCRE(3)
-
-
-
-NAME
- PCRE - Perl-compatible regular expressions
-
-DIFFERENCES BETWEEN PCRE AND PERL
-
- This document describes the differences in the ways that PCRE and Perl
- handle regular expressions. The differences described here are with
- respect to Perl 5.8.
-
- 1. PCRE does not have full UTF-8 support. Details of what it does have
- are given in the section on UTF-8 support in the main pcre page.
-
- 2. PCRE does not allow repeat quantifiers on lookahead assertions. Perl
- permits them, but they do not mean what you might think. For example,
- (?!a){3} does not assert that the next three characters are not "a". It
- just asserts that the next character is not "a" three times.
-
- 3. Capturing subpatterns that occur inside negative lookahead asser-
- tions are counted, but their entries in the offsets vector are never
- set. Perl sets its numerical variables from any such patterns that are
- matched before the assertion fails to match something (thereby succeed-
- ing), but only if the negative lookahead assertion contains just one
- branch.
-
- 4. Though binary zero characters are supported in the subject string,
- they are not allowed in a pattern string because it is passed as a nor-
- mal C string, terminated by zero. The escape sequence \0 can be used in
- the pattern to represent a binary zero.
-
- 5. The following Perl escape sequences are not supported: \l, \u, \L,
- \U, and \N. In fact these are implemented by Perl's general string-han-
- dling and are not part of its pattern matching engine. If any of these
- are encountered by PCRE, an error is generated.
-
- 6. The Perl escape sequences \p, \P, and \X are supported only if PCRE
- is built with Unicode character property support. The properties that
- can be tested with \p and \P are limited to the general category prop-
- erties such as Lu and Nd.
-
- 7. PCRE does support the \Q...\E escape for quoting substrings. Charac-
- ters in between are treated as literals. This is slightly different
- from Perl in that $ and @ are also handled as literals inside the
- quotes. In Perl, they cause variable interpolation (but of course PCRE
- does not have variables). Note the following examples:
-
- Pattern PCRE matches Perl matches
-
- \Qabc$xyz\E abc$xyz abc followed by the
- contents of $xyz
- \Qabc\$xyz\E abc\$xyz abc\$xyz
- \Qabc\E\$\Qxyz\E abc$xyz abc$xyz
-
- The \Q...\E sequence is recognized both inside and outside character
- classes.
-
- 8. Fairly obviously, PCRE does not support the (?{code}) and (?p{code})
- constructions. However, there is support for recursive patterns using
- the non-Perl items (?R), (?number), and (?P>name). Also, the PCRE
- "callout" feature allows an external function to be called during pat-
- tern matching. See the pcrecallout documentation for details.
-
- 9. There are some differences that are concerned with the settings of
- captured strings when part of a pattern is repeated. For example,
- matching "aba" against the pattern /^(a(b)?)+$/ in Perl leaves $2
- unset, but in PCRE it is set to "b".
-
- 10. PCRE provides some extensions to the Perl regular expression facil-
- ities:
-
- (a) Although lookbehind assertions must match fixed length strings,
- each alternative branch of a lookbehind assertion can match a different
- length of string. Perl requires them all to have the same length.
-
- (b) If PCRE_DOLLAR_ENDONLY is set and PCRE_MULTILINE is not set, the $
- meta-character matches only at the very end of the string.
-
- (c) If PCRE_EXTRA is set, a backslash followed by a letter with no spe-
- cial meaning is faulted.
-
- (d) If PCRE_UNGREEDY is set, the greediness of the repetition quanti-
- fiers is inverted, that is, by default they are not greedy, but if fol-
- lowed by a question mark they are.
-
- (e) PCRE_ANCHORED can be used at matching time to force a pattern to be
- tried only at the first matching position in the subject string.
-
- (f) The PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, and PCRE_NO_AUTO_CAP-
- TURE options for pcre_exec() have no Perl equivalents.
-
- (g) The (?R), (?number), and (?P>name) constructs allows for recursive
- pattern matching (Perl can do this using the (?p{code}) construct,
- which PCRE cannot support.)
-
- (h) PCRE supports named capturing substrings, using the Python syntax.
-
- (i) PCRE supports the possessive quantifier "++" syntax, taken from
- Sun's Java package.
-
- (j) The (R) condition, for testing recursion, is a PCRE extension.
-
- (k) The callout facility is PCRE-specific.
-
- (l) The partial matching facility is PCRE-specific.
-
- (m) Patterns compiled by PCRE can be saved and re-used at a later time,
- even on different hosts that have the other endianness.
-
-Last updated: 09 September 2004
-Copyright (c) 1997-2004 University of Cambridge.
------------------------------------------------------------------------------
-
-PCRE(3) PCRE(3)
-
-
-
-NAME
- PCRE - Perl-compatible regular expressions
-
-PCRE REGULAR EXPRESSION DETAILS
-
- The syntax and semantics of the regular expressions supported by PCRE
- are described below. Regular expressions are also described in the Perl
- documentation and in a number of books, some of which have copious
- examples. Jeffrey Friedl's "Mastering Regular Expressions", published
- by O'Reilly, covers regular expressions in great detail. This descrip-
- tion of PCRE's regular expressions is intended as reference material.
-
- The original operation of PCRE was on strings of one-byte characters.
- However, there is now also support for UTF-8 character strings. To use
- this, you must build PCRE to include UTF-8 support, and then call
- pcre_compile() with the PCRE_UTF8 option. How this affects pattern
- matching is mentioned in several places below. There is also a summary
- of UTF-8 features in the section on UTF-8 support in the main pcre
- page.
-
- A regular expression is a pattern that is matched against a subject
- string from left to right. Most characters stand for themselves in a
- pattern, and match the corresponding characters in the subject. As a
- trivial example, the pattern
-
- The quick brown fox
-
- matches a portion of a subject string that is identical to itself. The
- power of regular expressions comes from the ability to include alterna-
- tives and repetitions in the pattern. These are encoded in the pattern
- by the use of metacharacters, which do not stand for themselves but
- instead are interpreted in some special way.
-
- There are two different sets of metacharacters: those that are recog-
- nized anywhere in the pattern except within square brackets, and those
- that are recognized in square brackets. Outside square brackets, the
- metacharacters are as follows:
-
- \ general escape character with several uses
- ^ assert start of string (or line, in multiline mode)
- $ assert end of string (or line, in multiline mode)
- . match any character except newline (by default)
- [ start character class definition
- | start of alternative branch
- ( start subpattern
- ) end subpattern
- ? extends the meaning of (
- also 0 or 1 quantifier
- also quantifier minimizer
- * 0 or more quantifier
- + 1 or more quantifier
- also "possessive quantifier"
- { start min/max quantifier
-
- Part of a pattern that is in square brackets is called a "character
- class". In a character class the only metacharacters are:
-
- \ general escape character
- ^ negate the class, but only if the first character
- - indicates character range
- [ POSIX character class (only if followed by POSIX
- syntax)
- ] terminates the character class
-
- The following sections describe the use of each of the metacharacters.
-
-
-BACKSLASH
-
- The backslash character has several uses. Firstly, if it is followed by
- a non-alphanumeric character, it takes away any special meaning that
- character may have. This use of backslash as an escape character
- applies both inside and outside character classes.
-
- For example, if you want to match a * character, you write \* in the
- pattern. This escaping action applies whether or not the following
- character would otherwise be interpreted as a metacharacter, so it is
- always safe to precede a non-alphanumeric with backslash to specify
- that it stands for itself. In particular, if you want to match a back-
- slash, you write \\.
-
- If a pattern is compiled with the PCRE_EXTENDED option, whitespace in
- the pattern (other than in a character class) and characters between a
- # outside a character class and the next newline character are ignored.
- An escaping backslash can be used to include a whitespace or # charac-
- ter as part of the pattern.
-
- If you want to remove the special meaning from a sequence of charac-
- ters, you can do so by putting them between \Q and \E. This is differ-
- ent from Perl in that $ and @ are handled as literals in \Q...\E
- sequences in PCRE, whereas in Perl, $ and @ cause variable interpola-
- tion. Note the following examples:
-
- Pattern PCRE matches Perl matches
-
- \Qabc$xyz\E abc$xyz abc followed by the
- contents of $xyz
- \Qabc\$xyz\E abc\$xyz abc\$xyz
- \Qabc\E\$\Qxyz\E abc$xyz abc$xyz
-
- The \Q...\E sequence is recognized both inside and outside character
- classes.
-
- Non-printing characters
-
- A second use of backslash provides a way of encoding non-printing char-
- acters in patterns in a visible manner. There is no restriction on the
- appearance of non-printing characters, apart from the binary zero that
- terminates a pattern, but when a pattern is being prepared by text
- editing, it is usually easier to use one of the following escape
- sequences than the binary character it represents:
-
- \a alarm, that is, the BEL character (hex 07)
- \cx "control-x", where x is any character
- \e escape (hex 1B)
- \f formfeed (hex 0C)
- \n newline (hex 0A)
- \r carriage return (hex 0D)
- \t tab (hex 09)
- \ddd character with octal code ddd, or backreference
- \xhh character with hex code hh
- \x{hhh..} character with hex code hhh... (UTF-8 mode only)
-
- The precise effect of \cx is as follows: if x is a lower case letter,
- it is converted to upper case. Then bit 6 of the character (hex 40) is
- inverted. Thus \cz becomes hex 1A, but \c{ becomes hex 3B, while \c;
- becomes hex 7B.
-
- After \x, from zero to two hexadecimal digits are read (letters can be
- in upper or lower case). In UTF-8 mode, any number of hexadecimal dig-
- its may appear between \x{ and }, but the value of the character code
- must be less than 2**31 (that is, the maximum hexadecimal value is
- 7FFFFFFF). If characters other than hexadecimal digits appear between
- \x{ and }, or if there is no terminating }, this form of escape is not
- recognized. Instead, the initial \x will be interpreted as a basic hex-
- adecimal escape, with no following digits, giving a character whose
- value is zero.
-
- Characters whose value is less than 256 can be defined by either of the
- two syntaxes for \x when PCRE is in UTF-8 mode. There is no difference
- in the way they are handled. For example, \xdc is exactly the same as
- \x{dc}.
-
- After \0 up to two further octal digits are read. In both cases, if
- there are fewer than two digits, just those that are present are used.
- Thus the sequence \0\x\07 specifies two binary zeros followed by a BEL
- character (code value 7). Make sure you supply two digits after the
- initial zero if the pattern character that follows is itself an octal
- digit.
-
- The handling of a backslash followed by a digit other than 0 is compli-
- cated. Outside a character class, PCRE reads it and any following dig-
- its as a decimal number. If the number is less than 10, or if there
- have been at least that many previous capturing left parentheses in the
- expression, the entire sequence is taken as a back reference. A
- description of how this works is given later, following the discussion
- of parenthesized subpatterns.
-
- Inside a character class, or if the decimal number is greater than 9
- and there have not been that many capturing subpatterns, PCRE re-reads
- up to three octal digits following the backslash, and generates a sin-
- gle byte from the least significant 8 bits of the value. Any subsequent
- digits stand for themselves. For example:
-
- \040 is another way of writing a space
- \40 is the same, provided there are fewer than 40
- previous capturing subpatterns
- \7 is always a back reference
- \11 might be a back reference, or another way of
- writing a tab
- \011 is always a tab
- \0113 is a tab followed by the character "3"
- \113 might be a back reference, otherwise the
- character with octal code 113
- \377 might be a back reference, otherwise
- the byte consisting entirely of 1 bits
- \81 is either a back reference, or a binary zero
- followed by the two characters "8" and "1"
-
- Note that octal values of 100 or greater must not be introduced by a
- leading zero, because no more than three octal digits are ever read.
-
- All the sequences that define a single byte value or a single UTF-8
- character (in UTF-8 mode) can be used both inside and outside character
- classes. In addition, inside a character class, the sequence \b is
- interpreted as the backspace character (hex 08), and the sequence \X is
- interpreted as the character "X". Outside a character class, these
- sequences have different meanings (see below).
-
- Generic character types
-
- The third use of backslash is for specifying generic character types.
- The following are always recognized:
-
- \d any decimal digit
- \D any character that is not a decimal digit
- \s any whitespace character
- \S any character that is not a whitespace character
- \w any "word" character
- \W any "non-word" character
-
- Each pair of escape sequences partitions the complete set of characters
- into two disjoint sets. Any given character matches one, and only one,
- of each pair.
-
- These character type sequences can appear both inside and outside char-
- acter classes. They each match one character of the appropriate type.
- If the current matching point is at the end of the subject string, all
- of them fail, since there is no character to match.
-
- For compatibility with Perl, \s does not match the VT character (code
- 11). This makes it different from the the POSIX "space" class. The \s
- characters are HT (9), LF (10), FF (12), CR (13), and space (32).
-
- A "word" character is an underscore or any character less than 256 that
- is a letter or digit. The definition of letters and digits is con-
- trolled by PCRE's low-valued character tables, and may vary if locale-
- specific matching is taking place (see "Locale support" in the pcreapi
- page). For example, in the "fr_FR" (French) locale, some character
- codes greater than 128 are used for accented letters, and these are
- matched by \w.
-
- In UTF-8 mode, characters with values greater than 128 never match \d,
- \s, or \w, and always match \D, \S, and \W. This is true even when Uni-
- code character property support is available.
-
- Unicode character properties
-
- When PCRE is built with Unicode character property support, three addi-
- tional escape sequences to match generic character types are available
- when UTF-8 mode is selected. They are:
-
- \p{xx} a character with the xx property
- \P{xx} a character without the xx property
- \X an extended Unicode sequence
-
- The property names represented by xx above are limited to the Unicode
- general category properties. Each character has exactly one such prop-
- erty, specified by a two-letter abbreviation. For compatibility with
- Perl, negation can be specified by including a circumflex between the
- opening brace and the property name. For example, \p{^Lu} is the same
- as \P{Lu}.
-
- If only one letter is specified with \p or \P, it includes all the
- properties that start with that letter. In this case, in the absence of
- negation, the curly brackets in the escape sequence are optional; these
- two examples have the same effect:
-
- \p{L}
- \pL
-
- The following property codes are supported:
-
- C Other
- Cc Control
- Cf Format
- Cn Unassigned
- Co Private use
- Cs Surrogate
-
- L Letter
- Ll Lower case letter
- Lm Modifier letter
- Lo Other letter
- Lt Title case letter
- Lu Upper case letter
-
- M Mark
- Mc Spacing mark
- Me Enclosing mark
- Mn Non-spacing mark
-
- N Number
- Nd Decimal number
- Nl Letter number
- No Other number
-
- P Punctuation
- Pc Connector punctuation
- Pd Dash punctuation
- Pe Close punctuation
- Pf Final punctuation
- Pi Initial punctuation
- Po Other punctuation
- Ps Open punctuation
-
- S Symbol
- Sc Currency symbol
- Sk Modifier symbol
- Sm Mathematical symbol
- So Other symbol
-
- Z Separator
- Zl Line separator
- Zp Paragraph separator
- Zs Space separator
-
- Extended properties such as "Greek" or "InMusicalSymbols" are not sup-
- ported by PCRE.
-
- Specifying caseless matching does not affect these escape sequences.
- For example, \p{Lu} always matches only upper case letters.
-
- The \X escape matches any number of Unicode characters that form an
- extended Unicode sequence. \X is equivalent to
-
- (?>\PM\pM*)
-
- That is, it matches a character without the "mark" property, followed
- by zero or more characters with the "mark" property, and treats the
- sequence as an atomic group (see below). Characters with the "mark"
- property are typically accents that affect the preceding character.
-
- Matching characters by Unicode property is not fast, because PCRE has
- to search 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.
-
- Simple assertions
-
- The fourth use of backslash is for certain simple assertions. An asser-
- tion specifies a condition that has to be met at a particular point in
- a match, without consuming any characters from the subject string. The
- use of subpatterns for more complicated assertions is described below.
- The backslashed assertions are:
-
- \b matches at a word boundary
- \B matches when not at a word boundary
- \A matches at start of subject
- \Z matches at end of subject or before newline at end
- \z matches at end of subject
- \G matches at first matching position in subject
-
- These assertions may not appear in character classes (but note that \b
- has a different meaning, namely the backspace character, inside a char-
- acter class).
-
- A word boundary is a position in the subject string where the current
- character and the previous character do not both match \w or \W (i.e.
- one matches \w and the other matches \W), or the start or end of the
- string if the first or last character matches \w, respectively.
-
- The \A, \Z, and \z assertions differ from the traditional circumflex
- and dollar (described in the next section) in that they only ever match
- at the very start and end of the subject string, whatever options are
- set. Thus, they are independent of multiline mode. These three asser-
- tions are not affected by the PCRE_NOTBOL or PCRE_NOTEOL options, which
- affect only the behaviour of the circumflex and dollar metacharacters.
- However, if the startoffset argument of pcre_exec() is non-zero, indi-
- cating that matching is to start at a point other than the beginning of
- the subject, \A can never match. The difference between \Z and \z is
- that \Z matches before a newline that is the last character of the
- string as well as at the end of the string, whereas \z matches only at
- the end.
-
- The \G assertion is true only when the current matching position is at
- the start point of the match, as specified by the startoffset argument
- of pcre_exec(). It differs from \A when the value of startoffset is
- non-zero. By calling pcre_exec() multiple times with appropriate argu-
- ments, you can mimic Perl's /g option, and it is in this kind of imple-
- mentation where \G can be useful.
-
- Note, however, that PCRE's interpretation of \G, as the start of the
- current match, is subtly different from Perl's, which defines it as the
- end of the previous match. In Perl, these can be different when the
- previously matched string was empty. Because PCRE does just one match
- at a time, it cannot reproduce this behaviour.
-
- If all the alternatives of a pattern begin with \G, the expression is
- anchored to the starting match position, and the "anchored" flag is set
- in the compiled regular expression.
-
-
-CIRCUMFLEX AND DOLLAR
-
- Outside a character class, in the default matching mode, the circumflex
- character is an assertion that is true only if the current matching
- point is at the start of the subject string. If the startoffset argu-
- ment of pcre_exec() is non-zero, circumflex can never match if the
- PCRE_MULTILINE option is unset. Inside a character class, circumflex
- has an entirely different meaning (see below).
-
- Circumflex need not be the first character of the pattern if a number
- of alternatives are involved, but it should be the first thing in each
- alternative in which it appears if the pattern is ever to match that
- branch. If all possible alternatives start with a circumflex, that is,
- if the pattern is constrained to match only at the start of the sub-
- ject, it is said to be an "anchored" pattern. (There are also other
- constructs that can cause a pattern to be anchored.)
-
- A dollar character is an assertion that is true only if the current
- matching point is at the end of the subject string, or immediately
- before a newline character that is the last character in the string (by
- default). Dollar need not be the last character of the pattern if a
- number of alternatives are involved, but it should be the last item in
- any branch in which it appears. Dollar has no special meaning in a
- character class.
-
- The meaning of dollar can be changed so that it matches only at the
- very end of the string, by setting the PCRE_DOLLAR_ENDONLY option at
- compile time. This does not affect the \Z assertion.
-
- The meanings of the circumflex and dollar characters are changed if the
- PCRE_MULTILINE option is set. When this is the case, they match immedi-
- ately after and immediately before an internal newline character,
- respectively, in addition to matching at the start and end of the sub-
- ject string. For example, the pattern /^abc$/ matches the subject
- string "def\nabc" (where \n represents a newline character) in multi-
- line mode, but not otherwise. Consequently, patterns that are anchored
- in single line mode because all branches start with ^ are not anchored
- in multiline mode, and a match for circumflex is possible when the
- startoffset argument of pcre_exec() is non-zero. The PCRE_DOL-
- LAR_ENDONLY option is ignored if PCRE_MULTILINE is set.
-
- Note that the sequences \A, \Z, and \z can be used to match the start
- and end of the subject in both modes, and if all branches of a pattern
- start with \A it is always anchored, whether PCRE_MULTILINE is set or
- not.
-
-
-FULL STOP (PERIOD, DOT)
-
- Outside a character class, a dot in the pattern matches any one charac-
- ter in the subject, including a non-printing character, but not (by
- default) newline. In UTF-8 mode, a dot matches any UTF-8 character,
- which might be more than one byte long, except (by default) newline. If
- the PCRE_DOTALL option is set, dots match newlines as well. The han-
- dling of dot is entirely independent of the handling of circumflex and
- dollar, the only relationship being that they both involve newline
- characters. Dot has no special meaning in a character class.
-
-
-MATCHING A SINGLE BYTE
-
- Outside a character class, the escape sequence \C matches any one byte,
- both in and out of UTF-8 mode. Unlike a dot, it can match a newline.
- The feature is provided in Perl in order to match individual bytes in
- UTF-8 mode. Because it breaks up UTF-8 characters into individual
- bytes, what remains in the string may be a malformed UTF-8 string. For
- this reason, the \C escape sequence is best avoided.
-
- PCRE does not allow \C to appear in lookbehind assertions (described
- below), because in UTF-8 mode this would make it impossible to calcu-
- late the length of the lookbehind.
-
-
-SQUARE BRACKETS AND CHARACTER CLASSES
-
- An opening square bracket introduces a character class, terminated by a
- closing square bracket. A closing square bracket on its own is not spe-
- cial. If a closing square bracket is required as a member of the class,
- it should be the first data character in the class (after an initial
- circumflex, if present) or escaped with a backslash.
-
- A character class matches a single character in the subject. In UTF-8
- mode, the character may occupy more than one byte. A matched character
- must be in the set of characters defined by the class, unless the first
- character in the class definition is a circumflex, in which case the
- subject character must not be in the set defined by the class. If a
- circumflex is actually required as a member of the class, ensure it is
- not the first character, or escape it with a backslash.
-
- For example, the character class [aeiou] matches any lower case vowel,
- while [^aeiou] matches any character that is not a lower case vowel.
- Note that a circumflex is just a convenient notation for specifying the
- characters that are in the class by enumerating those that are not. A
- class that starts with a circumflex is not an assertion: it still con-
- sumes a character from the subject string, and therefore it fails if
- the current pointer is at the end of the string.
-
- In UTF-8 mode, characters with values greater than 255 can be included
- in a class as a literal string of bytes, or by using the \x{ escaping
- mechanism.
-
- When caseless matching is set, any letters in a class represent both
- their upper case and lower case versions, so for example, a caseless
- [aeiou] matches "A" as well as "a", and a caseless [^aeiou] does not
- match "A", whereas a caseful version would. When running 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.
-
- The newline character is never treated in any special way in character
- classes, whatever the setting of the PCRE_DOTALL or PCRE_MULTILINE
- options is. A class such as [^a] will always match a newline.
-
- The minus (hyphen) character can be used to specify a range of charac-
- ters in a character class. For example, [d-m] matches any letter
- between d and m, inclusive. If a minus character is required in a
- class, it must be escaped with a backslash or appear in a position
- where it cannot be interpreted as indicating a range, typically as the
- first or last character in the class.
-
- It is not possible to have the literal character "]" as the end charac-
- ter of a range. A pattern such as [W-]46] is interpreted as a class of
- two characters ("W" and "-") followed by a literal string "46]", so it
- would match "W46]" or "-46]". However, if the "]" is escaped with a
- backslash it is interpreted as the end of range, so [W-\]46] is inter-
- preted as a class containing a range followed by two other characters.
- The octal or hexadecimal representation of "]" can also be used to end
- a range.
-
- Ranges operate in the collating sequence of character values. They can
- also be used for characters specified numerically, for example
- [\000-\037]. In UTF-8 mode, ranges can include characters whose values
- are greater than 255, for example [\x{100}-\x{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 [][\\^_`wxyzabc], matched caselessly, and in non-UTF-8 mode, if
- character tables for the "fr_FR" locale are in use, [\xc8-\xcb] 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.
-
- The character types \d, \D, \p, \P, \s, \S, \w, and \W may also appear
- in a character class, and add the characters that they match to the
- class. For example, [\dABCDEF] matches any hexadecimal digit. A circum-
- flex can conveniently be used with the upper case character types to
- specify a more restricted set of characters than the matching lower
- case type. For example, the class [^\W_] matches any letter or digit,
- but not underscore.
-
- The only metacharacters that are recognized in character classes are
- backslash, hyphen (only where it can be interpreted as specifying a
- range), circumflex (only at the start), opening square bracket (only
- when it can be interpreted as introducing a POSIX class name - see the
- next section), and the terminating closing square bracket. However,
- escaping other non-alphanumeric characters does no harm.
-
-
-POSIX CHARACTER CLASSES
-
- Perl supports the POSIX notation for character classes. This uses names
- enclosed by [: and :] within the enclosing square brackets. PCRE also
- supports this notation. For example,
-
- [01[:alpha:]%]
-
- matches "0", "1", any alphabetic character, or "%". The supported class
- names are
-
- alnum letters and digits
- alpha letters
- ascii character codes 0 - 127
- blank space or tab only
- cntrl control characters
- digit decimal digits (same as \d)
- graph printing characters, excluding space
- lower lower case letters
- print printing characters, including space
- punct printing characters, excluding letters and digits
- space white space (not quite the same as \s)
- upper upper case letters
- word "word" characters (same as \w)
- xdigit hexadecimal digits
-
- The "space" characters are HT (9), LF (10), VT (11), FF (12), CR (13),
- and space (32). Notice that this list includes the VT character (code
- 11). This makes "space" different to \s, which does not include VT (for
- Perl compatibility).
-
- The name "word" is a Perl extension, and "blank" is a GNU extension
- from Perl 5.8. Another Perl extension is negation, which is indicated
- by a ^ character after the colon. For example,
-
- [12[:^digit:]]
-
- matches "1", "2", or any non-digit. PCRE (and Perl) also recognize the
- POSIX syntax [.ch.] and [=ch=] where "ch" is a "collating element", but
- these are not supported, and an error is given if they are encountered.
-
- In UTF-8 mode, characters with values greater than 128 do not match any
- of the POSIX character classes.
-
-
-VERTICAL BAR
-
- Vertical bar characters are used to separate alternative patterns. For
- example, the pattern
-
- gilbert|sullivan
-
- matches either "gilbert" or "sullivan". Any number of alternatives may
- appear, and an empty alternative is permitted (matching the empty
- string). The matching process tries each alternative in turn, from
- left to right, and the first one that succeeds is used. If the alterna-
- tives are within a subpattern (defined below), "succeeds" means match-
- ing the rest of the main pattern as well as the alternative in the sub-
- pattern.
-
-
-INTERNAL OPTION SETTING
-
- The settings of the PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, and
- PCRE_EXTENDED options can be changed from within the pattern by a
- sequence of Perl option letters enclosed between "(?" and ")". The
- option letters are
-
- i for PCRE_CASELESS
- m for PCRE_MULTILINE
- s for PCRE_DOTALL
- x for PCRE_EXTENDED
-
- For example, (?im) sets caseless, multiline matching. It is also possi-
- ble to unset these options by preceding the letter with a hyphen, and a
- combined setting and unsetting such as (?im-sx), which sets PCRE_CASE-
- LESS and PCRE_MULTILINE while unsetting PCRE_DOTALL and PCRE_EXTENDED,
- is also permitted. If a letter appears both before and after the
- hyphen, the option is unset.
-
- When an option change occurs at top level (that is, not inside subpat-
- tern parentheses), the change applies to the remainder of the pattern
- that follows. If the change is placed right at the start of a pattern,
- PCRE extracts it into the global options (and it will therefore show up
- in data extracted by the pcre_fullinfo() function).
-
- An option change within a subpattern affects only that part of the cur-
- rent pattern that follows it, so
-
- (a(?i)b)c
-
- matches abc and aBc and no other strings (assuming PCRE_CASELESS is not
- used). By this means, options can be made to have different settings
- in different parts of the pattern. Any changes made in one alternative
- do carry on into subsequent branches within the same subpattern. For
- example,
-
- (a(?i)b|c)
-
- matches "ab", "aB", "c", and "C", even though when matching "C" the
- first branch is abandoned before the option setting. This is because
- the effects of option settings happen at compile time. There would be
- some very weird behaviour otherwise.
-
- The PCRE-specific options PCRE_UNGREEDY and PCRE_EXTRA can be changed
- in the same way as the Perl-compatible options by using the characters
- U and X respectively. The (?X) flag setting is special in that it must
- always occur earlier in the pattern than any of the additional features
- it turns on, even when it is at top level. It is best to put it at the
- start.
-
-
-SUBPATTERNS
-
- Subpatterns are delimited by parentheses (round brackets), which can be
- nested. Turning part of a pattern into a subpattern does two things:
-
- 1. It localizes a set of alternatives. For example, the pattern
-
- cat(aract|erpillar|)
-
- matches one of the words "cat", "cataract", or "caterpillar". Without
- the parentheses, it would match "cataract", "erpillar" or the empty
- string.
-
- 2. It sets up the subpattern as a capturing subpattern. This means
- that, when the whole pattern matches, that portion of the subject
- string that matched the subpattern is passed back to the caller via the
- ovector argument of pcre_exec(). Opening parentheses are counted from
- left to right (starting from 1) to obtain numbers for the capturing
- subpatterns.
-
- For example, if the string "the red king" is matched against the pat-
- tern
-
- the ((red|white) (king|queen))
-
- the captured substrings are "red king", "red", and "king", and are num-
- bered 1, 2, and 3, respectively.
-
- The fact that plain parentheses fulfil two functions is not always
- helpful. There are often times when a grouping subpattern is required
- without a capturing requirement. If an opening parenthesis is followed
- by a question mark and a colon, the subpattern does not do any captur-
- ing, and is not counted when computing the number of any subsequent
- capturing subpatterns. For example, if the string "the white queen" is
- matched against the pattern
-
- the ((?:red|white) (king|queen))
-
- the captured substrings are "white queen" and "queen", and are numbered
- 1 and 2. The maximum number of capturing subpatterns is 65535, and the
- maximum depth of nesting of all subpatterns, both capturing and non-
- capturing, is 200.
-
- As a convenient shorthand, if any option settings are required at the
- start of a non-capturing subpattern, the option letters may appear
- between the "?" and the ":". Thus the two patterns
-
- (?i:saturday|sunday)
- (?:(?i)saturday|sunday)
-
- match exactly the same set of strings. Because alternative branches are
- tried from left to right, and options are not reset until the end of
- the subpattern is reached, an option setting in one branch does affect
- subsequent branches, so the above patterns match "SUNDAY" as well as
- "Saturday".
-
-
-NAMED SUBPATTERNS
-
- Identifying capturing parentheses by number is simple, but it can be
- very hard to keep track of the numbers in complicated regular expres-
- sions. Furthermore, if an expression is modified, the numbers may
- change. To help with this difficulty, PCRE supports the naming of sub-
- patterns, something that Perl does not provide. The Python syntax
- (?P<name>...) is used. Names consist of alphanumeric characters and
- underscores, and must be unique within a pattern.
-
- Named capturing parentheses are still allocated numbers as well as
- names. The PCRE API provides function calls for extracting the name-to-
- number translation table from a compiled pattern. There is also a con-
- venience function for extracting a captured substring by name. For fur-
- ther details see the pcreapi documentation.
-
-
-REPETITION
-
- Repetition is specified by quantifiers, which can follow any of the
- following items:
-
- a literal data character
- the . metacharacter
- the \C escape sequence
- the \X escape sequence (in UTF-8 mode with Unicode properties)
- an escape such as \d that matches a single character
- a character class
- a back reference (see next section)
- a parenthesized subpattern (unless it is an assertion)
-
- The general repetition quantifier specifies a minimum and maximum num-
- ber of permitted matches, by giving the two numbers in curly brackets
- (braces), separated by a comma. The numbers must be less than 65536,
- and the first must be less than or equal to the second. For example:
-
- z{2,4}
-
- matches "zz", "zzz", or "zzzz". A closing brace on its own is not a
- special character. If the second number is omitted, but the comma is
- present, there is no upper limit; if the second number and the comma
- are both omitted, the quantifier specifies an exact number of required
- matches. Thus
-
- [aeiou]{3,}
-
- matches at least 3 successive vowels, but may match many more, while
-
- \d{8}
-
- matches exactly 8 digits. An opening curly bracket that appears in a
- position where a quantifier is not allowed, or one that does not match
- the syntax of a quantifier, is taken as a literal character. For exam-
- ple, {,6} is not a quantifier, but a literal string of four characters.
-
- In UTF-8 mode, quantifiers apply to UTF-8 characters rather than to
- individual bytes. Thus, for example, \x{100}{2} matches two UTF-8 char-
- acters, each of which is represented by a two-byte sequence. Similarly,
- when Unicode property support is available, \X{3} matches three Unicode
- extended sequences, each of which may be several bytes long (and they
- may be of different lengths).
-
- The quantifier {0} is permitted, causing the expression to behave as if
- the previous item and the quantifier were not present.
-
- For convenience (and historical compatibility) the three most common
- quantifiers have single-character abbreviations:
-
- * is equivalent to {0,}
- + is equivalent to {1,}
- ? is equivalent to {0,1}
-
- It is possible to construct infinite loops by following a subpattern
- that can match no characters with a quantifier that has no upper limit,
- for example:
-
- (a?)*
-
- Earlier versions of Perl and PCRE used to give an error at compile time
- for such patterns. However, because there are cases where this can be
- useful, such patterns are now accepted, but if any repetition of the
- subpattern does in fact match no characters, the loop is forcibly bro-
- ken.
-
- By default, the quantifiers are "greedy", that is, they match as much
- as possible (up to the maximum number of permitted times), without
- causing the rest of the pattern to fail. The classic example of where
- this gives problems is in trying to match comments in C programs. These
- appear between /* and */ and within the comment, individual * and /
- characters may appear. An attempt to match C comments by applying the
- pattern
-
- /\*.*\*/
-
- to the string
-
- /* first comment */ not comment /* second comment */
-
- fails, because it matches the entire string owing to the greediness of
- the .* item.
-
- However, if a quantifier is followed by a question mark, it ceases to
- be greedy, and instead matches the minimum number of times possible, so
- the pattern
-
- /\*.*?\*/
-
- does the right thing with the C comments. The meaning of the various
- quantifiers is not otherwise changed, just the preferred number of
- matches. Do not confuse this use of question mark with its use as a
- quantifier in its own right. Because it has two uses, it can sometimes
- appear doubled, as in
-
- \d??\d
-
- which matches one digit by preference, but can match two if that is the
- only way the rest of the pattern matches.
-
- If the PCRE_UNGREEDY option is set (an option which is not available in
- Perl), the quantifiers are not greedy by default, but individual ones
- can be made greedy by following them with a question mark. In other
- words, it inverts the default behaviour.
-
- When a parenthesized subpattern is quantified with a minimum repeat
- count that is greater than 1 or with a limited maximum, more memory is
- required for the compiled pattern, in proportion to the size of the
- minimum or maximum.
-
- If a pattern starts with .* or .{0,} and the PCRE_DOTALL option (equiv-
- alent to Perl's /s) is set, thus allowing the . to match newlines, the
- pattern is implicitly anchored, because whatever follows will be tried
- against every character position in the subject string, so there is no
- point in retrying the overall match at any position after the first.
- PCRE normally treats such a pattern as though it were preceded by \A.
-
- In cases where it is known that the subject string contains no new-
- lines, it is worth setting PCRE_DOTALL in order to obtain this opti-
- mization, or alternatively using ^ to indicate anchoring explicitly.
-
- However, there is one situation where the optimization cannot be used.
- When .* is inside capturing parentheses that are the subject of a
- backreference elsewhere in the pattern, a match at the start may fail,
- and a later one succeed. Consider, for example:
-
- (.*)abc\1
-
- If the subject is "xyz123abc123" the match point is the fourth charac-
- ter. For this reason, such a pattern is not implicitly anchored.
-
- When a capturing subpattern is repeated, the value captured is the sub-
- string that matched the final iteration. For example, after
-
- (tweedle[dume]{3}\s*)+
-
- has matched "tweedledum tweedledee" the value of the captured substring
- is "tweedledee". However, if there are nested capturing subpatterns,
- the corresponding captured values may have been set in previous itera-
- tions. For example, after
-
- /(a|(b))+/
-
- matches "aba" the value of the second captured substring is "b".
-
-
-ATOMIC GROUPING AND POSSESSIVE QUANTIFIERS
-
- With both maximizing and minimizing repetition, failure of what follows
- normally causes the repeated item to be re-evaluated to see if a dif-
- ferent number of repeats allows the rest of the pattern to match. Some-
- times it is useful to prevent this, either to change the nature of the
- match, or to cause it fail earlier than it otherwise might, when the
- author of the pattern knows there is no point in carrying on.
-
- Consider, for example, the pattern \d+foo when applied to the subject
- line
-
- 123456bar
-
- After matching all 6 digits and then failing to match "foo", the normal
- action of the matcher is to try again with only 5 digits matching the
- \d+ item, and then with 4, and so on, before ultimately failing.
- "Atomic grouping" (a term taken from Jeffrey Friedl's book) provides
- the means for specifying that once a subpattern has matched, it is not
- to be re-evaluated in this way.
-
- If we use atomic grouping for the previous example, the matcher would
- give up immediately on failing to match "foo" the first time. The nota-
- tion is a kind of special parenthesis, starting with (?> as in this
- example:
-
- (?>\d+)foo
-
- This kind of parenthesis "locks up" the part of the pattern it con-
- tains once it has matched, and a failure further into the pattern is
- prevented from backtracking into it. Backtracking past it to previous
- items, however, works as normal.
-
- An alternative description is that a subpattern of this type matches
- the string of characters that an identical standalone pattern would
- match, if anchored at the current point in the subject string.
-
- Atomic grouping subpatterns are not capturing subpatterns. Simple cases
- such as the above example can be thought of as a maximizing repeat that
- must swallow everything it can. So, while both \d+ and \d+? are pre-
- pared to adjust the number of digits they match in order to make the
- rest of the pattern match, (?>\d+) can only match an entire sequence of
- digits.
-
- Atomic groups in general can of course contain arbitrarily complicated
- subpatterns, and can be nested. However, when the subpattern for an
- atomic group is just a single repeated item, as in the example above, a
- simpler notation, called a "possessive quantifier" can be used. This
- consists of an additional + character following a quantifier. Using
- this notation, the previous example can be rewritten as
-
- \d++foo
-
- Possessive quantifiers are always greedy; the setting of the
- PCRE_UNGREEDY option is ignored. They are a convenient notation for the
- simpler forms of atomic group. However, there is no difference in the
- meaning or processing of a possessive quantifier and the equivalent
- atomic group.
-
- The possessive quantifier syntax is an extension to the Perl syntax. It
- originates in Sun's Java package.
-
- When a pattern contains an unlimited repeat inside a subpattern that
- can itself be repeated an unlimited number of times, the use of an
- atomic group is the only way to avoid some failing matches taking a
- very long time indeed. The pattern
-
- (\D+|<\d+>)*[!?]
-
- matches an unlimited number of substrings that either consist of non-
- digits, or digits enclosed in <>, followed by either ! or ?. When it
- matches, it runs quickly. However, if it is applied to
-
- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-
- it takes a long time before reporting failure. This is because the
- string can be divided between the internal \D+ repeat and the external
- * repeat in a large number of ways, and all have to be tried. (The
- example uses [!?] rather than a single character at the end, because
- both PCRE and Perl have an optimization that allows for fast failure
- when a single character is used. They remember the last single charac-
- ter that is required for a match, and fail early if it is not present
- in the string.) If the pattern is changed so that it uses an atomic
- group, like this:
-
- ((?>\D+)|<\d+>)*[!?]
-
- sequences of non-digits cannot be broken, and failure happens quickly.
-
-
-BACK REFERENCES
-
- Outside a character class, a backslash followed by a digit greater than
- 0 (and possibly further digits) is a back reference to a capturing sub-
- pattern earlier (that is, to its left) in the pattern, provided there
- have been that many previous capturing left parentheses.
-
- However, if the decimal number following the backslash is less than 10,
- it is always taken as a back reference, and causes an error only if
- there are not that many capturing left parentheses in the entire pat-
- tern. In other words, the parentheses that are referenced need not be
- to the left of the reference for numbers less than 10. See the subsec-
- tion entitled "Non-printing characters" above for further details of
- the handling of digits following a backslash.
-
- A back reference matches whatever actually matched the capturing sub-
- pattern in the current subject string, rather than anything matching
- the subpattern itself (see "Subpatterns as subroutines" below for a way
- of doing that). So the pattern
-
- (sens|respons)e and \1ibility
-
- matches "sense and sensibility" and "response and responsibility", but
- not "sense and responsibility". If caseful matching is in force at the
- time of the back reference, the case of letters is relevant. For exam-
- ple,
-
- ((?i)rah)\s+\1
-
- matches "rah rah" and "RAH RAH", but not "RAH rah", even though the
- original capturing subpattern is matched caselessly.
-
- Back references to named subpatterns use the Python syntax (?P=name).
- We could rewrite the above example as follows:
-
- (?<p1>(?i)rah)\s+(?P=p1)
-
- There may be more than one back reference to the same subpattern. If a
- subpattern has not actually been used in a particular match, any back
- references to it always fail. For example, the pattern
-
- (a|(bc))\2
-
- always fails if it starts to match "a" rather than "bc". Because there
- may be many capturing parentheses in a pattern, all digits following
- the backslash are taken as part of a potential back reference number.
- If the pattern continues with a digit character, some delimiter must be
- used to terminate the back reference. If the PCRE_EXTENDED option is
- set, this can be whitespace. Otherwise an empty comment (see "Com-
- ments" below) can be used.
-
- A back reference that occurs inside the parentheses to which it refers
- fails when the subpattern is first used, so, for example, (a\1) never
- matches. However, such references can be useful inside repeated sub-
- patterns. For example, the pattern
-
- (a|b\1)+
-
- matches any number of "a"s and also "aba", "ababbaa" etc. At each iter-
- ation of the subpattern, the back reference matches the character
- string corresponding to the previous iteration. In order for this to
- work, the pattern must be such that the first iteration does not need
- to match the back reference. This can be done using alternation, as in
- the example above, or by a quantifier with a minimum of zero.
-
-
-ASSERTIONS
-
- An assertion is a test on the characters following or preceding the
- current matching point that does not actually consume any characters.
- The simple assertions coded as \b, \B, \A, \G, \Z, \z, ^ and $ are
- described above.
-
- More complicated assertions are coded as subpatterns. There are two
- kinds: those that look ahead of the current position in the subject
- string, and those that look behind it. An assertion subpattern is
- matched in the normal way, except that it does not cause the current
- matching position to be changed.
-
- Assertion subpatterns are not capturing subpatterns, and may not be
- repeated, because it makes no sense to assert the same thing several
- times. If any kind of assertion contains capturing subpatterns within
- it, these are counted for the purposes of numbering the capturing sub-
- patterns in the whole pattern. However, substring capturing is carried
- out only for positive assertions, because it does not make sense for
- negative assertions.
-
- Lookahead assertions
-
- Lookahead assertions start with (?= for positive assertions and (?! for
- negative assertions. For example,
-
- \w+(?=;)
-
- matches a word followed by a semicolon, but does not include the semi-
- colon in the match, and
-
- foo(?!bar)
-
- matches any occurrence of "foo" that is not followed by "bar". Note
- that the apparently similar pattern
-
- (?!foo)bar
-
- does not find an occurrence of "bar" that is preceded by something
- other than "foo"; it finds any occurrence of "bar" whatsoever, because
- the assertion (?!foo) is always true when the next three characters are
- "bar". A lookbehind assertion is needed to achieve the other effect.
-
- If you want to force a matching failure at some point in a pattern, the
- most convenient way to do it is with (?!) because an empty string
- always matches, so an assertion that requires there not to be an empty
- string must always fail.
-
- Lookbehind assertions
-
- Lookbehind assertions start with (?<= for positive assertions and (?<!
- for negative assertions. For example,
-
- (?<!foo)bar
-
- does find an occurrence of "bar" that is not preceded by "foo". The
- contents of a lookbehind assertion are restricted such that all the
- strings it matches must have a fixed length. However, if there are sev-
- eral alternatives, they do not all have to have the same fixed length.
- Thus
-
- (?<=bullock|donkey)
-
- is permitted, but
-
- (?<!dogs?|cats?)
-
- causes an error at compile time. Branches that match different length
- strings are permitted only at the top level of a lookbehind assertion.
- This is an extension compared with Perl (at least for 5.8), which
- requires all branches to match the same length of string. An assertion
- such as
-
- (?<=ab(c|de))
-
- is not permitted, because its single top-level branch can match two
- different lengths, but it is acceptable if rewritten to use two top-
- level branches:
-
- (?<=abc|abde)
-
- The implementation of lookbehind assertions is, for each alternative,
- to temporarily move the current position back by the fixed width and
- then try to match. If there are insufficient characters before the cur-
- rent position, the match is deemed to fail.
-
- PCRE does not allow the \C escape (which matches a single byte in UTF-8
- mode) to appear in lookbehind assertions, because it makes it impossi-
- ble to calculate the length of the lookbehind. The \X escape, which can
- match different numbers of bytes, is also not permitted.
-
- Atomic groups can be used in conjunction with lookbehind assertions to
- specify efficient matching at the end of the subject string. Consider a
- simple pattern such as
-
- abcd$
-
- when applied to a long string that does not match. Because matching
- proceeds from left to right, PCRE will look for each "a" in the subject
- and then see if what follows matches the rest of the pattern. If the
- pattern is specified as
-
- ^.*abcd$
-
- the initial .* matches the entire string at first, but when this fails
- (because there is no following "a"), it backtracks to match all but the
- last character, then all but the last two characters, and so on. Once
- again the search for "a" covers the entire string, from right to left,
- so we are no better off. However, if the pattern is written as
-
- ^(?>.*)(?<=abcd)
-
- or, equivalently, using the possessive quantifier syntax,
-
- ^.*+(?<=abcd)
-
- there can be no backtracking for the .* item; it can match only the
- entire string. The subsequent lookbehind assertion does a single test
- on the last four characters. If it fails, the match fails immediately.
- For long strings, this approach makes a significant difference to the
- processing time.
-
- Using multiple assertions
-
- Several assertions (of any sort) may occur in succession. For example,
-
- (?<=\d{3})(?<!999)foo
-
- matches "foo" preceded by three digits that are not "999". Notice that
- each of the assertions is applied independently at the same point in
- the subject string. First there is a check that the previous three
- characters are all digits, and then there is a check that the same
- three characters are not "999". This pattern does not match "foo" pre-
- ceded by six characters, the first of which are digits and the last
- three of which are not "999". For example, it doesn't match "123abc-
- foo". A pattern to do that is
-
- (?<=\d{3}...)(?<!999)foo
-
- This time the first assertion looks at the preceding six characters,
- checking that the first three are digits, and then the second assertion
- checks that the preceding three characters are not "999".
-
- Assertions can be nested in any combination. For example,
-
- (?<=(?<!foo)bar)baz
-
- matches an occurrence of "baz" that is preceded by "bar" which in turn
- is not preceded by "foo", while
-
- (?<=\d{3}(?!999)...)foo
-
- is another pattern that matches "foo" preceded by three digits and any
- three characters that are not "999".
-
-
-CONDITIONAL SUBPATTERNS
-
- It is possible to cause the matching process to obey a subpattern con-
- ditionally or to choose between two alternative subpatterns, depending
- on the result of an assertion, or whether a previous capturing subpat-
- tern matched or not. The two possible forms of conditional subpattern
- are
-
- (?(condition)yes-pattern)
- (?(condition)yes-pattern|no-pattern)
-
- If the condition is satisfied, the yes-pattern is used; otherwise the
- no-pattern (if present) is used. If there are more than two alterna-
- tives in the subpattern, a compile-time error occurs.
-
- There are three kinds of condition. If the text between the parentheses
- consists of a sequence of digits, the condition is satisfied if the
- capturing subpattern of that number has previously matched. The number
- must be greater than zero. Consider the following pattern, which con-
- tains non-significant white space to make it more readable (assume the
- PCRE_EXTENDED option) and to divide it into three parts for ease of
- discussion:
-
- ( \( )? [^()]+ (?(1) \) )
-
- The first part matches an optional opening parenthesis, and if that
- character is present, sets it as the first captured substring. The sec-
- ond part matches one or more characters that are not parentheses. The
- third part is a conditional subpattern that tests whether the first set
- of parentheses matched or not. If they did, that is, if subject started
- with an opening parenthesis, the condition is true, and so the yes-pat-
- tern is executed and a closing 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.
-
- If the condition is the string (R), it is satisfied if a recursive call
- to the pattern or subpattern has been made. At "top level", the condi-
- tion is false. This is a PCRE extension. Recursive patterns are
- described in the next section.
-
- If the condition is not a sequence of digits or (R), it must be an
- assertion. This may be a positive or negative lookahead or lookbehind
- assertion. Consider this pattern, again containing non-significant
- white space, and with the two alternatives on the second line:
-
- (?(?=[^a-z]*[a-z])
- \d{2}-[a-z]{3}-\d{2} | \d{2}-\d{2}-\d{2} )
-
- The condition is a positive lookahead assertion that matches an
- optional sequence of non-letters followed by a letter. In other words,
- it tests for the presence of at least one letter in the subject. If a
- letter is found, the subject is matched against the first alternative;
- otherwise it is matched against the second. This pattern matches
- strings in one of the two forms dd-aaa-dd or dd-dd-dd, where aaa are
- letters and dd are digits.
-
-
-COMMENTS
-
- The sequence (?# marks the start of a comment that continues up to the
- next closing parenthesis. Nested parentheses are not permitted. The
- characters that make up a comment play no part in the pattern matching
- at all.
-
- If the PCRE_EXTENDED option is set, an unescaped # character outside a
- character class introduces a comment that continues up to the next new-
- line character in the pattern.
-
-
-RECURSIVE PATTERNS
-
- Consider the problem of matching a string in parentheses, allowing for
- unlimited nested parentheses. Without the use of recursion, the best
- that can be done is to use a pattern that matches up to some fixed
- depth of nesting. It is not possible to handle an arbitrary nesting
- depth. Perl provides a facility that allows regular expressions to
- recurse (amongst other things). It does this by interpolating Perl code
- in the expression at run time, and the code can refer to the expression
- itself. A Perl pattern to solve the parentheses problem can be created
- like this:
-
- $re = qr{\( (?: (?>[^()]+) | (?p{$re}) )* \)}x;
-
- The (?p{...}) item interpolates Perl code at run time, and in this case
- refers recursively to the pattern in which it appears. Obviously, PCRE
- cannot support the interpolation of Perl code. Instead, it supports
- some special syntax for recursion of the entire pattern, and also for
- individual subpattern recursion.
-
- The special item that consists of (? followed by a number greater than
- zero and a closing parenthesis is a recursive call of the subpattern of
- the given number, provided that it occurs inside that subpattern. (If
- not, it is a "subroutine" call, which is described in the next sec-
- tion.) The special item (?R) is a recursive call of the entire regular
- expression.
-
- For example, this PCRE pattern solves the nested parentheses problem
- (assume the PCRE_EXTENDED option is set so that white space is
- ignored):
-
- \( ( (?>[^()]+) | (?R) )* \)
-
- First it matches an opening parenthesis. Then it matches any number of
- substrings which can either be a sequence of non-parentheses, or a
- recursive match of the pattern itself (that is a correctly parenthe-
- sized substring). Finally there is a closing parenthesis.
-
- If this were part of a larger pattern, you would not want to recurse
- the entire pattern, so instead you could use this:
-
- ( \( ( (?>[^()]+) | (?1) )* \) )
-
- We have put the pattern into parentheses, and caused the recursion to
- refer to them instead of the whole pattern. In a larger pattern, keep-
- ing track of parenthesis numbers can be tricky. It may be more conve-
- nient to use named parentheses instead. For this, PCRE uses (?P>name),
- which is an extension to the Python syntax that PCRE uses for named
- parentheses (Perl does not provide named parentheses). We could rewrite
- the above example as follows:
-
- (?P<pn> \( ( (?>[^()]+) | (?P>pn) )* \) )
-
- This particular example pattern 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
-
- (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()
-
- it yields "no match" quickly. However, if atomic grouping is not used,
- the match runs for a very long time indeed because there are so many
- different ways the + and * repeats can carve up the subject, and all
- have to be tested before failure can be reported.
-
- At the end of a match, the values set for any capturing subpatterns are
- those from the outermost level of the recursion at which the subpattern
- value is set. If you want to obtain intermediate values, a callout
- function can be used (see the next section and the pcrecallout documen-
- tation). If the pattern above is matched against
-
- (ab(cd)ef)
-
- the value for the capturing parentheses is "ef", which is the last
- value taken on at the top level. If additional parentheses are added,
- giving
-
- \( ( ( (?>[^()]+) | (?R) )* ) \)
- ^ ^
- ^ ^
-
- the string they capture is "ab(cd)ef", the contents of the top level
- parentheses. If there are more than 15 capturing parentheses in a pat-
- tern, PCRE has to obtain extra memory to store data during a recursion,
- which it does by using pcre_malloc, freeing it via pcre_free after-
- wards. If no memory can be obtained, the match fails with the
- PCRE_ERROR_NOMEMORY error.
-
- Do not confuse the (?R) item with the condition (R), which tests for
- recursion. Consider this pattern, which matches text in angle brack-
- ets, allowing for arbitrary nesting. Only digits are allowed in nested
- brackets (that is, when recursing), whereas any characters are permit-
- ted at the outer level.
-
- < (?: (?(R) \d++ | [^<>]*+) | (?R)) * >
-
- In this pattern, (?(R) is the start of a conditional subpattern, with
- two different alternatives for the recursive and non-recursive cases.
- The (?R) item is the actual recursive call.
-
-
-SUBPATTERNS AS SUBROUTINES
-
- If the syntax for a recursive subpattern reference (either by number or
- by name) is used outside the parentheses to which it refers, it oper-
- ates like a subroutine in a programming language. An earlier example
- pointed out that the pattern
-
- (sens|respons)e and \1ibility
-
- matches "sense and sensibility" and "response and responsibility", but
- not "sense and responsibility". If instead the pattern
-
- (sens|respons)e and (?1)ibility
-
- is used, it does match "sense and responsibility" as well as the other
- two strings. Such references must, however, follow the subpattern to
- which they refer.
-
-
-CALLOUTS
-
- Perl has a feature whereby using the sequence (?{...}) causes arbitrary
- Perl code to be obeyed in the middle of matching a regular expression.
- This makes it possible, amongst other things, to extract different sub-
- strings that match the same pair of parentheses when there is a repeti-
- tion.
-
- PCRE provides a similar feature, but of course it cannot obey arbitrary
- Perl code. The feature is called "callout". The caller of PCRE provides
- an external function by putting its entry point in the global variable
- pcre_callout. By default, this variable contains NULL, which disables
- all calling out.
-
- Within a regular expression, (?C) indicates the points at which the
- external function is to be called. If you want to identify different
- callout points, you can put a number less than 256 after the letter C.
- The default value is zero. For example, this pattern has two callout
- points:
-
- (?C1)abc(?C2)def
-
- If the PCRE_AUTO_CALLOUT flag is passed to pcre_compile(), callouts are
- automatically installed before each item in the pattern. They are all
- numbered 255.
-
- During matching, when PCRE reaches a callout point (and pcre_callout is
- set), the external function is called. It is provided with the number
- of the callout, the position in the pattern, and, optionally, one item
- of data originally supplied by the caller of pcre_exec(). The callout
- function may cause matching to proceed, to backtrack, or to fail alto-
- gether. A complete description of the interface to the callout function
- is given in the pcrecallout documentation.
-
-Last updated: 09 September 2004
-Copyright (c) 1997-2004 University of Cambridge.
------------------------------------------------------------------------------
-
-PCRE(3) PCRE(3)
-
-
-
-NAME
- PCRE - Perl-compatible regular expressions
-
-PARTIAL MATCHING IN PCRE
-
- In normal use of PCRE, if the subject string that is passed to
- pcre_exec() matches as far as it goes, but is too short to match the
- entire pattern, PCRE_ERROR_NOMATCH is returned. There are circumstances
- where it might be helpful to distinguish this case from other cases in
- which there is no match.
-
- Consider, for example, an application where a human is required to type
- in data for a field with specific formatting requirements. An example
- might be a date in the form ddmmmyy, defined by this pattern:
-
- ^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$
-
- If the application sees the user's keystrokes one by one, and can check
- that what has been typed so far is potentially valid, it is able to
- raise an error as soon as a mistake is made, possibly beeping and not
- reflecting the character that has been typed. This immediate feedback
- is likely to be a better user interface than a check that is delayed
- until the entire string has been entered.
-
- PCRE supports the concept of partial matching by means of the PCRE_PAR-
- TIAL option, which can be set when calling pcre_exec(). When this is
- done, the return code PCRE_ERROR_NOMATCH is converted into
- PCRE_ERROR_PARTIAL if at any time during the matching process the
- entire subject string matched part of the pattern. No captured data is
- set when this occurs.
-
- Using PCRE_PARTIAL disables one of PCRE's optimizations. PCRE remembers
- the last literal byte in a pattern, and abandons matching immediately
- if such a byte is not present in the subject string. This optimization
- cannot be used for a subject string that might match only partially.
-
-
-RESTRICTED PATTERNS FOR PCRE_PARTIAL
-
- Because of the way certain internal optimizations are implemented in
- PCRE, the PCRE_PARTIAL option cannot be used with all patterns.
- Repeated single characters such as
-
- a{2,4}
-
- and repeated single metasequences such as
-
- \d+
-
- are not permitted if the maximum number of occurrences is greater than
- one. Optional items such as \d? (where the maximum is one) are permit-
- ted. Quantifiers with any values are permitted after parentheses, so
- the invalid examples above can be coded thus:
-
- (a){2,4}
- (\d)+
-
- These constructions run more slowly, but for the kinds of application
- that are envisaged for this facility, this is not felt to be a major
- restriction.
-
- If PCRE_PARTIAL is set for a pattern that does not conform to the
- restrictions, pcre_exec() returns the error code PCRE_ERROR_BADPARTIAL
- (-13).
-
-
-EXAMPLE OF PARTIAL MATCHING USING PCRETEST
-
- If the escape sequence \P is present in a pcretest data line, the
- PCRE_PARTIAL flag is used for the match. Here is a run of pcretest that
- uses the date example quoted above:
-
- re> /^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$/
- data> 25jun04P
- 0: 25jun04
- 1: jun
- data> 25dec3P
- Partial match
- data> 3juP
- Partial match
- data> 3jujP
- No match
- data> jP
- No match
-
- The first data string is matched completely, so pcretest shows the
- matched substrings. The remaining four strings do not match the com-
- plete pattern, but the first two are partial matches.
-
-Last updated: 08 September 2004
-Copyright (c) 1997-2004 University of Cambridge.
------------------------------------------------------------------------------
-
-PCRE(3) PCRE(3)
-
-
-
-NAME
- PCRE - Perl-compatible regular expressions
-
-SAVING AND RE-USING PRECOMPILED PCRE PATTERNS
-
- If you are running an application that uses a large number of regular
- expression patterns, it may be useful to store them in a precompiled
- form instead of having to compile them every time the application is
- run. If you are not using any private character tables (see the
- pcre_maketables() documentation), this is relatively straightforward.
- If you are using private tables, it is a little bit more complicated.
-
- If you save compiled patterns to a file, you can copy them to a differ-
- ent host and run them there. This works even if the new host has the
- opposite endianness to the one on which the patterns were compiled.
- There may be a small performance penalty, but it should be insignifi-
- cant.
-
-
-SAVING A COMPILED PATTERN
- The value returned by pcre_compile() points to a single block of memory
- that holds the compiled pattern and associated data. You can find the
- length of this block in bytes by calling pcre_fullinfo() with an argu-
- ment of PCRE_INFO_SIZE. You can then save the data in any appropriate
- manner. Here is sample code that compiles a pattern and writes it to a
- file. It assumes that the variable fd refers to a file that is open for
- output:
-
- int erroroffset, rc, size;
- char *error;
- pcre *re;
-
- re = pcre_compile("my pattern", 0, &error, &erroroffset, NULL);
- if (re == NULL) { ... handle errors ... }
- rc = pcre_fullinfo(re, NULL, PCRE_INFO_SIZE, &size);
- if (rc < 0) { ... handle errors ... }
- rc = fwrite(re, 1, size, fd);
- if (rc != size) { ... handle errors ... }
-
- In this example, the bytes that comprise the compiled pattern are
- copied exactly. Note that this is binary data that may contain any of
- the 256 possible byte values. On systems that make a distinction
- between binary and non-binary data, be sure that the file is opened for
- binary output.
-
- If you want to write more than one pattern to a file, you will have to
- devise a way of separating them. For binary data, preceding each pat-
- tern with its length is probably the most straightforward approach.
- Another possibility is to write out the data in hexadecimal instead of
- binary, one pattern to a line.
-
- Saving compiled patterns in a file is only one possible way of storing
- them for later use. They could equally well be saved in a database, or
- in the memory of some daemon process that passes them via sockets to
- the processes that want them.
-
- If the pattern has been studied, it is also possible to save the study
- data in a similar way to the compiled pattern itself. When studying
- generates additional information, pcre_study() returns a pointer to a
- pcre_extra data block. Its format is defined in the section on matching
- a pattern in the pcreapi documentation. The study_data field points to
- the binary study data, and this is what you must save (not the
- pcre_extra block itself). The length of the study data can be obtained
- by calling pcre_fullinfo() with an argument of PCRE_INFO_STUDYSIZE.
- Remember to check that pcre_study() did return a non-NULL value before
- trying to save the study data.
-
-
-RE-USING A PRECOMPILED PATTERN
-
- Re-using a precompiled pattern is straightforward. Having reloaded it
- into main memory, you pass its pointer to pcre_exec() in the usual way.
- This should work even on another host, and even if that host has the
- opposite endianness to the one where the pattern was compiled.
-
- However, if you passed a pointer to custom character tables when the
- pattern was compiled (the tableptr argument of pcre_compile()), you
- must now pass a similar pointer to pcre_exec(), because the value saved
- with the compiled pattern will obviously be nonsense. A field in a
- pcre_extra() block is used to pass this data, as described in the sec-
- tion on matching a pattern in the pcreapi documentation.
-
- If you did not provide custom character tables when the pattern was
- compiled, the pointer in the compiled pattern is NULL, which causes
- pcre_exec() to use PCRE's internal tables. Thus, you do not need to
- take any special action at run time in this case.
-
- If you saved study data with the compiled pattern, you need to create
- your own pcre_extra data block and set the study_data field to point to
- the reloaded study data. You must also set the PCRE_EXTRA_STUDY_DATA
- bit in the flags field to indicate that study data is present. Then
- pass the pcre_extra block to pcre_exec() in the usual way.
-
-
-COMPATIBILITY WITH DIFFERENT PCRE RELEASES
-
- The layout of the control block that is at the start of the data that
- makes up a compiled pattern was changed for release 5.0. If you have
- any saved patterns that were compiled with previous releases (not a
- facility that was previously advertised), you will have to recompile
- them for release 5.0. However, from now on, it should be possible to
- make changes in a compabible manner.
-
-Last updated: 10 September 2004
-Copyright (c) 1997-2004 University of Cambridge.
------------------------------------------------------------------------------
-
-PCRE(3) PCRE(3)
-
-
-
-NAME
- PCRE - Perl-compatible regular expressions
-
-PCRE PERFORMANCE
-
- Certain items that may appear in regular expression patterns are more
- efficient than others. It is more efficient to use a character class
- like [aeiou] than a set of alternatives such as (a|e|i|o|u). In gen-
- eral, the simplest construction that provides the required behaviour is
- usually the most efficient. Jeffrey Friedl's book contains a lot of
- useful general discussion about optimizing regular expressions for
- efficient performance. This document contains a few observations about
- PCRE.
-
- Using Unicode character properties (the \p, \P, and \X escapes) is
- slow, because PCRE has to scan a structure that contains data for over
- fifteen thousand characters whenever it needs a character's property.
- If you can find an alternative pattern that does not use character
- properties, it will probably be faster.
-
- When a pattern begins with .* not in parentheses, or in parentheses
- that are not the subject of a backreference, and the PCRE_DOTALL option
- is set, the pattern is implicitly anchored by PCRE, since it can match
- only at the start of a subject string. However, if PCRE_DOTALL is not
- set, PCRE cannot make this optimization, because the . metacharacter
- does not then match a newline, and if the subject string contains new-
- lines, the pattern may match from the character immediately following
- one of them instead of from the very start. For example, the pattern
-
- .*second
-
- matches the subject "first\nand second" (where \n stands for a newline
- character), with the match starting at the seventh character. In order
- to do this, PCRE has to retry the match starting after every newline in
- the subject.
-
- If you are using such a pattern with subject strings that do not con-
- tain newlines, the best performance is obtained by setting PCRE_DOTALL,
- or starting the pattern with ^.* to indicate explicit anchoring. That
- saves PCRE from having to scan along the subject looking for a newline
- to restart at.
-
- Beware of patterns that contain nested indefinite repeats. These can
- take a long time to run when applied to a string that does not match.
- Consider the pattern fragment
-
- (a+)*
-
- This can match "aaaa" in 33 different ways, and this number increases
- very rapidly as the string gets longer. (The * repeat can match 0, 1,
- 2, 3, or 4 times, and for each of those cases other than 0, the +
- repeats can match different numbers of times.) When the remainder of
- the pattern is such that the entire match is going to fail, PCRE has in
- principle to try every possible variation, and this can take an
- extremely long time.
-
- An optimization catches some of the more simple cases such as
-
- (a+)*b
-
- where a literal character follows. Before embarking on the standard
- matching procedure, PCRE checks that there is a "b" later in the
- subject string, and if there is not, it fails the match immediately.
- However, when there is no following literal this optimization cannot be
- used. You can see the difference by comparing the behaviour of
-
- (a+)*\d
-
- with the pattern above. The former gives a failure almost instantly
- when applied to a whole line of "a" characters, whereas the latter
- takes an appreciable time with strings longer than about 20 characters.
-
- In many cases, the solution to this kind of performance issue is to use
- an atomic group or a possessive quantifier.
-
-Last updated: 09 September 2004
-Copyright (c) 1997-2004 University of Cambridge.
------------------------------------------------------------------------------
-
-PCRE(3) PCRE(3)
-
-
-
-NAME
- PCRE - Perl-compatible regular expressions.
-
-SYNOPSIS OF POSIX API
-
- #include <pcreposix.h>
-
- int regcomp(regex_t *preg, const char *pattern,
- int cflags);
-
- int regexec(regex_t *preg, const char *string,
- size_t nmatch, regmatch_t pmatch[], int eflags);
-
- size_t regerror(int errcode, const regex_t *preg,
- char *errbuf, size_t errbuf_size);
-
- void regfree(regex_t *preg);
-
-
-DESCRIPTION
-
- This set of functions provides a POSIX-style API to the PCRE regular
- expression package. See the pcreapi documentation for a description of
- PCRE's native API, which contains additional functionality.
-
- The functions described here are just wrapper functions that ultimately
- call the PCRE native API. Their prototypes are defined in the
- pcreposix.h header file, and on Unix systems the library itself is
- called pcreposix.a, so can be accessed by adding -lpcreposix to the
- command for linking an application that uses them. Because the POSIX
- functions call the native ones, it is also necessary to add -lpcre.
-
- I have implemented only those option bits that can be reasonably mapped
- to PCRE native options. In addition, the options REG_EXTENDED and
- REG_NOSUB are defined with the value zero. They have no effect, but
- since programs that are written to the POSIX interface often use them,
- this makes it easier to slot in PCRE as a replacement library. Other
- POSIX options are not even defined.
-
- When PCRE is called via these functions, it is only the API that is
- POSIX-like in style. The syntax and semantics of the regular expres-
- sions themselves are still those of Perl, subject to the setting of
- various PCRE options, as described below. "POSIX-like in style" means
- that the API approximates to the POSIX definition; it is not fully
- POSIX-compatible, and in multi-byte encoding domains it is probably
- even less compatible.
-
- The header for these functions is supplied as pcreposix.h to avoid any
- potential clash with other POSIX libraries. It can, of course, be
- renamed or aliased as regex.h, which is the "correct" name. It provides
- two structure types, regex_t for compiled internal forms, and reg-
- match_t for returning captured substrings. It also defines some con-
- stants whose names start with "REG_"; these are used for setting
- options and identifying error codes.
-
-
-COMPILING A PATTERN
-
- The function regcomp() is called to compile a pattern into an internal
- form. The pattern is a C string terminated by a binary zero, and is
- passed in the argument pattern. The preg argument is a pointer to a
- regex_t structure that is used as a base for storing information about
- the compiled expression.
-
- The argument cflags is either zero, or contains one or more of the bits
- defined by the following macros:
-
- REG_ICASE
-
- The PCRE_CASELESS option is set when the expression is passed for com-
- pilation to the native function.
-
- REG_NEWLINE
-
- The PCRE_MULTILINE option is set when the expression is passed for com-
- pilation to the native function. Note that this does not mimic the
- defined POSIX behaviour for REG_NEWLINE (see the following section).
-
- In the absence of these flags, no options are passed to the native
- function. This means the the regex is compiled with PCRE default
- semantics. In particular, the way it handles newline characters in the
- subject string is the Perl way, not the POSIX way. Note that setting
- PCRE_MULTILINE has only some of the effects specified for REG_NEWLINE.
- It does not affect the way newlines are matched by . (they aren't) or
- by a negative class such as [^a] (they are).
-
- The yield of regcomp() is zero on success, and non-zero otherwise. The
- preg structure is filled in on success, and one member of the structure
- is public: re_nsub contains the number of capturing subpatterns in the
- regular expression. Various error codes are defined in the header file.
-
-
-MATCHING NEWLINE CHARACTERS
-
- This area is not simple, because POSIX and Perl take different views of
- things. It is not possible to get PCRE to obey POSIX semantics, but
- then PCRE was never intended to be a POSIX engine. The following table
- lists the different possibilities for matching newline characters in
- PCRE:
-
- Default Change with
-
- . matches newline no PCRE_DOTALL
- newline matches [^a] yes not changeable
- $ matches \n at end yes PCRE_DOLLARENDONLY
- $ matches \n in middle no PCRE_MULTILINE
- ^ matches \n in middle no PCRE_MULTILINE
-
- This is the equivalent table for POSIX:
-
- Default Change with
-
- . matches newline yes REG_NEWLINE
- newline matches [^a] yes REG_NEWLINE
- $ matches \n at end no REG_NEWLINE
- $ matches \n in middle no REG_NEWLINE
- ^ matches \n in middle no REG_NEWLINE
-
- PCRE's behaviour is the same as Perl's, except that there is no equiva-
- lent for PCRE_DOLLAR_ENDONLY in Perl. In both PCRE and Perl, there is
- no way to stop newline from matching [^a].
-
- The default POSIX newline handling can be obtained by setting
- PCRE_DOTALL and PCRE_DOLLAR_ENDONLY, but there is no way to make PCRE
- behave exactly as for the REG_NEWLINE action.
-
-
-MATCHING A PATTERN
-
- The function regexec() is called to match a compiled pattern preg
- against a given string, which is terminated by a zero byte, subject to
- the options in eflags. These can be:
-
- REG_NOTBOL
-
- The PCRE_NOTBOL option is set when calling the underlying PCRE matching
- function.
-
- REG_NOTEOL
-
- The PCRE_NOTEOL option is set when calling the underlying PCRE matching
- function.
-
- The portion of the string that was matched, and also any captured sub-
- strings, are returned via the pmatch argument, which points to an array
- of nmatch structures of type regmatch_t, containing the members rm_so
- and rm_eo. These contain the offset to the first character of each sub-
- string and the offset to the first character after the end of each sub-
- string, respectively. The 0th element of the vector relates to the
- entire portion of string that was matched; subsequent elements relate
- to the capturing subpatterns of the regular expression. Unused entries
- in the array have both structure members set to -1.
-
- A successful match yields a zero return; various error codes are
- defined in the header file, of which REG_NOMATCH is the "expected"
- failure code.
-
-
-ERROR MESSAGES
-
- The regerror() function maps a non-zero errorcode from either regcomp()
- or regexec() to a printable message. If preg is not NULL, the error
- should have arisen from the use of that structure. A message terminated
- by a binary zero is placed in errbuf. The length of the message,
- including the zero, is limited to errbuf_size. The yield of the func-
- tion is the size of buffer needed to hold the whole message.
-
-
-MEMORY USAGE
-
- Compiling a regular expression causes memory to be allocated and asso-
- ciated with the preg structure. The function regfree() frees all such
- memory, after which preg may no longer be used as a compiled expres-
- sion.
-
-
-AUTHOR
-
- Philip Hazel <ph10@cam.ac.uk>
- University Computing Service,
- Cambridge CB2 3QG, England.
-
-Last updated: 07 September 2004
-Copyright (c) 1997-2004 University of Cambridge.
------------------------------------------------------------------------------
-
-PCRE(3) PCRE(3)
-
-
-
-NAME
- PCRE - Perl-compatible regular expressions
-
-PCRE SAMPLE PROGRAM
-
- A simple, complete demonstration program, to get you started with using
- PCRE, is supplied in the file pcredemo.c in the PCRE distribution.
-
- The program compiles the regular expression that is its first argument,
- and matches it against the subject string in its second argument. No
- PCRE options are set, and default character tables are used. If match-
- ing succeeds, the program outputs the portion of the subject that
- matched, together with the contents of any captured substrings.
-
- If the -g option is given on the command line, the program then goes on
- to check for further matches of the same regular expression in the same
- subject string. The logic is a little bit tricky because of the possi-
- bility of matching an empty string. Comments in the code explain what
- is going on.
-
- If PCRE is installed in the standard include and library directories
- for your system, you should be able to compile the demonstration pro-
- gram using this command:
-
- gcc -o pcredemo pcredemo.c -lpcre
-
- If PCRE is installed elsewhere, you may need to add additional options
- to the command line. For example, on a Unix-like system that has PCRE
- installed in /usr/local, you can compile the demonstration program
- using a command like this:
-
- gcc -o pcredemo -I/usr/local/include pcredemo.c \
- -L/usr/local/lib -lpcre
-
- Once you have compiled the demonstration program, you can run simple
- tests like this:
-
- ./pcredemo 'cat|dog' 'the cat sat on the mat'
- ./pcredemo -g 'cat|dog' 'the dog sat on the cat'
-
- Note that there is a much more comprehensive test program, called
- pcretest, which supports many more facilities for testing regular
- expressions and the PCRE library. The pcredemo program is provided as a
- simple coding example.
-
- On some operating systems (e.g. Solaris), when PCRE is not installed in
- the standard library directory, you may get an error like this when you
- try to run pcredemo:
-
- ld.so.1: a.out: fatal: libpcre.so.0: open failed: No such file or
- directory
-
- This is caused by the way shared library support works on those sys-
- tems. You need to add
-
- -R/usr/local/lib
-
- (for example) to the compile command to get round this problem.
-
-Last updated: 09 September 2004
-Copyright (c) 1997-2004 University of Cambridge.
------------------------------------------------------------------------------
-
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B pcre *pcre_compile(const char *\fIpattern\fP, int \fIoptions\fP,
-.ti +5n
-.B const char **\fIerrptr\fP, int *\fIerroffset\fP,
-.ti +5n
-.B const unsigned char *\fItableptr\fP);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This function compiles a regular expression into an internal form. Its
-arguments are:
-.sp
- \fIpattern\fR A zero-terminated string containing the
- regular expression to be compiled
- \fIoptions\fR Zero or more option bits
- \fIerrptr\fR Where to put an error message
- \fIerroffset\fR Offset in pattern where error was found
- \fItableptr\fR Pointer to character tables, or NULL to
- use the built-in default
-.sp
-The option bits are:
-.sp
- PCRE_ANCHORED Force pattern anchoring
- PCRE_AUTO_CALLOUT Compile automatic callouts
- PCRE_CASELESS Do caseless matching
- PCRE_DOLLAR_ENDONLY $ not to match newline at end
- PCRE_DOTALL . matches anything including NL
- PCRE_EXTENDED Ignore whitespace and # comments
- PCRE_EXTRA PCRE extra features
- (not much use currently)
- PCRE_MULTILINE ^ and $ match newlines within data
- PCRE_NO_AUTO_CAPTURE Disable numbered capturing paren-
- theses (named ones available)
- PCRE_UNGREEDY Invert greediness of quantifiers
- PCRE_UTF8 Run in UTF-8 mode
- PCRE_NO_UTF8_CHECK Do not check the pattern for UTF-8
- validity (only relevant if
- PCRE_UTF8 is set)
-.sp
-PCRE must be built with UTF-8 support in order to use PCRE_UTF8 and
-PCRE_NO_UTF8_CHECK.
-.P
-The yield of the function is a pointer to a private data structure that
-contains the compiled pattern, or NULL if an error was detected.
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fR
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fR
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B int pcre_config(int \fIwhat\fP, void *\fIwhere\fP);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This function makes it possible for a client program to find out which optional
-features are available in the version of the PCRE library it is using. Its
-arguments are as follows:
-.sp
- \fIwhat\fR A code specifying what information is required
- \fIwhere\fR Points to where to put the data
-.sp
-The available codes are:
-.sp
- PCRE_CONFIG_LINK_SIZE Internal link size: 2, 3, or 4
- PCRE_CONFIG_MATCH_LIMIT Internal resource limit
- PCRE_CONFIG_NEWLINE Value of the newline character
- PCRE_CONFIG_POSIX_MALLOC_THRESHOLD
- Threshold of return slots, above
- which \fBmalloc()\fR is used by
- the POSIX API
- PCRE_CONFIG_STACKRECURSE Recursion implementation (1=stack 0=heap)
- PCRE_CONFIG_UTF8 Availability of UTF-8 support (1=yes 0=no)
- PCRE_CONFIG_UNICODE_PROPERTIES
- Availability of Unicode property support
- (1=yes 0=no)
-.sp
-The function yields 0 on success or PCRE_ERROR_BADOPTION otherwise.
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fR
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fR
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B int pcre_copy_named_substring(const pcre *\fIcode\fP,
-.ti +5n
-.B const char *\fIsubject\fP, int *\fIovector\fP,
-.ti +5n
-.B int \fIstringcount\fP, const char *\fIstringname\fP,
-.ti +5n
-.B char *\fIbuffer\fP, int \fIbuffersize\fP);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This is a convenience function for extracting a captured substring, identified
-by name, into a given buffer. The arguments are:
-.sp
- \fIcode\fP Pattern that was successfully matched
- \fIsubject\fP Subject that has been successfully matched
- \fIovector\fP Offset vector that \fBpcre_exec()\fP used
- \fIstringcount\fP Value returned by \fBpcre_exec()\fP
- \fIstringname\fP Name of the required substring
- \fIbuffer\fP Buffer to receive the string
- \fIbuffersize\fP Size of buffer
-.sp
-The yield is the length of the substring, PCRE_ERROR_NOMEMORY if the buffer was
-too small, or PCRE_ERROR_NOSUBSTRING if the string name is invalid.
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fP
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B int pcre_copy_substring(const char *\fIsubject\fP, int *\fIovector\fP,
-.ti +5n
-.B int \fIstringcount\fP, int \fIstringnumber\fP, char *\fIbuffer\fP,
-.ti +5n
-.B int \fIbuffersize\fP);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This is a convenience function for extracting a captured substring into a given
-buffer. The arguments are:
-.sp
- \fIsubject\fP Subject that has been successfully matched
- \fIovector\fP Offset vector that \fBpcre_exec()\fP used
- \fIstringcount\fP Value returned by \fBpcre_exec()\fP
- \fIstringnumber\fP Number of the required substring
- \fIbuffer\fP Buffer to receive the string
- \fIbuffersize\fP Size of buffer
-.sp
-The yield is the legnth of the string, PCRE_ERROR_NOMEMORY if the buffer was
-too small, or PCRE_ERROR_NOSUBSTRING if the string number is invalid.
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fP
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B int pcre_exec(const pcre *\fIcode\fP, "const pcre_extra *\fIextra\fP,"
-.ti +5n
-.B "const char *\fIsubject\fP," int \fIlength\fP, int \fIstartoffset\fP,
-.ti +5n
-.B int \fIoptions\fP, int *\fIovector\fP, int \fIovecsize\fP);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This function matches a compiled regular expression against a given subject
-string, and returns offsets to capturing subexpressions. Its arguments are:
-.sp
- \fIcode\fP Points to the compiled pattern
- \fIextra\fP Points to an associated \fBpcre_extra\fP structure,
- or is NULL
- \fIsubject\fP Points to the subject string
- \fIlength\fP Length of the subject string, in bytes
- \fIstartoffset\fP Offset in bytes in the subject at which to
- start matching
- \fIoptions\fP Option bits
- \fIovector\fP Points to a vector of ints for result offsets
- \fIovecsize\fP Number of elements in the vector (a multiple of 3)
-.sp
-The options are:
-.sp
- PCRE_ANCHORED Match only at the first position
- PCRE_NOTBOL Subject is not the beginning of a line
- PCRE_NOTEOL Subject is not the end of a line
- PCRE_NOTEMPTY An empty string is not a valid match
- PCRE_NO_UTF8_CHECK Do not check the subject for UTF-8
- validity (only relevant if PCRE_UTF8
- was set at compile time)
- PCRE_PARTIAL Return PCRE_ERROR_PARTIAL for a partial match
-.sp
-There are restrictions on what may appear in a pattern when partial matching is
-requested.
-.P
-A \fBpcre_extra\fP structure contains the following fields:
-.sp
- \fIflags\fP Bits indicating which fields are set
- \fIstudy_data\fP Opaque data from \fBpcre_study()\fP
- \fImatch_limit\fP Limit on internal recursion
- \fIcallout_data\fP Opaque data passed back to callouts
- \fItables\fP Points to character tables or is NULL
-.sp
-The flag bits are PCRE_EXTRA_STUDY_DATA, PCRE_EXTRA_MATCH_LIMIT,
-PCRE_EXTRA_CALLOUT_DATA, and PCRE_EXTRA_TABLES.
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fP
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B void pcre_free_substring(const char *\fIstringptr\fP);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This is a convenience function for freeing the store obtained by a previous
-call to \fBpcre_get_substring()\fP or \fBpcre_get_named_substring()\fP. Its
-only argument is a pointer to the string.
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fP
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B void pcre_free_substring_list(const char **\fIstringptr\fP);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This is a convenience function for freeing the store obtained by a previous
-call to \fBpcre_get_substring_list()\fP. Its only argument is a pointer to the
-list of string pointers.
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fP
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B int pcre_fullinfo(const pcre *\fIcode\fP, "const pcre_extra *\fIextra\fP,"
-.ti +5n
-.B int \fIwhat\fP, void *\fIwhere\fP);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This function returns information about a compiled pattern. Its arguments are:
-.sp
- \fIcode\fP Compiled regular expression
- \fIextra\fP Result of \fBpcre_study()\fP or NULL
- \fIwhat\fP What information is required
- \fIwhere\fP Where to put the information
-.sp
-The following information is available:
-.sp
- PCRE_INFO_BACKREFMAX Number of highest back reference
- PCRE_INFO_CAPTURECOUNT Number of capturing subpatterns
- PCRE_INFO_DEFAULT_TABLES Pointer to default tables
- PCRE_INFO_FIRSTBYTE Fixed first byte for a match, or
- -1 for start of string
- or after newline, or
- -2 otherwise
- PCRE_INFO_FIRSTTABLE Table of first bytes
- (after studying)
- PCRE_INFO_LASTLITERAL Literal last byte required
- PCRE_INFO_NAMECOUNT Number of named subpatterns
- PCRE_INFO_NAMEENTRYSIZE Size of name table entry
- PCRE_INFO_NAMETABLE Pointer to name table
- PCRE_INFO_OPTIONS Options used for compilation
- PCRE_INFO_SIZE Size of compiled pattern
- PCRE_INFO_STUDYSIZE Size of study data
-.sp
-The yield of the function is zero on success or:
-.sp
- PCRE_ERROR_NULL the argument \fIcode\fP was NULL
- the argument \fIwhere\fP was NULL
- PCRE_ERROR_BADMAGIC the "magic number" was not found
- PCRE_ERROR_BADOPTION the value of \fIwhat\fP was invalid
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fP
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B int pcre_get_named_substring(const pcre *\fIcode\fP,
-.ti +5n
-.B const char *\fIsubject\fP, int *\fIovector\fP,
-.ti +5n
-.B int \fIstringcount\fP, const char *\fIstringname\fP,
-.ti +5n
-.B const char **\fIstringptr\fP);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This is a convenience function for extracting a captured substring by name. The
-arguments are:
-.sp
- \fIcode\fP Compiled pattern
- \fIsubject\fP Subject that has been successfully matched
- \fIovector\fP Offset vector that \fBpcre_exec()\fP used
- \fIstringcount\fP Value returned by \fBpcre_exec()\fP
- \fIstringname\fP Name of the required substring
- \fIstringptr\fP Where to put the string pointer
-.sp
-The memory in which the substring is placed is obtained by calling
-\fBpcre_malloc()\fP. The yield of the function is the length of the extracted
-substring, PCRE_ERROR_NOMEMORY if sufficient memory could not be obtained, or
-PCRE_ERROR_NOSUBSTRING if the string name is invalid.
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fP
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B int pcre_get_stringnumber(const pcre *\fIcode\fP,
-.ti +5n
-.B const char *\fIname\fP);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This convenience function finds the number of a named substring capturing
-parenthesis in a compiled pattern. Its arguments are:
-.sp
- \fIcode\fP Compiled regular expression
- \fIname\fP Name whose number is required
-.sp
-The yield of the function is the number of the parenthesis if the name is
-found, or PCRE_ERROR_NOSUBSTRING otherwise.
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fP
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B int pcre_get_substring(const char *\fIsubject\fP, int *\fIovector\fP,
-.ti +5n
-.B int \fIstringcount\fP, int \fIstringnumber\fP,
-.ti +5n
-.B const char **\fIstringptr\fP);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This is a convenience function for extracting a captured substring. The
-arguments are:
-.sp
- \fIsubject\fP Subject that has been successfully matched
- \fIovector\fP Offset vector that \fBpcre_exec()\fP used
- \fIstringcount\fP Value returned by \fBpcre_exec()\fP
- \fIstringnumber\fP Number of the required substring
- \fIstringptr\fP Where to put the string pointer
-.sp
-The memory in which the substring is placed is obtained by calling
-\fBpcre_malloc()\fP. The yield of the function is the length of the substring,
-PCRE_ERROR_NOMEMORY if sufficient memory could not be obtained, or
-PCRE_ERROR_NOSUBSTRING if the string number is invalid.
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fP
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B int pcre_get_substring_list(const char *\fIsubject\fP,
-.ti +5n
-.B int *\fIovector\fP, int \fIstringcount\fP, "const char ***\fIlistptr\fP);"
-.
-.SH DESCRIPTION
-.rs
-.sp
-This is a convenience function for extracting a list of all the captured
-substrings. The arguments are:
-.sp
- \fIsubject\fP Subject that has been successfully matched
- \fIovector\fP Offset vector that \fBpcre_exec\fP used
- \fIstringcount\fP Value returned by \fBpcre_exec\fP
- \fIlistptr\fP Where to put a pointer to the list
-.sp
-The memory in which the substrings and the list are placed is obtained by
-calling \fBpcre_malloc()\fP. A pointer to a list of pointers is put in
-the variable whose address is in \fIlistptr\fP. The list is terminated by a
-NULL pointer. The yield of the function is zero on success or
-PCRE_ERROR_NOMEMORY if sufficient memory could not be obtained.
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fP
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B int pcre_info(const pcre *\fIcode\fP, int *\fIoptptr\fP, int
-.B *\fIfirstcharptr\fP);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This function is obsolete. You should be using \fBpcre_fullinfo()\fP instead.
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fP
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B const unsigned char *pcre_maketables(void);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This function builds a set of character tables for character values less than
-256. These can be passed to \fBpcre_compile()\fP to override PCRE's internal,
-built-in tables (which were made by \fBpcre_maketables()\fP when PCRE was
-compiled). You might want to do this if you are using a non-standard locale.
-The function yields a pointer to the tables.
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fP
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B pcre_extra *pcre_study(const pcre *\fIcode\fP, int \fIoptions\fP,
-.ti +5n
-.B const char **\fIerrptr\fP);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This function studies a compiled pattern, to see if additional information can
-be extracted that might speed up matching. Its arguments are:
-.sp
- \fIcode\fP A compiled regular expression
- \fIoptions\fP Options for \fBpcre_study()\fP
- \fIerrptr\fP Where to put an error message
-.sp
-If the function succeeds, it returns a value that can be passed to
-\fBpcre_exec()\fP via its \fIextra\fP argument.
-.P
-If the function returns NULL, either it could not find any additional
-information, or there was an error. You can tell the difference by looking at
-the error value. It is NULL in first case.
-.P
-There are currently no options defined; the value of the second argument should
-always be zero.
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fP
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH SYNOPSIS
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B char *pcre_version(void);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This function returns a character string that gives the version number of the
-PCRE library and the date of its release.
-.P
-There is a complete description of the PCRE native API in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-page and a description of the POSIX API in the
-.\" HREF
-\fBpcreposix\fP
-.\"
-page.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH "PCRE NATIVE API"
-.rs
-.sp
-.B #include <pcre.h>
-.PP
-.SM
-.br
-.B pcre *pcre_compile(const char *\fIpattern\fP, int \fIoptions\fP,
-.ti +5n
-.B const char **\fIerrptr\fP, int *\fIerroffset\fP,
-.ti +5n
-.B const unsigned char *\fItableptr\fP);
-.PP
-.br
-.B pcre_extra *pcre_study(const pcre *\fIcode\fP, int \fIoptions\fP,
-.ti +5n
-.B const char **\fIerrptr\fP);
-.PP
-.br
-.B int pcre_exec(const pcre *\fIcode\fP, "const pcre_extra *\fIextra\fP,"
-.ti +5n
-.B "const char *\fIsubject\fP," int \fIlength\fP, int \fIstartoffset\fP,
-.ti +5n
-.B int \fIoptions\fP, int *\fIovector\fP, int \fIovecsize\fP);
-.PP
-.br
-.B int pcre_copy_named_substring(const pcre *\fIcode\fP,
-.ti +5n
-.B const char *\fIsubject\fP, int *\fIovector\fP,
-.ti +5n
-.B int \fIstringcount\fP, const char *\fIstringname\fP,
-.ti +5n
-.B char *\fIbuffer\fP, int \fIbuffersize\fP);
-.PP
-.br
-.B int pcre_copy_substring(const char *\fIsubject\fP, int *\fIovector\fP,
-.ti +5n
-.B int \fIstringcount\fP, int \fIstringnumber\fP, char *\fIbuffer\fP,
-.ti +5n
-.B int \fIbuffersize\fP);
-.PP
-.br
-.B int pcre_get_named_substring(const pcre *\fIcode\fP,
-.ti +5n
-.B const char *\fIsubject\fP, int *\fIovector\fP,
-.ti +5n
-.B int \fIstringcount\fP, const char *\fIstringname\fP,
-.ti +5n
-.B const char **\fIstringptr\fP);
-.PP
-.br
-.B int pcre_get_stringnumber(const pcre *\fIcode\fP,
-.ti +5n
-.B const char *\fIname\fP);
-.PP
-.br
-.B int pcre_get_substring(const char *\fIsubject\fP, int *\fIovector\fP,
-.ti +5n
-.B int \fIstringcount\fP, int \fIstringnumber\fP,
-.ti +5n
-.B const char **\fIstringptr\fP);
-.PP
-.br
-.B int pcre_get_substring_list(const char *\fIsubject\fP,
-.ti +5n
-.B int *\fIovector\fP, int \fIstringcount\fP, "const char ***\fIlistptr\fP);"
-.PP
-.br
-.B void pcre_free_substring(const char *\fIstringptr\fP);
-.PP
-.br
-.B void pcre_free_substring_list(const char **\fIstringptr\fP);
-.PP
-.br
-.B const unsigned char *pcre_maketables(void);
-.PP
-.br
-.B int pcre_fullinfo(const pcre *\fIcode\fP, "const pcre_extra *\fIextra\fP,"
-.ti +5n
-.B int \fIwhat\fP, void *\fIwhere\fP);
-.PP
-.br
-.B int pcre_info(const pcre *\fIcode\fP, int *\fIoptptr\fP, int
-.B *\fIfirstcharptr\fP);
-.PP
-.br
-.B int pcre_config(int \fIwhat\fP, void *\fIwhere\fP);
-.PP
-.br
-.B char *pcre_version(void);
-.PP
-.br
-.B void *(*pcre_malloc)(size_t);
-.PP
-.br
-.B void (*pcre_free)(void *);
-.PP
-.br
-.B void *(*pcre_stack_malloc)(size_t);
-.PP
-.br
-.B void (*pcre_stack_free)(void *);
-.PP
-.br
-.B int (*pcre_callout)(pcre_callout_block *);
-.
-.
-.SH "PCRE API OVERVIEW"
-.rs
-.sp
-PCRE has its own native API, which is described in this document. There is also
-a set of wrapper functions that correspond to the POSIX regular expression API.
-These are described in the
-.\" HREF
-\fBpcreposix\fP
-.\"
-documentation.
-.P
-The native API function prototypes are defined in the header file \fBpcre.h\fP,
-and on Unix systems the library itself is called \fBlibpcre\fP. It can
-normally be accessed by adding \fB-lpcre\fP to the command for linking an
-application that uses PCRE. The header file defines the macros PCRE_MAJOR and
-PCRE_MINOR to contain the major and minor release numbers for the library.
-Applications can use these to include support for different releases of PCRE.
-.P
-The functions \fBpcre_compile()\fP, \fBpcre_study()\fP, and \fBpcre_exec()\fP
-are used for compiling and matching regular expressions. A sample program that
-demonstrates the simplest way of using them is provided in the file called
-\fIpcredemo.c\fP in the source distribution. The
-.\" HREF
-\fBpcresample\fP
-.\"
-documentation describes how to run it.
-.P
-In addition to the main compiling and matching functions, there are convenience
-functions for extracting captured substrings from a matched subject string.
-They are:
-.sp
- \fBpcre_copy_substring()\fP
- \fBpcre_copy_named_substring()\fP
- \fBpcre_get_substring()\fP
- \fBpcre_get_named_substring()\fP
- \fBpcre_get_substring_list()\fP
- \fBpcre_get_stringnumber()\fP
-.sp
-\fBpcre_free_substring()\fP and \fBpcre_free_substring_list()\fP are also
-provided, to free the memory used for extracted strings.
-.P
-The function \fBpcre_maketables()\fP is used to build a set of character tables
-in the current locale for passing to \fBpcre_compile()\fP or \fBpcre_exec()\fP.
-This is an optional facility that is provided for specialist use. Most
-commonly, no special tables are passed, in which case internal tables that are
-generated when PCRE is built are used.
-.P
-The function \fBpcre_fullinfo()\fP is used to find out information about a
-compiled pattern; \fBpcre_info()\fP is an obsolete version that returns only
-some of the available information, but is retained for backwards compatibility.
-The function \fBpcre_version()\fP returns a pointer to a string containing the
-version of PCRE and its date of release.
-.P
-The global variables \fBpcre_malloc\fP and \fBpcre_free\fP initially contain
-the entry points of the standard \fBmalloc()\fP and \fBfree()\fP functions,
-respectively. PCRE calls the memory management functions via these variables,
-so a calling program can replace them if it wishes to intercept the calls. This
-should be done before calling any PCRE functions.
-.P
-The global variables \fBpcre_stack_malloc\fP and \fBpcre_stack_free\fP are also
-indirections to memory management functions. These special functions are used
-only when PCRE is compiled to use the heap for remembering data, instead of
-recursive function calls. This is a non-standard way of building PCRE, for use
-in environments that have limited stacks. Because of the greater use of memory
-management, it runs more slowly. Separate functions are provided so that
-special-purpose external code can be used for this case. When used, these
-functions are always called in a stack-like manner (last obtained, first
-freed), and always for memory blocks of the same size.
-.P
-The global variable \fBpcre_callout\fP initially contains NULL. It can be set
-by the caller to a "callout" function, which PCRE will then call at specified
-points during a matching operation. Details are given in the
-.\" HREF
-\fBpcrecallout\fP
-.\"
-documentation.
-.
-.
-.SH MULTITHREADING
-.rs
-.sp
-The PCRE functions can be used in multi-threading applications, with the
-proviso that the memory management functions pointed to by \fBpcre_malloc\fP,
-\fBpcre_free\fP, \fBpcre_stack_malloc\fP, and \fBpcre_stack_free\fP, and the
-callout function pointed to by \fBpcre_callout\fP, are shared by all threads.
-.P
-The compiled form of a regular expression is not altered during matching, so
-the same compiled pattern can safely be used by several threads at once.
-.
-.
-.SH "SAVING PRECOMPILED PATTERNS FOR LATER USE"
-.rs
-.sp
-The compiled form of a regular expression can be saved and re-used at a later
-time, possibly by a different program, and even on a host other than the one on
-which it was compiled. Details are given in the
-.\" HREF
-\fBpcreprecompile\fP
-.\"
-documentation.
-.
-.
-.SH "CHECKING BUILD-TIME OPTIONS"
-.rs
-.sp
-.B int pcre_config(int \fIwhat\fP, void *\fIwhere\fP);
-.PP
-The function \fBpcre_config()\fP makes it possible for a PCRE client to
-discover which optional features have been compiled into the PCRE library. The
-.\" HREF
-\fBpcrebuild\fP
-.\"
-documentation has more details about these optional features.
-.P
-The first argument for \fBpcre_config()\fP is an integer, specifying which
-information is required; the second argument is a pointer to a variable into
-which the information is placed. The following information is available:
-.sp
- PCRE_CONFIG_UTF8
-.sp
-The output is an integer that is set to one if UTF-8 support is available;
-otherwise it is set to zero.
-.sp
- PCRE_CONFIG_UNICODE_PROPERTIES
-.sp
-The output is an integer that is set to one if support for Unicode character
-properties is available; otherwise it is set to zero.
-.sp
- PCRE_CONFIG_NEWLINE
-.sp
-The output is an integer that is set to the value of the code that is used for
-the newline character. It is either linefeed (10) or carriage return (13), and
-should normally be the standard character for your operating system.
-.sp
- PCRE_CONFIG_LINK_SIZE
-.sp
-The output is an integer that contains the number of bytes used for internal
-linkage in compiled regular expressions. The value is 2, 3, or 4. Larger values
-allow larger regular expressions to be compiled, at the expense of slower
-matching. The default value of 2 is sufficient for all but the most massive
-patterns, since it allows the compiled pattern to be up to 64K in size.
-.sp
- PCRE_CONFIG_POSIX_MALLOC_THRESHOLD
-.sp
-The output is an integer that contains the threshold above which the POSIX
-interface uses \fBmalloc()\fP for output vectors. Further details are given in
-the
-.\" HREF
-\fBpcreposix\fP
-.\"
-documentation.
-.sp
- PCRE_CONFIG_MATCH_LIMIT
-.sp
-The output is an integer that gives the default limit for the number of
-internal matching function calls in a \fBpcre_exec()\fP execution. Further
-details are given with \fBpcre_exec()\fP below.
-.sp
- PCRE_CONFIG_STACKRECURSE
-.sp
-The output is an integer that is set to one if internal recursion is
-implemented by recursive function calls that use the stack to remember their
-state. This is the usual way that PCRE is compiled. The output is zero if PCRE
-was compiled to use blocks of data on the heap instead of recursive function
-calls. In this case, \fBpcre_stack_malloc\fP and \fBpcre_stack_free\fP are
-called to manage memory blocks on the heap, thus avoiding the use of the stack.
-.
-.
-.SH "COMPILING A PATTERN"
-.rs
-.sp
-.B pcre *pcre_compile(const char *\fIpattern\fP, int \fIoptions\fP,
-.ti +5n
-.B const char **\fIerrptr\fP, int *\fIerroffset\fP,
-.ti +5n
-.B const unsigned char *\fItableptr\fP);
-.P
-The function \fBpcre_compile()\fP is called to compile a pattern into an
-internal form. The pattern is a C string terminated by a binary zero, and
-is passed in the \fIpattern\fP argument. A pointer to a single block of memory
-that is obtained via \fBpcre_malloc\fP is returned. This contains the compiled
-code and related data. The \fBpcre\fP type is defined for the returned block;
-this is a typedef for a structure whose contents are not externally defined. It
-is up to the caller to free the memory when it is no longer required.
-.P
-Although the compiled code of a PCRE regex is relocatable, that is, it does not
-depend on memory location, the complete \fBpcre\fP data block is not
-fully relocatable, because it may contain a copy of the \fItableptr\fP
-argument, which is an address (see below).
-.P
-The \fIoptions\fP argument contains independent bits that affect the
-compilation. It should be zero if no options are required. The available
-options are described below. Some of them, in particular, those that are
-compatible with Perl, can also be set and unset from within the pattern (see
-the detailed description in the
-.\" HREF
-\fBpcrepattern\fP
-.\"
-documentation). For these options, the contents of the \fIoptions\fP argument
-specifies their initial settings at the start of compilation and execution. The
-PCRE_ANCHORED option can be set at the time of matching as well as at compile
-time.
-.P
-If \fIerrptr\fP is NULL, \fBpcre_compile()\fP returns NULL immediately.
-Otherwise, if compilation of a pattern fails, \fBpcre_compile()\fP returns
-NULL, and sets the variable pointed to by \fIerrptr\fP to point to a textual
-error message. The offset from the start of the pattern to the character where
-the error was discovered is placed in the variable pointed to by
-\fIerroffset\fP, which must not be NULL. If it is, an immediate error is given.
-.P
-If the final argument, \fItableptr\fP, is NULL, PCRE uses a default set of
-character tables that are built when PCRE is compiled, using the default C
-locale. Otherwise, \fItableptr\fP must be an address that is the result of a
-call to \fBpcre_maketables()\fP. This value is stored with the compiled
-pattern, and used again by \fBpcre_exec()\fP, unless another table pointer is
-passed to it. For more discussion, see the section on locale support below.
-.P
-This code fragment shows a typical straightforward call to \fBpcre_compile()\fP:
-.sp
- pcre *re;
- const char *error;
- int erroffset;
- re = pcre_compile(
- "^A.*Z", /* the pattern */
- 0, /* default options */
- &error, /* for error message */
- &erroffset, /* for error offset */
- NULL); /* use default character tables */
-.sp
-The following names for option bits are defined in the \fBpcre.h\fP header
-file:
-.sp
- PCRE_ANCHORED
-.sp
-If this bit is set, the pattern is forced to be "anchored", that is, it is
-constrained to match only at the first matching point in the string that is
-being searched (the "subject string"). This effect can also be achieved by
-appropriate constructs in the pattern itself, which is the only way to do it in
-Perl.
-.sp
- PCRE_AUTO_CALLOUT
-.sp
-If this bit is set, \fBpcre_compile()\fP automatically inserts callout items,
-all with number 255, before each pattern item. For discussion of the callout
-facility, see the
-.\" HREF
-\fBpcrecallout\fP
-.\"
-documentation.
-.sp
- PCRE_CASELESS
-.sp
-If this bit is set, letters in the pattern match both upper and lower case
-letters. It is equivalent to Perl's /i option, and it can be changed within a
-pattern by a (?i) option setting. When running in UTF-8 mode, case support for
-high-valued characters is available only when PCRE is built with Unicode
-character property support.
-.sp
- PCRE_DOLLAR_ENDONLY
-.sp
-If this bit is set, a dollar metacharacter in the pattern matches only at the
-end of the subject string. Without this option, a dollar also matches
-immediately before the final character if it is a newline (but not before any
-other newlines). The PCRE_DOLLAR_ENDONLY option is ignored if PCRE_MULTILINE is
-set. There is no equivalent to this option in Perl, and no way to set it within
-a pattern.
-.sp
- PCRE_DOTALL
-.sp
-If this bit is set, a dot metacharater in the pattern matches all characters,
-including newlines. Without it, newlines are excluded. This option is
-equivalent to Perl's /s option, and it can be changed within a pattern by a
-(?s) option setting. A negative class such as [^a] always matches a newline
-character, independent of the setting of this option.
-.sp
- PCRE_EXTENDED
-.sp
-If this bit is set, whitespace data characters in the pattern are totally
-ignored except when escaped or inside a character class. Whitespace does not
-include the VT character (code 11). In addition, characters between an
-unescaped # outside a character class and the next newline character,
-inclusive, are also ignored. This is equivalent to Perl's /x option, and it can
-be changed within a pattern by a (?x) option setting.
-.P
-This option makes it possible to include comments inside complicated patterns.
-Note, however, that this applies only to data characters. Whitespace characters
-may never appear within special character sequences in a pattern, for example
-within the sequence (?( which introduces a conditional subpattern.
-.sp
- PCRE_EXTRA
-.sp
-This option was invented in order to turn on additional functionality of PCRE
-that is incompatible with Perl, but it is currently of very little use. When
-set, any backslash in a pattern that is followed by a letter that has no
-special meaning causes an error, thus reserving these combinations for future
-expansion. By default, as in Perl, a backslash followed by a letter with no
-special meaning is treated as a literal. There are at present no other features
-controlled by this option. It can also be set by a (?X) option setting within a
-pattern.
-.sp
- PCRE_MULTILINE
-.sp
-By default, PCRE treats the subject string as consisting of a single line of
-characters (even if it actually contains newlines). The "start of line"
-metacharacter (^) matches only at the start of the string, while the "end of
-line" metacharacter ($) matches only at the end of the string, or before a
-terminating newline (unless PCRE_DOLLAR_ENDONLY is set). This is the same as
-Perl.
-.P
-When PCRE_MULTILINE it is set, the "start of line" and "end of line" constructs
-match immediately following or immediately before any newline in the subject
-string, respectively, as well as at the very start and end. This is equivalent
-to Perl's /m option, and it can be changed within a pattern by a (?m) option
-setting. If there are no "\en" characters in a subject string, or no
-occurrences of ^ or $ in a pattern, setting PCRE_MULTILINE has no effect.
-.sp
- PCRE_NO_AUTO_CAPTURE
-.sp
-If this option is set, it disables the use of numbered capturing parentheses in
-the pattern. Any opening parenthesis that is not followed by ? behaves as if it
-were followed by ?: but named parentheses can still be used for capturing (and
-they acquire numbers in the usual way). There is no equivalent of this option
-in Perl.
-.sp
- PCRE_UNGREEDY
-.sp
-This option inverts the "greediness" of the quantifiers so that they are not
-greedy by default, but become greedy if followed by "?". It is not compatible
-with Perl. It can also be set by a (?U) option setting within the pattern.
-.sp
- PCRE_UTF8
-.sp
-This option causes PCRE to regard both the pattern and the subject as strings
-of UTF-8 characters instead of single-byte character strings. However, it is
-available only when PCRE is built to include UTF-8 support. If not, the use
-of this option provokes an error. Details of how this option changes the
-behaviour of PCRE are given in the
-.\" HTML <a href="pcre.html#utf8support">
-.\" </a>
-section on UTF-8 support
-.\"
-in the main
-.\" HREF
-\fBpcre\fP
-.\"
-page.
-.sp
- PCRE_NO_UTF8_CHECK
-.sp
-When PCRE_UTF8 is set, the validity of the pattern as a UTF-8 string is
-automatically checked. If an invalid UTF-8 sequence of bytes is found,
-\fBpcre_compile()\fP returns an error. If you already know that your pattern is
-valid, and you want to skip this check for performance reasons, you can set the
-PCRE_NO_UTF8_CHECK option. When it is set, the effect of passing an invalid
-UTF-8 string as a pattern is undefined. It may cause your program to crash.
-Note that this option can also be passed to \fBpcre_exec()\fP, to suppress the
-UTF-8 validity checking of subject strings.
-.
-.
-.SH "STUDYING A PATTERN"
-.rs
-.sp
-.B pcre_extra *pcre_study(const pcre *\fIcode\fP, int \fIoptions\fP,
-.ti +5n
-.B const char **\fIerrptr\fP);
-.PP
-If a compiled pattern is going to be used several times, it is worth spending
-more time analyzing it in order to speed up the time taken for matching. The
-function \fBpcre_study()\fP takes a pointer to a compiled pattern as its first
-argument. If studying the pattern produces additional information that will
-help speed up matching, \fBpcre_study()\fP returns a pointer to a
-\fBpcre_extra\fP block, in which the \fIstudy_data\fP field points to the
-results of the study.
-.P
-The returned value from \fBpcre_study()\fP can be passed directly to
-\fBpcre_exec()\fP. However, a \fBpcre_extra\fP block also contains other
-fields that can be set by the caller before the block is passed; these are
-described
-.\" HTML <a href="#extradata">
-.\" </a>
-below
-.\"
-in the section on matching a pattern.
-.P
-If studying the pattern does not produce any additional information,
-\fBpcre_study()\fP returns NULL. In that circumstance, if the calling program
-wants to pass any of the other fields to \fBpcre_exec()\fP, it must set up its
-own \fBpcre_extra\fP block.
-.P
-The second argument of \fBpcre_study()\fP contains option bits. At present, no
-options are defined, and this argument should always be zero.
-.P
-The third argument for \fBpcre_study()\fP is a pointer for an error message. If
-studying succeeds (even if no data is returned), the variable it points to is
-set to NULL. Otherwise it points to a textual error message. You should
-therefore test the error pointer for NULL after calling \fBpcre_study()\fP, to
-be sure that it has run successfully.
-.P
-This is a typical call to \fBpcre_study\fP():
-.sp
- pcre_extra *pe;
- pe = pcre_study(
- re, /* result of pcre_compile() */
- 0, /* no options exist */
- &error); /* set to NULL or points to a message */
-.sp
-At present, studying a pattern is useful only for non-anchored patterns that do
-not have a single fixed starting character. A bitmap of possible starting
-bytes is created.
-.
-.
-.\" HTML <a name="localesupport"></a>
-.SH "LOCALE SUPPORT"
-.rs
-.sp
-PCRE handles caseless matching, and determines whether characters are letters,
-digits, or whatever, by reference to a set of tables, indexed by character
-value. (When running in UTF-8 mode, this applies only to characters with codes
-less than 128. Higher-valued codes never match escapes such as \ew or \ed, but
-can be tested with \ep if PCRE is built with Unicode character property
-support.)
-.P
-An internal set of tables is created in the default C locale when PCRE is
-built. This is used when the final argument of \fBpcre_compile()\fP is NULL,
-and is sufficient for many applications. An alternative set of tables can,
-however, be supplied. These may be created in a different locale from the
-default. As more and more applications change to using Unicode, the need for
-this locale support is expected to die away.
-.P
-External tables are built by calling the \fBpcre_maketables()\fP function,
-which has no arguments, in the relevant locale. The result can then be passed
-to \fBpcre_compile()\fP or \fBpcre_exec()\fP as often as necessary. For
-example, to build and use tables that are appropriate for the French locale
-(where accented characters with values greater than 128 are treated as letters),
-the following code could be used:
-.sp
- setlocale(LC_CTYPE, "fr_FR");
- tables = pcre_maketables();
- re = pcre_compile(..., tables);
-.sp
-When \fBpcre_maketables()\fP runs, the tables are built in memory that is
-obtained via \fBpcre_malloc\fP. It is the caller's responsibility to ensure
-that the memory containing the tables remains available for as long as it is
-needed.
-.P
-The pointer that is passed to \fBpcre_compile()\fP is saved with the compiled
-pattern, and the same tables are used via this pointer by \fBpcre_study()\fP
-and normally also by \fBpcre_exec()\fP. Thus, by default, for any single
-pattern, compilation, studying and matching all happen in the same locale, but
-different patterns can be compiled in different locales.
-.P
-It is possible to pass a table pointer or NULL (indicating the use of the
-internal tables) to \fBpcre_exec()\fP. Although not intended for this purpose,
-this facility could be used to match a pattern in a different locale from the
-one in which it was compiled. Passing table pointers at run time is discussed
-below in the section on matching a pattern.
-.
-.
-.SH "INFORMATION ABOUT A PATTERN"
-.rs
-.sp
-.B int pcre_fullinfo(const pcre *\fIcode\fP, "const pcre_extra *\fIextra\fP,"
-.ti +5n
-.B int \fIwhat\fP, void *\fIwhere\fP);
-.PP
-The \fBpcre_fullinfo()\fP function returns information about a compiled
-pattern. It replaces the obsolete \fBpcre_info()\fP function, which is
-nevertheless retained for backwards compability (and is documented below).
-.P
-The first argument for \fBpcre_fullinfo()\fP is a pointer to the compiled
-pattern. The second argument is the result of \fBpcre_study()\fP, or NULL if
-the pattern was not studied. The third argument specifies which piece of
-information is required, and the fourth argument is a pointer to a variable
-to receive the data. The yield of the function is zero for success, or one of
-the following negative numbers:
-.sp
- PCRE_ERROR_NULL the argument \fIcode\fP was NULL
- the argument \fIwhere\fP was NULL
- PCRE_ERROR_BADMAGIC the "magic number" was not found
- PCRE_ERROR_BADOPTION the value of \fIwhat\fP was invalid
-.sp
-The "magic number" is placed at the start of each compiled pattern as an simple
-check against passing an arbitrary memory pointer. Here is a typical call of
-\fBpcre_fullinfo()\fP, to obtain the length of the compiled pattern:
-.sp
- int rc;
- unsigned long int length;
- rc = pcre_fullinfo(
- re, /* result of pcre_compile() */
- pe, /* result of pcre_study(), or NULL */
- PCRE_INFO_SIZE, /* what is required */
- &length); /* where to put the data */
-.sp
-The possible values for the third argument are defined in \fBpcre.h\fP, and are
-as follows:
-.sp
- PCRE_INFO_BACKREFMAX
-.sp
-Return the number of the highest back reference in the pattern. The fourth
-argument should point to an \fBint\fP variable. Zero is returned if there are
-no back references.
-.sp
- PCRE_INFO_CAPTURECOUNT
-.sp
-Return the number of capturing subpatterns in the pattern. The fourth argument
-should point to an \fBint\fP variable.
-.sp
- PCRE_INFO_DEFAULTTABLES
-.sp
-Return a pointer to the internal default character tables within PCRE. The
-fourth argument should point to an \fBunsigned char *\fP variable. This
-information call is provided for internal use by the \fBpcre_study()\fP
-function. External callers can cause PCRE to use its internal tables by passing
-a NULL table pointer.
-.sp
- PCRE_INFO_FIRSTBYTE
-.sp
-Return information about the first byte of any matched string, for a
-non-anchored pattern. (This option used to be called PCRE_INFO_FIRSTCHAR; the
-old name is still recognized for backwards compatibility.)
-.P
-If there is a fixed first byte, for example, from a pattern such as
-(cat|cow|coyote), it is returned in the integer pointed to by \fIwhere\fP.
-Otherwise, if either
-.sp
-(a) the pattern was compiled with the PCRE_MULTILINE option, and every branch
-starts with "^", or
-.sp
-(b) every branch of the pattern starts with ".*" and PCRE_DOTALL is not set
-(if it were set, the pattern would be anchored),
-.sp
--1 is returned, indicating that the pattern matches only at the start of a
-subject string or after any newline within the string. Otherwise -2 is
-returned. For anchored patterns, -2 is returned.
-.sp
- PCRE_INFO_FIRSTTABLE
-.sp
-If the pattern was studied, and this resulted in the construction of a 256-bit
-table indicating a fixed set of bytes for the first byte in any matching
-string, a pointer to the table is returned. Otherwise NULL is returned. The
-fourth argument should point to an \fBunsigned char *\fP variable.
-.sp
- PCRE_INFO_LASTLITERAL
-.sp
-Return the value of the rightmost literal byte that must exist in any matched
-string, other than at its start, if such a byte has been recorded. The fourth
-argument should point to an \fBint\fP variable. If there is no such byte, -1 is
-returned. For anchored patterns, a last literal byte is recorded only if it
-follows something of variable length. For example, for the pattern
-/^a\ed+z\ed+/ the returned value is "z", but for /^a\edz\ed/ the returned value
-is -1.
-.sp
- PCRE_INFO_NAMECOUNT
- PCRE_INFO_NAMEENTRYSIZE
- PCRE_INFO_NAMETABLE
-.sp
-PCRE supports the use of named as well as numbered capturing parentheses. The
-names are just an additional way of identifying the parentheses, which still
-acquire numbers. A convenience function called \fBpcre_get_named_substring()\fP
-is provided for extracting an individual captured substring by name. It is also
-possible to extract the data directly, by first converting the name to a number
-in order to access the correct pointers in the output vector (described with
-\fBpcre_exec()\fP below). To do the conversion, you need to use the
-name-to-number map, which is described by these three values.
-.P
-The map consists of a number of fixed-size entries. PCRE_INFO_NAMECOUNT gives
-the number of entries, and PCRE_INFO_NAMEENTRYSIZE gives the size of each
-entry; both of these return an \fBint\fP value. The entry size depends on the
-length of the longest name. PCRE_INFO_NAMETABLE returns a pointer to the first
-entry of the table (a pointer to \fBchar\fP). The first two bytes of each entry
-are the number of the capturing parenthesis, most significant byte first. The
-rest of the entry is the corresponding name, zero terminated. The names are in
-alphabetical order. For example, consider the following pattern (assume
-PCRE_EXTENDED is set, so white space - including newlines - is ignored):
-.sp
-.\" JOIN
- (?P<date> (?P<year>(\ed\ed)?\ed\ed) -
- (?P<month>\ed\ed) - (?P<day>\ed\ed) )
-.sp
-There are four named subpatterns, so the table has four entries, and each entry
-in the table is eight bytes long. The table is as follows, with non-printing
-bytes shows in hexadecimal, and undefined bytes shown as ??:
-.sp
- 00 01 d a t e 00 ??
- 00 05 d a y 00 ?? ??
- 00 04 m o n t h 00
- 00 02 y e a r 00 ??
-.sp
-When writing code to extract data from named subpatterns using the
-name-to-number map, remember that the length of each entry is likely to be
-different for each compiled pattern.
-.sp
- PCRE_INFO_OPTIONS
-.sp
-Return a copy of the options with which the pattern was compiled. The fourth
-argument should point to an \fBunsigned long int\fP variable. These option bits
-are those specified in the call to \fBpcre_compile()\fP, modified by any
-top-level option settings within the pattern itself.
-.P
-A pattern is automatically anchored by PCRE if all of its top-level
-alternatives begin with one of the following:
-.sp
- ^ unless PCRE_MULTILINE is set
- \eA always
- \eG always
-.\" JOIN
- .* if PCRE_DOTALL is set and there are no back
- references to the subpattern in which .* appears
-.sp
-For such patterns, the PCRE_ANCHORED bit is set in the options returned by
-\fBpcre_fullinfo()\fP.
-.sp
- PCRE_INFO_SIZE
-.sp
-Return the size of the compiled pattern, that is, the value that was passed as
-the argument to \fBpcre_malloc()\fP when PCRE was getting memory in which to
-place the compiled data. The fourth argument should point to a \fBsize_t\fP
-variable.
-.sp
- PCRE_INFO_STUDYSIZE
-.sp
-Return the size of the data block pointed to by the \fIstudy_data\fP field in
-a \fBpcre_extra\fP block. That is, it is the value that was passed to
-\fBpcre_malloc()\fP when PCRE was getting memory into which to place the data
-created by \fBpcre_study()\fP. The fourth argument should point to a
-\fBsize_t\fP variable.
-.
-.
-.SH "OBSOLETE INFO FUNCTION"
-.rs
-.sp
-.B int pcre_info(const pcre *\fIcode\fP, int *\fIoptptr\fP, int
-.B *\fIfirstcharptr\fP);
-.PP
-The \fBpcre_info()\fP function is now obsolete because its interface is too
-restrictive to return all the available data about a compiled pattern. New
-programs should use \fBpcre_fullinfo()\fP instead. The yield of
-\fBpcre_info()\fP is the number of capturing subpatterns, or one of the
-following negative numbers:
-.sp
- PCRE_ERROR_NULL the argument \fIcode\fP was NULL
- PCRE_ERROR_BADMAGIC the "magic number" was not found
-.sp
-If the \fIoptptr\fP argument is not NULL, a copy of the options with which the
-pattern was compiled is placed in the integer it points to (see
-PCRE_INFO_OPTIONS above).
-.P
-If the pattern is not anchored and the \fIfirstcharptr\fP argument is not NULL,
-it is used to pass back information about the first character of any matched
-string (see PCRE_INFO_FIRSTBYTE above).
-.
-.
-.SH "MATCHING A PATTERN"
-.rs
-.sp
-.B int pcre_exec(const pcre *\fIcode\fP, "const pcre_extra *\fIextra\fP,"
-.ti +5n
-.B "const char *\fIsubject\fP," int \fIlength\fP, int \fIstartoffset\fP,
-.ti +5n
-.B int \fIoptions\fP, int *\fIovector\fP, int \fIovecsize\fP);
-.P
-The function \fBpcre_exec()\fP is called to match a subject string against a
-compiled pattern, which is passed in the \fIcode\fP argument. If the
-pattern has been studied, the result of the study should be passed in the
-\fIextra\fP argument.
-.P
-In most applications, the pattern will have been compiled (and optionally
-studied) in the same process that calls \fBpcre_exec()\fP. However, it is
-possible to save compiled patterns and study data, and then use them later
-in different processes, possibly even on different hosts. For a discussion
-about this, see the
-.\" HREF
-\fBpcreprecompile\fP
-.\"
-documentation.
-.P
-Here is an example of a simple call to \fBpcre_exec()\fP:
-.sp
- int rc;
- int ovector[30];
- rc = pcre_exec(
- re, /* result of pcre_compile() */
- NULL, /* we didn't study the pattern */
- "some string", /* the subject string */
- 11, /* the length of the subject string */
- 0, /* start at offset 0 in the subject */
- 0, /* default options */
- ovector, /* vector of integers for substring information */
- 30); /* number of elements in the vector (NOT size in bytes) */
-.
-.\" HTML <a name="extradata"></a>
-.SS "Extra data for \fBpcre_exec()\fR"
-.rs
-.sp
-If the \fIextra\fP argument is not NULL, it must point to a \fBpcre_extra\fP
-data block. The \fBpcre_study()\fP function returns such a block (when it
-doesn't return NULL), but you can also create one for yourself, and pass
-additional information in it. The fields in a \fBpcre_extra\fP block are as
-follows:
-.sp
- unsigned long int \fIflags\fP;
- void *\fIstudy_data\fP;
- unsigned long int \fImatch_limit\fP;
- void *\fIcallout_data\fP;
- const unsigned char *\fItables\fP;
-.sp
-The \fIflags\fP field is a bitmap that specifies which of the other fields
-are set. The flag bits are:
-.sp
- PCRE_EXTRA_STUDY_DATA
- PCRE_EXTRA_MATCH_LIMIT
- PCRE_EXTRA_CALLOUT_DATA
- PCRE_EXTRA_TABLES
-.sp
-Other flag bits should be set to zero. The \fIstudy_data\fP field is set in the
-\fBpcre_extra\fP block that is returned by \fBpcre_study()\fP, together with
-the appropriate flag bit. You should not set this yourself, but you may add to
-the block by setting the other fields and their corresponding flag bits.
-.P
-The \fImatch_limit\fP field provides a means of preventing PCRE from using up a
-vast amount of resources when running patterns that are not going to match,
-but which have a very large number of possibilities in their search trees. The
-classic example is the use of nested unlimited repeats.
-.P
-Internally, PCRE uses a function called \fBmatch()\fP which it calls repeatedly
-(sometimes recursively). The limit is imposed on the number of times this
-function is called during a match, which has the effect of limiting the amount
-of recursion and backtracking that can take place. For patterns that are not
-anchored, the count starts from zero for each position in the subject string.
-.P
-The default limit for the library can be set when PCRE is built; the default
-default is 10 million, which handles all but the most extreme cases. You can
-reduce the default by suppling \fBpcre_exec()\fP with a \fBpcre_extra\fP block
-in which \fImatch_limit\fP is set to a smaller value, and
-PCRE_EXTRA_MATCH_LIMIT is set in the \fIflags\fP field. If the limit is
-exceeded, \fBpcre_exec()\fP returns PCRE_ERROR_MATCHLIMIT.
-.P
-The \fIpcre_callout\fP field is used in conjunction with the "callout" feature,
-which is described in the
-.\" HREF
-\fBpcrecallout\fP
-.\"
-documentation.
-.P
-The \fItables\fP field is used to pass a character tables pointer to
-\fBpcre_exec()\fP; this overrides the value that is stored with the compiled
-pattern. A non-NULL value is stored with the compiled pattern only if custom
-tables were supplied to \fBpcre_compile()\fP via its \fItableptr\fP argument.
-If NULL is passed to \fBpcre_exec()\fP using this mechanism, it forces PCRE's
-internal tables to be used. This facility is helpful when re-using patterns
-that have been saved after compiling with an external set of tables, because
-the external tables might be at a different address when \fBpcre_exec()\fP is
-called. See the
-.\" HREF
-\fBpcreprecompile\fP
-.\"
-documentation for a discussion of saving compiled patterns for later use.
-.
-.SS "Option bits for \fBpcre_exec()\fP"
-.rs
-.sp
-The unused bits of the \fIoptions\fP argument for \fBpcre_exec()\fP must be
-zero. The only bits that may be set are PCRE_ANCHORED, PCRE_NOTBOL,
-PCRE_NOTEOL, PCRE_NOTEMPTY, PCRE_NO_UTF8_CHECK and PCRE_PARTIAL.
-.sp
- PCRE_ANCHORED
-.sp
-The PCRE_ANCHORED option limits \fBpcre_exec()\fP to matching at the first
-matching position. If a pattern was compiled with PCRE_ANCHORED, or turned out
-to be anchored by virtue of its contents, it cannot be made unachored at
-matching time.
-.sp
- PCRE_NOTBOL
-.sp
-This option specifies that first character of the subject string is not the
-beginning of a line, so the circumflex metacharacter should not match before
-it. Setting this without PCRE_MULTILINE (at compile time) causes circumflex
-never to match. This option affects only the behaviour of the circumflex
-metacharacter. It does not affect \eA.
-.sp
- PCRE_NOTEOL
-.sp
-This option specifies that the end of the subject string is not the end of a
-line, so the dollar metacharacter should not match it nor (except in multiline
-mode) a newline immediately before it. Setting this without PCRE_MULTILINE (at
-compile time) causes dollar never to match. This option affects only the
-behaviour of the dollar metacharacter. It does not affect \eZ or \ez.
-.sp
- PCRE_NOTEMPTY
-.sp
-An empty string is not considered to be a valid match if this option is set. If
-there are alternatives in the pattern, they are tried. If all the alternatives
-match the empty string, the entire match fails. For example, if the pattern
-.sp
- a?b?
-.sp
-is applied to a string not beginning with "a" or "b", it matches the empty
-string at the start of the subject. With PCRE_NOTEMPTY set, this match is not
-valid, so PCRE searches further into the string for occurrences of "a" or "b".
-.P
-Perl has no direct equivalent of PCRE_NOTEMPTY, but it does make a special case
-of a pattern match of the empty string within its \fBsplit()\fP function, and
-when using the /g modifier. It is possible to emulate Perl's behaviour after
-matching a null string by first trying the match again at the same offset with
-PCRE_NOTEMPTY and PCRE_ANCHORED, and then if that fails by advancing the
-starting offset (see below) and trying an ordinary match again. There is some
-code that demonstrates how to do this in the \fIpcredemo.c\fP sample program.
-.sp
- PCRE_NO_UTF8_CHECK
-.sp
-When PCRE_UTF8 is set at compile time, the validity of the subject as a UTF-8
-string is automatically checked when \fBpcre_exec()\fP is subsequently called.
-The value of \fIstartoffset\fP is also checked to ensure that it points to the
-start of a UTF-8 character. If an invalid UTF-8 sequence of bytes is found,
-\fBpcre_exec()\fP returns the error PCRE_ERROR_BADUTF8. If \fIstartoffset\fP
-contains an invalid value, PCRE_ERROR_BADUTF8_OFFSET is returned.
-.P
-If you already know that your subject is valid, and you want to skip these
-checks for performance reasons, you can set the PCRE_NO_UTF8_CHECK option when
-calling \fBpcre_exec()\fP. You might want to do this for the second and
-subsequent calls to \fBpcre_exec()\fP if you are making repeated calls to find
-all the matches in a single subject string. However, you should be sure that
-the value of \fIstartoffset\fP points to the start of a UTF-8 character. When
-PCRE_NO_UTF8_CHECK is set, the effect of passing an invalid UTF-8 string as a
-subject, or a value of \fIstartoffset\fP that does not point to the start of a
-UTF-8 character, is undefined. Your program may crash.
-.sp
- PCRE_PARTIAL
-.sp
-This option turns on the partial matching feature. If the subject string fails
-to match the pattern, but at some point during the matching process the end of
-the subject was reached (that is, the subject partially matches the pattern and
-the failure to match occurred only because there were not enough subject
-characters), \fBpcre_exec()\fP returns PCRE_ERROR_PARTIAL instead of
-PCRE_ERROR_NOMATCH. When PCRE_PARTIAL is used, there are restrictions on what
-may appear in the pattern. These are discussed in the
-.\" HREF
-\fBpcrepartial\fP
-.\"
-documentation.
-.
-.SS "The string to be matched by \fBpcre_exec()\fP"
-.rs
-.sp
-The subject string is passed to \fBpcre_exec()\fP as a pointer in
-\fIsubject\fP, a length in \fIlength\fP, and a starting byte offset in
-\fIstartoffset\fP. In UTF-8 mode, the byte offset must point to the start of a
-UTF-8 character. Unlike the pattern string, the subject may contain binary zero
-bytes. When the starting offset is zero, the search for a match starts at the
-beginning of the subject, and this is by far the most common case.
-.P
-A non-zero starting offset is useful when searching for another match in the
-same subject by calling \fBpcre_exec()\fP again after a previous success.
-Setting \fIstartoffset\fP differs from just passing over a shortened string and
-setting PCRE_NOTBOL in the case of a pattern that begins with any kind of
-lookbehind. For example, consider the pattern
-.sp
- \eBiss\eB
-.sp
-which finds occurrences of "iss" in the middle of words. (\eB matches only if
-the current position in the subject is not a word boundary.) When applied to
-the string "Mississipi" the first call to \fBpcre_exec()\fP finds the first
-occurrence. If \fBpcre_exec()\fP is called again with just the remainder of the
-subject, namely "issipi", it does not match, because \eB is always false at the
-start of the subject, which is deemed to be a word boundary. However, if
-\fBpcre_exec()\fP is passed the entire string again, but with \fIstartoffset\fP
-set to 4, it finds the second occurrence of "iss" because it is able to look
-behind the starting point to discover that it is preceded by a letter.
-.P
-If a non-zero starting offset is passed when the pattern is anchored, one
-attempt to match at the given offset is made. This can only succeed if the
-pattern does not require the match to be at the start of the subject.
-.
-.SS "How \fBpcre_exec()\fP returns captured substrings"
-.rs
-.sp
-In general, a pattern matches a certain portion of the subject, and in
-addition, further substrings from the subject may be picked out by parts of the
-pattern. Following the usage in Jeffrey Friedl's book, this is called
-"capturing" in what follows, and the phrase "capturing subpattern" is used for
-a fragment of a pattern that picks out a substring. PCRE supports several other
-kinds of parenthesized subpattern that do not cause substrings to be captured.
-.P
-Captured substrings are returned to the caller via a vector of integer offsets
-whose address is passed in \fIovector\fP. The number of elements in the vector
-is passed in \fIovecsize\fP, which must be a non-negative number. \fBNote\fP:
-this argument is NOT the size of \fIovector\fP in bytes.
-.P
-The first two-thirds of the vector is used to pass back captured substrings,
-each substring using a pair of integers. The remaining third of the vector is
-used as workspace by \fBpcre_exec()\fP while matching capturing subpatterns,
-and is not available for passing back information. The length passed in
-\fIovecsize\fP should always be a multiple of three. If it is not, it is
-rounded down.
-.P
-When a match is successful, information about captured substrings is returned
-in pairs of integers, starting at the beginning of \fIovector\fP, and
-continuing up to two-thirds of its length at the most. The first element of a
-pair is set to the offset of the first character in a substring, and the second
-is set to the offset of the first character after the end of a substring. The
-first pair, \fIovector[0]\fP and \fIovector[1]\fP, identify the portion of the
-subject string matched by the entire pattern. The next pair is used for the
-first capturing subpattern, and so on. The value returned by \fBpcre_exec()\fP
-is the number of pairs that have been set. If there are no capturing
-subpatterns, the return value from a successful match is 1, indicating that
-just the first pair of offsets has been set.
-.P
-Some convenience functions are provided for extracting the captured substrings
-as separate strings. These are described in the following section.
-.P
-It is possible for an capturing subpattern number \fIn+1\fP to match some
-part of the subject when subpattern \fIn\fP has not been used at all. For
-example, if the string "abc" is matched against the pattern (a|(z))(bc)
-subpatterns 1 and 3 are matched, but 2 is not. When this happens, both offset
-values corresponding to the unused subpattern are set to -1.
-.P
-If a capturing subpattern is matched repeatedly, it is the last portion of the
-string that it matched that is returned.
-.P
-If the vector is too small to hold all the captured substring offsets, it is
-used as far as possible (up to two-thirds of its length), and the function
-returns a value of zero. In particular, if the substring offsets are not of
-interest, \fBpcre_exec()\fP may be called with \fIovector\fP passed as NULL and
-\fIovecsize\fP as zero. However, if the pattern contains back references and
-the \fIovector\fP is not big enough to remember the related substrings, PCRE
-has to get additional memory for use during matching. Thus it is usually
-advisable to supply an \fIovector\fP.
-.P
-Note that \fBpcre_info()\fP can be used to find out how many capturing
-subpatterns there are in a compiled pattern. The smallest size for
-\fIovector\fP that will allow for \fIn\fP captured substrings, in addition to
-the offsets of the substring matched by the whole pattern, is (\fIn\fP+1)*3.
-.
-.SS "Return values from \fBpcre_exec()\fP"
-.rs
-.sp
-If \fBpcre_exec()\fP fails, it returns a negative number. The following are
-defined in the header file:
-.sp
- PCRE_ERROR_NOMATCH (-1)
-.sp
-The subject string did not match the pattern.
-.sp
- PCRE_ERROR_NULL (-2)
-.sp
-Either \fIcode\fP or \fIsubject\fP was passed as NULL, or \fIovector\fP was
-NULL and \fIovecsize\fP was not zero.
-.sp
- PCRE_ERROR_BADOPTION (-3)
-.sp
-An unrecognized bit was set in the \fIoptions\fP argument.
-.sp
- PCRE_ERROR_BADMAGIC (-4)
-.sp
-PCRE stores a 4-byte "magic number" at the start of the compiled code, to catch
-the case when it is passed a junk pointer and to detect when a pattern that was
-compiled in an environment of one endianness is run in an environment with the
-other endianness. This is the error that PCRE gives when the magic number is
-not present.
-.sp
- PCRE_ERROR_UNKNOWN_NODE (-5)
-.sp
-While running the pattern match, an unknown item was encountered in the
-compiled pattern. This error could be caused by a bug in PCRE or by overwriting
-of the compiled pattern.
-.sp
- PCRE_ERROR_NOMEMORY (-6)
-.sp
-If a pattern contains back references, but the \fIovector\fP that is passed to
-\fBpcre_exec()\fP is not big enough to remember the referenced substrings, PCRE
-gets a block of memory at the start of matching to use for this purpose. If the
-call via \fBpcre_malloc()\fP fails, this error is given. The memory is
-automatically freed at the end of matching.
-.sp
- PCRE_ERROR_NOSUBSTRING (-7)
-.sp
-This error is used by the \fBpcre_copy_substring()\fP,
-\fBpcre_get_substring()\fP, and \fBpcre_get_substring_list()\fP functions (see
-below). It is never returned by \fBpcre_exec()\fP.
-.sp
- PCRE_ERROR_MATCHLIMIT (-8)
-.sp
-The recursion and backtracking limit, as specified by the \fImatch_limit\fP
-field in a \fBpcre_extra\fP structure (or defaulted) was reached. See the
-description above.
-.sp
- PCRE_ERROR_CALLOUT (-9)
-.sp
-This error is never generated by \fBpcre_exec()\fP itself. It is provided for
-use by callout functions that want to yield a distinctive error code. See the
-.\" HREF
-\fBpcrecallout\fP
-.\"
-documentation for details.
-.sp
- PCRE_ERROR_BADUTF8 (-10)
-.sp
-A string that contains an invalid UTF-8 byte sequence was passed as a subject.
-.sp
- PCRE_ERROR_BADUTF8_OFFSET (-11)
-.sp
-The UTF-8 byte sequence that was passed as a subject was valid, but the value
-of \fIstartoffset\fP did not point to the beginning of a UTF-8 character.
-.sp
- PCRE_ERROR_PARTIAL (-12)
-.sp
-The subject string did not match, but it did match partially. See the
-.\" HREF
-\fBpcrepartial\fP
-.\"
-documentation for details of partial matching.
-.sp
- PCRE_ERROR_BAD_PARTIAL (-13)
-.sp
-The PCRE_PARTIAL option was used with a compiled pattern containing items that
-are not supported for partial matching. See the
-.\" HREF
-\fBpcrepartial\fP
-.\"
-documentation for details of partial matching.
-.sp
- PCRE_ERROR_INTERNAL (-14)
-.sp
-An unexpected internal error has occurred. This error could be caused by a bug
-in PCRE or by overwriting of the compiled pattern.
-.sp
- PCRE_ERROR_BADCOUNT (-15)
-.sp
-This error is given if the value of the \fIovecsize\fP argument is negative.
-.
-.
-.SH "EXTRACTING CAPTURED SUBSTRINGS BY NUMBER"
-.rs
-.sp
-.B int pcre_copy_substring(const char *\fIsubject\fP, int *\fIovector\fP,
-.ti +5n
-.B int \fIstringcount\fP, int \fIstringnumber\fP, char *\fIbuffer\fP,
-.ti +5n
-.B int \fIbuffersize\fP);
-.PP
-.br
-.B int pcre_get_substring(const char *\fIsubject\fP, int *\fIovector\fP,
-.ti +5n
-.B int \fIstringcount\fP, int \fIstringnumber\fP,
-.ti +5n
-.B const char **\fIstringptr\fP);
-.PP
-.br
-.B int pcre_get_substring_list(const char *\fIsubject\fP,
-.ti +5n
-.B int *\fIovector\fP, int \fIstringcount\fP, "const char ***\fIlistptr\fP);"
-.PP
-Captured substrings can be accessed directly by using the offsets returned by
-\fBpcre_exec()\fP in \fIovector\fP. For convenience, the functions
-\fBpcre_copy_substring()\fP, \fBpcre_get_substring()\fP, and
-\fBpcre_get_substring_list()\fP are provided for extracting captured substrings
-as new, separate, zero-terminated strings. These functions identify substrings
-by number. The next section describes functions for extracting named
-substrings. A substring that contains a binary zero is correctly extracted and
-has a further zero added on the end, but the result is not, of course,
-a C string.
-.P
-The first three arguments are the same for all three of these functions:
-\fIsubject\fP is the subject string that has just been successfully matched,
-\fIovector\fP is a pointer to the vector of integer offsets that was passed to
-\fBpcre_exec()\fP, and \fIstringcount\fP is the number of substrings that were
-captured by the match, including the substring that matched the entire regular
-expression. This is the value returned by \fBpcre_exec()\fP if it is greater
-than zero. If \fBpcre_exec()\fP returned zero, indicating that it ran out of
-space in \fIovector\fP, the value passed as \fIstringcount\fP should be the
-number of elements in the vector divided by three.
-.P
-The functions \fBpcre_copy_substring()\fP and \fBpcre_get_substring()\fP
-extract a single substring, whose number is given as \fIstringnumber\fP. A
-value of zero extracts the substring that matched the entire pattern, whereas
-higher values extract the captured substrings. For \fBpcre_copy_substring()\fP,
-the string is placed in \fIbuffer\fP, whose length is given by
-\fIbuffersize\fP, while for \fBpcre_get_substring()\fP a new block of memory is
-obtained via \fBpcre_malloc\fP, and its address is returned via
-\fIstringptr\fP. The yield of the function is the length of the string, not
-including the terminating zero, or one of
-.sp
- PCRE_ERROR_NOMEMORY (-6)
-.sp
-The buffer was too small for \fBpcre_copy_substring()\fP, or the attempt to get
-memory failed for \fBpcre_get_substring()\fP.
-.sp
- PCRE_ERROR_NOSUBSTRING (-7)
-.sp
-There is no substring whose number is \fIstringnumber\fP.
-.P
-The \fBpcre_get_substring_list()\fP function extracts all available substrings
-and builds a list of pointers to them. All this is done in a single block of
-memory that is obtained via \fBpcre_malloc\fP. The address of the memory block
-is returned via \fIlistptr\fP, which is also the start of the list of string
-pointers. The end of the list is marked by a NULL pointer. The yield of the
-function is zero if all went well, or
-.sp
- PCRE_ERROR_NOMEMORY (-6)
-.sp
-if the attempt to get the memory block failed.
-.P
-When any of these functions encounter a substring that is unset, which can
-happen when capturing subpattern number \fIn+1\fP matches some part of the
-subject, but subpattern \fIn\fP has not been used at all, they return an empty
-string. This can be distinguished from a genuine zero-length substring by
-inspecting the appropriate offset in \fIovector\fP, which is negative for unset
-substrings.
-.P
-The two convenience functions \fBpcre_free_substring()\fP and
-\fBpcre_free_substring_list()\fP can be used to free the memory returned by
-a previous call of \fBpcre_get_substring()\fP or
-\fBpcre_get_substring_list()\fP, respectively. They do nothing more than call
-the function pointed to by \fBpcre_free\fP, which of course could be called
-directly from a C program. However, PCRE is used in some situations where it is
-linked via a special interface to another programming language which cannot use
-\fBpcre_free\fP directly; it is for these cases that the functions are
-provided.
-.
-.
-.SH "EXTRACTING CAPTURED SUBSTRINGS BY NAME"
-.rs
-.sp
-.B int pcre_get_stringnumber(const pcre *\fIcode\fP,
-.ti +5n
-.B const char *\fIname\fP);
-.PP
-.br
-.B int pcre_copy_named_substring(const pcre *\fIcode\fP,
-.ti +5n
-.B const char *\fIsubject\fP, int *\fIovector\fP,
-.ti +5n
-.B int \fIstringcount\fP, const char *\fIstringname\fP,
-.ti +5n
-.B char *\fIbuffer\fP, int \fIbuffersize\fP);
-.PP
-.br
-.B int pcre_get_named_substring(const pcre *\fIcode\fP,
-.ti +5n
-.B const char *\fIsubject\fP, int *\fIovector\fP,
-.ti +5n
-.B int \fIstringcount\fP, const char *\fIstringname\fP,
-.ti +5n
-.B const char **\fIstringptr\fP);
-.PP
-To extract a substring by name, you first have to find associated number.
-For example, for this pattern
-.sp
- (a+)b(?<xxx>\ed+)...
-.sp
-the number of the subpattern called "xxx" is 2. You can find the number from
-the name by calling \fBpcre_get_stringnumber()\fP. The first argument is the
-compiled pattern, and the second is the name. The yield of the function is the
-subpattern number, or PCRE_ERROR_NOSUBSTRING (-7) if there is no subpattern of
-that name.
-.P
-Given the number, you can extract the substring directly, or use one of the
-functions described in the previous section. For convenience, there are also
-two functions that do the whole job.
-.P
-Most of the arguments of \fIpcre_copy_named_substring()\fP and
-\fIpcre_get_named_substring()\fP are the same as those for the similarly named
-functions that extract by number. As these are described in the previous
-section, they are not re-described here. There are just two differences:
-.P
-First, instead of a substring number, a substring name is given. Second, there
-is an extra argument, given at the start, which is a pointer to the compiled
-pattern. This is needed in order to gain access to the name-to-number
-translation table.
-.P
-These functions call \fBpcre_get_stringnumber()\fP, and if it succeeds, they
-then call \fIpcre_copy_substring()\fP or \fIpcre_get_substring()\fP, as
-appropriate.
-.P
-.in 0
-Last updated: 09 September 2004
-.br
-Copyright (c) 1997-2004 University of Cambridge.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH "PCRE BUILD-TIME OPTIONS"
-.rs
-.sp
-This document describes the optional features of PCRE that can be selected when
-the library is compiled. They are all selected, or deselected, by providing
-options to the \fBconfigure\fP script that is run before the \fBmake\fP
-command. The complete list of options for \fBconfigure\fP (which includes the
-standard ones such as the selection of the installation directory) can be
-obtained by running
-.sp
- ./configure --help
-.sp
-The following sections describe certain options whose names begin with --enable
-or --disable. These settings specify changes to the defaults for the
-\fBconfigure\fP command. Because of the way that \fBconfigure\fP works,
---enable and --disable always come in pairs, so the complementary option always
-exists as well, but as it specifies the default, it is not described.
-.
-.SH "UTF-8 SUPPORT"
-.rs
-.sp
-To build PCRE with support for UTF-8 character strings, add
-.sp
- --enable-utf8
-.sp
-to the \fBconfigure\fP command. Of itself, this does not make PCRE treat
-strings as UTF-8. As well as compiling PCRE with this option, you also have
-have to set the PCRE_UTF8 option when you call the \fBpcre_compile()\fP
-function.
-.
-.SH "UNICODE CHARACTER PROPERTY SUPPORT"
-.rs
-.sp
-UTF-8 support allows PCRE to process character values greater than 255 in the
-strings that it handles. On its own, however, it does not provide any
-facilities for accessing the properties of such characters. If you want to be
-able to use the pattern escapes \eP, \ep, and \eX, which refer to Unicode
-character properties, you must add
-.sp
- --enable-unicode-properties
-.sp
-to the \fBconfigure\fP command. This implies UTF-8 support, even if you have
-not explicitly requested it.
-.P
-Including Unicode property support adds around 90K of tables to the PCRE
-library, approximately doubling its size. Only the general category properties
-such as \fILu\fP and \fINd\fP are supported. Details are given in the
-.\" HREF
-\fBpcrepattern\fP
-.\"
-documentation.
-.
-.SH "CODE VALUE OF NEWLINE"
-.rs
-.sp
-By default, PCRE treats character 10 (linefeed) as the newline character. This
-is the normal newline character on Unix-like systems. You can compile PCRE to
-use character 13 (carriage return) instead by adding
-.sp
- --enable-newline-is-cr
-.sp
-to the \fBconfigure\fP command. For completeness there is also a
---enable-newline-is-lf option, which explicitly specifies linefeed as the
-newline character.
-.
-.SH "BUILDING SHARED AND STATIC LIBRARIES"
-.rs
-.sp
-The PCRE building process uses \fBlibtool\fP to build both shared and static
-Unix libraries by default. You can suppress one of these by adding one of
-.sp
- --disable-shared
- --disable-static
-.sp
-to the \fBconfigure\fP command, as required.
-.
-.SH "POSIX MALLOC USAGE"
-.rs
-.sp
-When PCRE is called through the POSIX interface (see the
-.\" HREF
-\fBpcreposix\fP
-.\"
-documentation), additional working storage is required for holding the pointers
-to capturing substrings, because PCRE requires three integers per substring,
-whereas the POSIX interface provides only two. If the number of expected
-substrings is small, the wrapper function uses space on the stack, because this
-is faster than using \fBmalloc()\fP for each call. The default threshold above
-which the stack is no longer used is 10; it can be changed by adding a setting
-such as
-.sp
- --with-posix-malloc-threshold=20
-.sp
-to the \fBconfigure\fP command.
-.
-.SH "LIMITING PCRE RESOURCE USAGE"
-.rs
-.sp
-Internally, PCRE has a function called \fBmatch()\fP, which it calls repeatedly
-(possibly recursively) when matching a pattern. By controlling the maximum
-number of times this function may be called during a single matching operation,
-a limit can be placed on the resources used by a single call to
-\fBpcre_exec()\fP. The limit can be changed at run time, as described in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-documentation. The default is 10 million, but this can be changed by adding a
-setting such as
-.sp
- --with-match-limit=500000
-.sp
-to the \fBconfigure\fP command.
-.
-.SH "HANDLING VERY LARGE PATTERNS"
-.rs
-.sp
-Within a compiled pattern, offset values are used to point from one part to
-another (for example, from an opening parenthesis to an alternation
-metacharacter). By default, two-byte values are used for these offsets, leading
-to a maximum size for a compiled pattern of around 64K. This is sufficient to
-handle all but the most gigantic patterns. Nevertheless, some people do want to
-process enormous patterns, so it is possible to compile PCRE to use three-byte
-or four-byte offsets by adding a setting such as
-.sp
- --with-link-size=3
-.sp
-to the \fBconfigure\fP command. The value given must be 2, 3, or 4. Using
-longer offsets slows down the operation of PCRE because it has to load
-additional bytes when handling them.
-.P
-If you build PCRE with an increased link size, test 2 (and test 5 if you are
-using UTF-8) will fail. Part of the output of these tests is a representation
-of the compiled pattern, and this changes with the link size.
-.
-.SH "AVOIDING EXCESSIVE STACK USAGE"
-.rs
-.sp
-PCRE implements backtracking while matching by making recursive calls to an
-internal function called \fBmatch()\fP. In environments where the size of the
-stack is limited, this can severely limit PCRE's operation. (The Unix
-environment does not usually suffer from this problem.) An alternative approach
-that uses memory from the heap to remember data, instead of using recursive
-function calls, has been implemented to work round this problem. If you want to
-build a version of PCRE that works this way, add
-.sp
- --disable-stack-for-recursion
-.sp
-to the \fBconfigure\fP command. With this configuration, PCRE will use the
-\fBpcre_stack_malloc\fP and \fBpcre_stack_free\fP variables to call memory
-management functions. Separate functions are provided because the usage is very
-predictable: the block sizes requested are always the same, and the blocks are
-always freed in reverse order. A calling program might be able to implement
-optimized functions that perform better than the standard \fBmalloc()\fP and
-\fBfree()\fP functions. PCRE runs noticeably more slowly when built in this
-way.
-.
-.SH "USING EBCDIC CODE"
-.rs
-.sp
-PCRE assumes by default that it will run in an environment where the character
-code is ASCII (or Unicode, which is a superset of ASCII). PCRE can, however, be
-compiled to run in an EBCDIC environment by adding
-.sp
- --enable-ebcdic
-.sp
-to the \fBconfigure\fP command.
-.P
-.in 0
-Last updated: 09 September 2004
-.br
-Copyright (c) 1997-2004 University of Cambridge.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH "PCRE CALLOUTS"
-.rs
-.sp
-.B int (*pcre_callout)(pcre_callout_block *);
-.PP
-PCRE provides a feature called "callout", which is a means of temporarily
-passing control to the caller of PCRE in the middle of pattern matching. The
-caller of PCRE provides an external function by putting its entry point in the
-global variable \fIpcre_callout\fP. By default, this variable contains NULL,
-which disables all calling out.
-.P
-Within a regular expression, (?C) indicates the points at which the external
-function is to be called. Different callout points can be identified by putting
-a number less than 256 after the letter C. The default value is zero.
-For example, this pattern has two callout points:
-.sp
- (?C1)\deabc(?C2)def
-.sp
-If the PCRE_AUTO_CALLOUT option bit is set when \fBpcre_compile()\fP is called,
-PCRE automatically inserts callouts, all with number 255, before each item in
-the pattern. For example, if PCRE_AUTO_CALLOUT is used with the pattern
-.sp
- A(\ed{2}|--)
-.sp
-it is processed as if it were
-.sp
-(?C255)A(?C255)((?C255)\ed{2}(?C255)|(?C255)-(?C255)-(?C255))(?C255)
-.sp
-Notice that there is a callout before and after each parenthesis and
-alternation bar. Automatic callouts can be used for tracking the progress of
-pattern matching. The
-.\" HREF
-\fBpcretest\fP
-.\"
-command has an option that sets automatic callouts; when it is used, the output
-indicates how the pattern is matched. This is useful information when you are
-trying to optimize the performance of a particular pattern.
-.
-.
-.SH "MISSING CALLOUTS"
-.rs
-.sp
-You should be aware that, because of optimizations in the way PCRE matches
-patterns, callouts sometimes do not happen. For example, if the pattern is
-.sp
- ab(?C4)cd
-.sp
-PCRE knows that any matching string must contain the letter "d". If the subject
-string is "abyz", the lack of "d" means that matching doesn't ever start, and
-the callout is never reached. However, with "abyd", though the result is still
-no match, the callout is obeyed.
-.
-.
-.SH "THE CALLOUT INTERFACE"
-.rs
-.sp
-During matching, when PCRE reaches a callout point, the external function
-defined by \fIpcre_callout\fP is called (if it is set). The only argument is a
-pointer to a \fBpcre_callout\fP block. This structure contains the following
-fields:
-.sp
- int \fIversion\fP;
- int \fIcallout_number\fP;
- int *\fIoffset_vector\fP;
- const char *\fIsubject\fP;
- int \fIsubject_length\fP;
- int \fIstart_match\fP;
- int \fIcurrent_position\fP;
- int \fIcapture_top\fP;
- int \fIcapture_last\fP;
- void *\fIcallout_data\fP;
- int \fIpattern_position\fP;
- int \fInext_item_length\fP;
-.sp
-The \fIversion\fP field is an integer containing the version number of the
-block format. The initial version was 0; the current version is 1. The version
-number will change again in future if additional fields are added, but the
-intention is never to remove any of the existing fields.
-.P
-The \fIcallout_number\fP field contains the number of the callout, as compiled
-into the pattern (that is, the number after ?C for manual callouts, and 255 for
-automatically generated callouts).
-.P
-The \fIoffset_vector\fP field is a pointer to the vector of offsets that was
-passed by the caller to \fBpcre_exec()\fP. The contents can be inspected in
-order to extract substrings that have been matched so far, in the same way as
-for extracting substrings after a match has completed.
-.P
-The \fIsubject\fP and \fIsubject_length\fP fields contain copies of the values
-that were passed to \fBpcre_exec()\fP.
-.P
-The \fIstart_match\fP field contains the offset within the subject at which the
-current match attempt started. If the pattern is not anchored, the callout
-function may be called several times from the same point in the pattern for
-different starting points in the subject.
-.P
-The \fIcurrent_position\fP field contains the offset within the subject of the
-current match pointer.
-.P
-The \fIcapture_top\fP field contains one more than the number of the highest
-numbered captured substring so far. If no substrings have been captured,
-the value of \fIcapture_top\fP is one.
-.P
-The \fIcapture_last\fP field contains the number of the most recently captured
-substring. If no substrings have been captured, its value is -1.
-.P
-The \fIcallout_data\fP field contains a value that is passed to
-\fBpcre_exec()\fP by the caller specifically so that it can be passed back in
-callouts. It is passed in the \fIpcre_callout\fP field of the \fBpcre_extra\fP
-data structure. If no such data was passed, the value of \fIcallout_data\fP in
-a \fBpcre_callout\fP block is NULL. There is a description of the
-\fBpcre_extra\fP structure in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-documentation.
-.P
-The \fIpattern_position\fP field is present from version 1 of the
-\fIpcre_callout\fP structure. It contains the offset to the next item to be
-matched in the pattern string.
-.P
-The \fInext_item_length\fP field is present from version 1 of the
-\fIpcre_callout\fP structure. It contains the length of the next item to be
-matched in the pattern string. When the callout immediately precedes an
-alternation bar, a closing parenthesis, or the end of the pattern, the length
-is zero. When the callout precedes an opening parenthesis, the length is that
-of the entire subpattern.
-.P
-The \fIpattern_position\fP and \fInext_item_length\fP fields are intended to
-help in distinguishing between different automatic callouts, which all have the
-same callout number. However, they are set for all callouts.
-.
-.
-.SH "RETURN VALUES"
-.rs
-.sp
-The external callout function returns an integer to PCRE. If the value is zero,
-matching proceeds as normal. If the value is greater than zero, matching fails
-at the current point, but backtracking to test other matching possibilities
-goes ahead, just as if a lookahead assertion had failed. If the value is less
-than zero, the match is abandoned, and \fBpcre_exec()\fP returns the negative
-value.
-.P
-Negative values should normally be chosen from the set of PCRE_ERROR_xxx
-values. In particular, PCRE_ERROR_NOMATCH forces a standard "no match" failure.
-The error number PCRE_ERROR_CALLOUT is reserved for use by callout functions;
-it will never be used by PCRE itself.
-.P
-.in 0
-Last updated: 09 September 2004
-.br
-Copyright (c) 1997-2004 University of Cambridge.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH "DIFFERENCES BETWEEN PCRE AND PERL"
-.rs
-.sp
-This document describes the differences in the ways that PCRE and Perl handle
-regular expressions. The differences described here are with respect to Perl
-5.8.
-.P
-1. PCRE does not have full UTF-8 support. Details of what it does have are
-given in the
-.\" HTML <a href="pcre.html#utf8support">
-.\" </a>
-section on UTF-8 support
-.\"
-in the main
-.\" HREF
-\fBpcre\fP
-.\"
-page.
-.P
-2. PCRE does not allow repeat quantifiers on lookahead assertions. Perl permits
-them, but they do not mean what you might think. For example, (?!a){3} does
-not assert that the next three characters are not "a". It just asserts that the
-next character is not "a" three times.
-.P
-3. Capturing subpatterns that occur inside negative lookahead assertions are
-counted, but their entries in the offsets vector are never set. Perl sets its
-numerical variables from any such patterns that are matched before the
-assertion fails to match something (thereby succeeding), but only if the
-negative lookahead assertion contains just one branch.
-.P
-4. Though binary zero characters are supported in the subject string, they are
-not allowed in a pattern string because it is passed as a normal C string,
-terminated by zero. The escape sequence \e0 can be used in the pattern to
-represent a binary zero.
-.P
-5. The following Perl escape sequences are not supported: \el, \eu, \eL,
-\eU, and \eN. In fact these are implemented by Perl's general string-handling
-and are not part of its pattern matching engine. If any of these are
-encountered by PCRE, an error is generated.
-.P
-6. The Perl escape sequences \ep, \eP, and \eX are supported only if PCRE is
-built with Unicode character property support. The properties that can be
-tested with \ep and \eP are limited to the general category properties such as
-Lu and Nd.
-.P
-7. PCRE does support the \eQ...\eE escape for quoting substrings. Characters in
-between are treated as literals. This is slightly different from Perl in that $
-and @ are also handled as literals inside the quotes. In Perl, they cause
-variable interpolation (but of course PCRE does not have variables). Note the
-following examples:
-.sp
- Pattern PCRE matches Perl matches
-.sp
-.\" JOIN
- \eQabc$xyz\eE abc$xyz abc followed by the
- contents of $xyz
- \eQabc\e$xyz\eE abc\e$xyz abc\e$xyz
- \eQabc\eE\e$\eQxyz\eE abc$xyz abc$xyz
-.sp
-The \eQ...\eE sequence is recognized both inside and outside character classes.
-.P
-8. Fairly obviously, PCRE does not support the (?{code}) and (?p{code})
-constructions. However, there is support for recursive patterns using the
-non-Perl items (?R), (?number), and (?P>name). Also, the PCRE "callout" feature
-allows an external function to be called during pattern matching. See the
-.\" HREF
-\fBpcrecallout\fP
-.\"
-documentation for details.
-.P
-9. There are some differences that are concerned with the settings of captured
-strings when part of a pattern is repeated. For example, matching "aba" against
-the pattern /^(a(b)?)+$/ in Perl leaves $2 unset, but in PCRE it is set to "b".
-.P
-10. PCRE provides some extensions to the Perl regular expression facilities:
-.sp
-(a) Although lookbehind assertions must match fixed length strings, each
-alternative branch of a lookbehind assertion can match a different length of
-string. Perl requires them all to have the same length.
-.sp
-(b) If PCRE_DOLLAR_ENDONLY is set and PCRE_MULTILINE is not set, the $
-meta-character matches only at the very end of the string.
-.sp
-(c) If PCRE_EXTRA is set, a backslash followed by a letter with no special
-meaning is faulted.
-.sp
-(d) If PCRE_UNGREEDY is set, the greediness of the repetition quantifiers is
-inverted, that is, by default they are not greedy, but if followed by a
-question mark they are.
-.sp
-(e) PCRE_ANCHORED can be used at matching time to force a pattern to be tried
-only at the first matching position in the subject string.
-.sp
-(f) The PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, and PCRE_NO_AUTO_CAPTURE
-options for \fBpcre_exec()\fP have no Perl equivalents.
-.sp
-(g) The (?R), (?number), and (?P>name) constructs allows for recursive pattern
-matching (Perl can do this using the (?p{code}) construct, which PCRE cannot
-support.)
-.sp
-(h) PCRE supports named capturing substrings, using the Python syntax.
-.sp
-(i) PCRE supports the possessive quantifier "++" syntax, taken from Sun's Java
-package.
-.sp
-(j) The (R) condition, for testing recursion, is a PCRE extension.
-.sp
-(k) The callout facility is PCRE-specific.
-.sp
-(l) The partial matching facility is PCRE-specific.
-.sp
-(m) Patterns compiled by PCRE can be saved and re-used at a later time, even on
-different hosts that have the other endianness.
-.P
-.in 0
-Last updated: 09 September 2004
-.br
-Copyright (c) 1997-2004 University of Cambridge.
+++ /dev/null
-.TH PCREGREP 1
-.SH NAME
-pcregrep - a grep with Perl-compatible regular expressions.
-.SH SYNOPSIS
-.B pcregrep [-Vcfhilnrsuvx] [long options] [pattern] [file1 file2 ...]
-.
-.SH DESCRIPTION
-.rs
-.sp
-\fBpcregrep\fP searches files for character patterns, in the same way as other
-grep commands do, but it uses the PCRE regular expression library to support
-patterns that are compatible with the regular expressions of Perl 5. See
-.\" HREF
-\fBpcrepattern\fP
-.\"
-for a full description of syntax and semantics of the regular expressions that
-PCRE supports.
-.P
-A pattern must be specified on the command line unless the \fB-f\fP option is
-used (see below).
-.P
-If no files are specified, \fBpcregrep\fP reads the standard input. By default,
-each line that matches the pattern is copied to the standard output, and if
-there is more than one file, the file name is printed before each line of
-output. However, there are options that can change how \fBpcregrep\fP behaves.
-.P
-Lines are limited to BUFSIZ characters. BUFSIZ is defined in \fB<stdio.h>\fP.
-The newline character is removed from the end of each line before it is matched
-against the pattern.
-.
-.SH OPTIONS
-.rs
-.sp
-.TP 10
-\fB-V\fP
-Write the version number of the PCRE library being used to the standard error
-stream.
-.TP
-\fB-c\fP
-Do not print individual lines; instead just print a count of the number of
-lines that would otherwise have been printed. If several files are given, a
-count is printed for each of them.
-.TP
-\fB-f\fP\fIfilename\fP
-Read a number of patterns from the file, one per line, and match all of them
-against each line of input. A line is output if any of the patterns match it.
-When \fB-f\fP is used, no pattern is taken from the command line; all arguments
-are treated as file names. There is a maximum of 100 patterns. Trailing white
-space is removed, and blank lines are ignored. An empty file contains no
-patterns and therefore matches nothing.
-.TP
-\fB-h\fP
-Suppress printing of filenames when searching multiple files.
-.TP
-\fB-i\fP
-Ignore upper/lower case distinctions during comparisons.
-.TP
-\fB-l\fP
-Instead of printing lines from the files, just print the names of the files
-containing lines that would have been printed. Each file name is printed
-once, on a separate line.
-.TP
-\fB-n\fP
-Precede each line by its line number in the file.
-.TP
-\fB-r\fP
-If any file is a directory, recursively scan the files it contains. Without
-\fB-r\fP a directory is scanned as a normal file.
-.TP
-\fB-s\fP
-Work silently, that is, display nothing except error messages.
-The exit status indicates whether any matches were found.
-.TP
-\fB-u\fP
-Operate in UTF-8 mode. This option is available only if PCRE has been compiled
-with UTF-8 support. Both the pattern and each subject line must be valid
-strings of UTF-8 characters.
-.TP
-\fB-v\fP
-Invert the sense of the match, so that lines which do \fInot\fP match the
-pattern are now the ones that are found.
-.TP
-\fB-x\fP
-Force the pattern to be anchored (it must start matching at the beginning of
-the line) and in addition, require it to match the entire line. This is
-equivalent to having ^ and $ characters at the start and end of each
-alternative branch in the regular expression.
-.
-.SH "LONG OPTIONS"
-.rs
-.sp
-Long forms of all the options are available, as in GNU grep. They are shown in
-the following table:
-.sp
- -c --count
- -h --no-filename
- -i --ignore-case
- -l --files-with-matches
- -n --line-number
- -r --recursive
- -s --no-messages
- -u --utf-8
- -V --version
- -v --invert-match
- -x --line-regex
- -x --line-regexp
-.sp
-In addition, --file=\fIfilename\fP is equivalent to -f\fIfilename\fP, and
---help shows the list of options and then exits.
-.
-.SH DIAGNOSTICS
-.rs
-.sp
-Exit status is 0 if any matches were found, 1 if no matches were found, and 2
-for syntax errors or inacessible files (even if matches were found).
-.
-.
-.SH AUTHOR
-.rs
-.sp
-Philip Hazel <ph10@cam.ac.uk>
-.br
-University Computing Service
-.br
-Cambridge CB2 3QG, England.
-.P
-.in 0
-Last updated: 09 September 2004
-.br
-Copyright (c) 1997-2004 University of Cambridge.
+++ /dev/null
-<HTML>
-<HEAD>
-<TITLE>pcregrep specification</TITLE>
-</HEAD>
-<body bgcolor="#FFFFFF" text="#00005A">
-<H1>pcregrep specification</H1>
-This HTML document has been generated automatically from the original man page.
-If there is any nonsense in it, please consult the man page in case the
-conversion went wrong.
-<UL>
-<LI><A NAME="TOC1" HREF="#SEC1">NAME</A>
-<LI><A NAME="TOC2" HREF="#SEC2">SYNOPSIS</A>
-<LI><A NAME="TOC3" HREF="#SEC3">DESCRIPTION</A>
-<LI><A NAME="TOC4" HREF="#SEC4">OPTIONS</A>
-<LI><A NAME="TOC5" HREF="#SEC5">SEE ALSO</A>
-<LI><A NAME="TOC6" HREF="#SEC6">DIAGNOSTICS</A>
-<LI><A NAME="TOC7" HREF="#SEC7">AUTHOR</A>
-</UL>
-<LI><A NAME="SEC1" HREF="#TOC1">NAME</A>
-<P>
-pcregrep - a grep with Perl-compatible regular expressions.
-</P>
-<LI><A NAME="SEC2" HREF="#TOC1">SYNOPSIS</A>
-<P>
-<B>pcregrep [-Vcfhilnrsvx] pattern [file] ...</B>
-</P>
-<LI><A NAME="SEC3" HREF="#TOC1">DESCRIPTION</A>
-<P>
-<B>pcregrep</B> searches files for character patterns, in the same way as other
-grep commands do, but it uses the PCRE regular expression library to support
-patterns that are compatible with the regular expressions of Perl 5. See
-<B>pcre(3)</B> for a full description of syntax and semantics.
-</P>
-<P>
-If no files are specified, <B>pcregrep</B> reads the standard input. By default,
-each line that matches the pattern is copied to the standard output, and if
-there is more than one file, the file name is printed before each line of
-output. However, there are options that can change how <B>pcregrep</B> behaves.
-</P>
-<P>
-Lines are limited to BUFSIZ characters. BUFSIZ is defined in <B><stdio.h></B>.
-The newline character is removed from the end of each line before it is matched
-against the pattern.
-</P>
-<LI><A NAME="SEC4" HREF="#TOC1">OPTIONS</A>
-<P>
-<B>-V</B>
-Write the version number of the PCRE library being used to the standard error
-stream.
-</P>
-<P>
-<B>-c</B>
-Do not print individual lines; instead just print a count of the number of
-lines that would otherwise have been printed. If several files are given, a
-count is printed for each of them.
-</P>
-<P>
-\fB-f<I>filename</I>
-Read patterns from the file, one per line, and match all patterns against each
-line. There is a maximum of 100 patterns. Trailing white space is removed, and
-blank lines are ignored. An empty file contains no patterns and therefore
-matches nothing.
-</P>
-<P>
-<B>-h</B>
-Suppress printing of filenames when searching multiple files.
-</P>
-<P>
-<B>-i</B>
-Ignore upper/lower case distinctions during comparisons.
-</P>
-<P>
-<B>-l</B>
-Instead of printing lines from the files, just print the names of the files
-containing lines that would have been printed. Each file name is printed
-once, on a separate line.
-</P>
-<P>
-<B>-n</B>
-Precede each line by its line number in the file.
-</P>
-<P>
-<B>-r</B>
-If any file is a directory, recursively scan the files it contains. Without
-<B>-r</B> a directory is scanned as a normal file.
-</P>
-<P>
-<B>-s</B>
-Work silently, that is, display nothing except error messages.
-The exit status indicates whether any matches were found.
-</P>
-<P>
-<B>-v</B>
-Invert the sense of the match, so that lines which do <I>not</I> match the
-pattern are now the ones that are found.
-</P>
-<P>
-<B>-x</B>
-Force the pattern to be anchored (it must start matching at the beginning of
-the line) and in addition, require it to match the entire line. This is
-equivalent to having ^ and $ characters at the start and end of each
-alternative branch in the regular expression.
-</P>
-<LI><A NAME="SEC5" HREF="#TOC1">SEE ALSO</A>
-<P>
-<B>pcre(3)</B>, Perl 5 documentation
-</P>
-<LI><A NAME="SEC6" HREF="#TOC1">DIAGNOSTICS</A>
-<P>
-Exit status is 0 if any matches were found, 1 if no matches were found, and 2
-for syntax errors or inacessible files (even if matches were found).
-</P>
-<LI><A NAME="SEC7" HREF="#TOC1">AUTHOR</A>
-<P>
-Philip Hazel <ph10@cam.ac.uk>
-</P>
-<P>
-Last updated: 15 August 2001
-<BR>
-Copyright (c) 1997-2001 University of Cambridge.
+++ /dev/null
-PCREGREP(1) PCREGREP(1)
-
-
-
-NAME
- pcregrep - a grep with Perl-compatible regular expressions.
-
-SYNOPSIS
- pcregrep [-Vcfhilnrsuvx] [long options] [pattern] [file1 file2 ...]
-
-
-DESCRIPTION
-
- pcregrep searches files for character patterns, in the same way as
- other grep commands do, but it uses the PCRE regular expression library
- to support patterns that are compatible with the regular expressions of
- Perl 5. See pcrepattern for a full description of syntax and semantics
- of the regular expressions that PCRE supports.
-
- A pattern must be specified on the command line unless the -f option is
- used (see below).
-
- If no files are specified, pcregrep reads the standard input. By
- default, each line that matches the pattern is copied to the standard
- output, and if there is more than one file, the file name is printed
- before each line of output. However, there are options that can change
- how pcregrep behaves.
-
- Lines are limited to BUFSIZ characters. BUFSIZ is defined in <stdio.h>.
- The newline character is removed from the end of each line before it is
- matched against the pattern.
-
-
-OPTIONS
-
-
- -V Write the version number of the PCRE library being used to
- the standard error stream.
-
- -c Do not print individual lines; instead just print a count of
- the number of lines that would otherwise have been printed.
- If several files are given, a count is printed for each of
- them.
-
- -ffilename
- Read a number of patterns from the file, one per line, and
- match all of them against each line of input. A line is out-
- put if any of the patterns match it. When -f is used, no
- pattern is taken from the command line; all arguments are
- treated as file names. There is a maximum of 100 patterns.
- Trailing white space is removed, and blank lines are ignored.
- An empty file contains no patterns and therefore matches
- nothing.
-
- -h Suppress printing of filenames when searching multiple files.
-
- -i Ignore upper/lower case distinctions during comparisons.
-
- -l Instead of printing lines from the files, just print the
- names of the files containing lines that would have been
- printed. Each file name is printed once, on a separate line.
-
- -n Precede each line by its line number in the file.
-
- -r If any file is a directory, recursively scan the files it
- contains. Without -r a directory is scanned as a normal file.
-
- -s Work silently, that is, display nothing except error mes-
- sages. The exit status indicates whether any matches were
- found.
-
- -u Operate in UTF-8 mode. This option is available only if PCRE
- has been compiled with UTF-8 support. Both the pattern and
- each subject line must be valid strings of UTF-8 characters.
-
- -v Invert the sense of the match, so that lines which do not
- match the pattern are now the ones that are found.
-
- -x Force the pattern to be anchored (it must start matching at
- the beginning of the line) and in addition, require it to
- match the entire line. This is equivalent to having ^ and $
- characters at the start and end of each alternative branch in
- the regular expression.
-
-
-LONG OPTIONS
-
- Long forms of all the options are available, as in GNU grep. They are
- shown in the following table:
-
- -c --count
- -h --no-filename
- -i --ignore-case
- -l --files-with-matches
- -n --line-number
- -r --recursive
- -s --no-messages
- -u --utf-8
- -V --version
- -v --invert-match
- -x --line-regex
- -x --line-regexp
-
- In addition, --file=filename is equivalent to -ffilename, and --help
- shows the list of options and then exits.
-
-
-DIAGNOSTICS
-
- Exit status is 0 if any matches were found, 1 if no matches were found,
- and 2 for syntax errors or inacessible files (even if matches were
- found).
-
-
-AUTHOR
-
- Philip Hazel <ph10@cam.ac.uk>
- University Computing Service
- Cambridge CB2 3QG, England.
-
-Last updated: 09 September 2004
-Copyright (c) 1997-2004 University of Cambridge.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH "PARTIAL MATCHING IN PCRE"
-.rs
-.sp
-In normal use of PCRE, if the subject string that is passed to
-\fBpcre_exec()\fP matches as far as it goes, but is too short to match the
-entire pattern, PCRE_ERROR_NOMATCH is returned. There are circumstances where
-it might be helpful to distinguish this case from other cases in which there is
-no match.
-.P
-Consider, for example, an application where a human is required to type in data
-for a field with specific formatting requirements. An example might be a date
-in the form \fIddmmmyy\fP, defined by this pattern:
-.sp
- ^\ed?\ed(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\ed\ed$
-.sp
-If the application sees the user's keystrokes one by one, and can check that
-what has been typed so far is potentially valid, it is able to raise an error
-as soon as a mistake is made, possibly beeping and not reflecting the
-character that has been typed. This immediate feedback is likely to be a better
-user interface than a check that is delayed until the entire string has been
-entered.
-.P
-PCRE supports the concept of partial matching by means of the PCRE_PARTIAL
-option, which can be set when calling \fBpcre_exec()\fP. When this is done, the
-return code PCRE_ERROR_NOMATCH is converted into PCRE_ERROR_PARTIAL if at any
-time during the matching process the entire subject string matched part of the
-pattern. No captured data is set when this occurs.
-.P
-Using PCRE_PARTIAL disables one of PCRE's optimizations. PCRE remembers the
-last literal byte in a pattern, and abandons matching immediately if such a
-byte is not present in the subject string. This optimization cannot be used
-for a subject string that might match only partially.
-.
-.
-.SH "RESTRICTED PATTERNS FOR PCRE_PARTIAL"
-.rs
-.sp
-Because of the way certain internal optimizations are implemented in PCRE, the
-PCRE_PARTIAL option cannot be used with all patterns. Repeated single
-characters such as
-.sp
- a{2,4}
-.sp
-and repeated single metasequences such as
-.sp
- \ed+
-.sp
-are not permitted if the maximum number of occurrences is greater than one.
-Optional items such as \ed? (where the maximum is one) are permitted.
-Quantifiers with any values are permitted after parentheses, so the invalid
-examples above can be coded thus:
-.sp
- (a){2,4}
- (\ed)+
-.sp
-These constructions run more slowly, but for the kinds of application that are
-envisaged for this facility, this is not felt to be a major restriction.
-.P
-If PCRE_PARTIAL is set for a pattern that does not conform to the restrictions,
-\fBpcre_exec()\fP returns the error code PCRE_ERROR_BADPARTIAL (-13).
-.
-.
-.SH "EXAMPLE OF PARTIAL MATCHING USING PCRETEST"
-.rs
-.sp
-If the escape sequence \eP is present in a \fBpcretest\fP data line, the
-PCRE_PARTIAL flag is used for the match. Here is a run of \fBpcretest\fP that
-uses the date example quoted above:
-.sp
- re> /^\ed?\ed(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\ed\ed$/
- data> 25jun04\P
- 0: 25jun04
- 1: jun
- data> 25dec3\P
- Partial match
- data> 3ju\P
- Partial match
- data> 3juj\P
- No match
- data> j\P
- No match
-.sp
-The first data string is matched completely, so \fBpcretest\fP shows the
-matched substrings. The remaining four strings do not match the complete
-pattern, but the first two are partial matches.
-.
-.
-.P
-.in 0
-Last updated: 08 September 2004
-.br
-Copyright (c) 1997-2004 University of Cambridge.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH "PCRE REGULAR EXPRESSION DETAILS"
-.rs
-.sp
-The syntax and semantics of the regular expressions supported by PCRE are
-described below. Regular expressions are also described in the Perl
-documentation and in a number of books, some of which have copious examples.
-Jeffrey Friedl's "Mastering Regular Expressions", published by O'Reilly, covers
-regular expressions in great detail. This description of PCRE's regular
-expressions is intended as reference material.
-.P
-The original operation of PCRE was on strings of one-byte characters. However,
-there is now also support for UTF-8 character strings. To use this, you must
-build PCRE to include UTF-8 support, and then call \fBpcre_compile()\fP with
-the PCRE_UTF8 option. How this affects pattern matching is mentioned in several
-places below. There is also a summary of UTF-8 features in the
-.\" HTML <a href="pcre.html#utf8support">
-.\" </a>
-section on UTF-8 support
-.\"
-in the main
-.\" HREF
-\fBpcre\fP
-.\"
-page.
-.P
-A regular expression is a pattern that is matched against a subject string from
-left to right. Most characters stand for themselves in a pattern, and match the
-corresponding characters in the subject. As a trivial example, the pattern
-.sp
- The quick brown fox
-.sp
-matches a portion of a subject string that is identical to itself. The power of
-regular expressions comes from the ability to include alternatives and
-repetitions in the pattern. These are encoded in the pattern by the use of
-\fImetacharacters\fP, which do not stand for themselves but instead are
-interpreted in some special way.
-.P
-There are two different sets of metacharacters: those that are recognized
-anywhere in the pattern except within square brackets, and those that are
-recognized in square brackets. Outside square brackets, the metacharacters are
-as follows:
-.sp
- \e general escape character with several uses
- ^ assert start of string (or line, in multiline mode)
- $ assert end of string (or line, in multiline mode)
- . match any character except newline (by default)
- [ start character class definition
- | start of alternative branch
- ( start subpattern
- ) end subpattern
- ? extends the meaning of (
- also 0 or 1 quantifier
- also quantifier minimizer
- * 0 or more quantifier
- + 1 or more quantifier
- also "possessive quantifier"
- { start min/max quantifier
-.sp
-Part of a pattern that is in square brackets is called a "character class". In
-a character class the only metacharacters are:
-.sp
- \e general escape character
- ^ negate the class, but only if the first character
- - indicates character range
-.\" JOIN
- [ POSIX character class (only if followed by POSIX
- syntax)
- ] terminates the character class
-.sp
-The following sections describe the use of each of the metacharacters.
-.
-.SH BACKSLASH
-.rs
-.sp
-The backslash character has several uses. Firstly, if it is followed by a
-non-alphanumeric character, it takes away any special meaning that character may
-have. This use of backslash as an escape character applies both inside and
-outside character classes.
-.P
-For example, if you want to match a * character, you write \e* in the pattern.
-This escaping action applies whether or not the following character would
-otherwise be interpreted as a metacharacter, so it is always safe to precede a
-non-alphanumeric with backslash to specify that it stands for itself. In
-particular, if you want to match a backslash, you write \e\e.
-.P
-If a pattern is compiled with the PCRE_EXTENDED option, whitespace in the
-pattern (other than in a character class) and characters between a # outside
-a character class and the next newline character are ignored. An escaping
-backslash can be used to include a whitespace or # character as part of the
-pattern.
-.P
-If you want to remove the special meaning from a sequence of characters, you
-can do so by putting them between \eQ and \eE. This is different from Perl in
-that $ and @ are handled as literals in \eQ...\eE sequences in PCRE, whereas in
-Perl, $ and @ cause variable interpolation. Note the following examples:
-.sp
- Pattern PCRE matches Perl matches
-.sp
-.\" JOIN
- \eQabc$xyz\eE abc$xyz abc followed by the
- contents of $xyz
- \eQabc\e$xyz\eE abc\e$xyz abc\e$xyz
- \eQabc\eE\e$\eQxyz\eE abc$xyz abc$xyz
-.sp
-The \eQ...\eE sequence is recognized both inside and outside character classes.
-.
-.
-.\" HTML <a name="digitsafterbackslash"></a>
-.SS "Non-printing characters"
-.rs
-.sp
-A second use of backslash provides a way of encoding non-printing characters
-in patterns in a visible manner. There is no restriction on the appearance of
-non-printing characters, apart from the binary zero that terminates a pattern,
-but when a pattern is being prepared by text editing, it is usually easier to
-use one of the following escape sequences than the binary character it
-represents:
-.sp
- \ea alarm, that is, the BEL character (hex 07)
- \ecx "control-x", where x is any character
- \ee escape (hex 1B)
- \ef formfeed (hex 0C)
- \en newline (hex 0A)
- \er carriage return (hex 0D)
- \et tab (hex 09)
- \eddd character with octal code ddd, or backreference
- \exhh character with hex code hh
- \ex{hhh..} character with hex code hhh... (UTF-8 mode only)
-.sp
-The precise effect of \ecx is as follows: if x is a lower case letter, it
-is converted to upper case. Then bit 6 of the character (hex 40) is inverted.
-Thus \ecz becomes hex 1A, but \ec{ becomes hex 3B, while \ec; becomes hex
-7B.
-.P
-After \ex, from zero to two hexadecimal digits are read (letters can be in
-upper or lower case). In UTF-8 mode, any number of hexadecimal digits may
-appear between \ex{ and }, but the value of the character code must be less
-than 2**31 (that is, the maximum hexadecimal value is 7FFFFFFF). If characters
-other than hexadecimal digits appear between \ex{ and }, or if there is no
-terminating }, this form of escape is not recognized. Instead, the initial
-\ex will be interpreted as a basic hexadecimal escape, with no following
-digits, giving a character whose value is zero.
-.P
-Characters whose value is less than 256 can be defined by either of the two
-syntaxes for \ex when PCRE is in UTF-8 mode. There is no difference in the
-way they are handled. For example, \exdc is exactly the same as \ex{dc}.
-.P
-After \e0 up to two further octal digits are read. In both cases, if there
-are fewer than two digits, just those that are present are used. Thus the
-sequence \e0\ex\e07 specifies two binary zeros followed by a BEL character
-(code value 7). Make sure you supply two digits after the initial zero if the
-pattern character that follows is itself an octal digit.
-.P
-The handling of a backslash followed by a digit other than 0 is complicated.
-Outside a character class, PCRE reads it and any following digits as a decimal
-number. If the number is less than 10, or if there have been at least that many
-previous capturing left parentheses in the expression, the entire sequence is
-taken as a \fIback reference\fP. A description of how this works is given
-.\" HTML <a href="#backreferences">
-.\" </a>
-later,
-.\"
-following the discussion of
-.\" HTML <a href="#subpattern">
-.\" </a>
-parenthesized subpatterns.
-.\"
-.P
-Inside a character class, or if the decimal number is greater than 9 and there
-have not been that many capturing subpatterns, PCRE re-reads up to three octal
-digits following the backslash, and generates a single byte from the least
-significant 8 bits of the value. Any subsequent digits stand for themselves.
-For example:
-.sp
- \e040 is another way of writing a space
-.\" JOIN
- \e40 is the same, provided there are fewer than 40
- previous capturing subpatterns
- \e7 is always a back reference
-.\" JOIN
- \e11 might be a back reference, or another way of
- writing a tab
- \e011 is always a tab
- \e0113 is a tab followed by the character "3"
-.\" JOIN
- \e113 might be a back reference, otherwise the
- character with octal code 113
-.\" JOIN
- \e377 might be a back reference, otherwise
- the byte consisting entirely of 1 bits
-.\" JOIN
- \e81 is either a back reference, or a binary zero
- followed by the two characters "8" and "1"
-.sp
-Note that octal values of 100 or greater must not be introduced by a leading
-zero, because no more than three octal digits are ever read.
-.P
-All the sequences that define a single byte value or a single UTF-8 character
-(in UTF-8 mode) can be used both inside and outside character classes. In
-addition, inside a character class, the sequence \eb is interpreted as the
-backspace character (hex 08), and the sequence \eX is interpreted as the
-character "X". Outside a character class, these sequences have different
-meanings
-.\" HTML <a href="#uniextseq">
-.\" </a>
-(see below).
-.\"
-.
-.
-.SS "Generic character types"
-.rs
-.sp
-The third use of backslash is for specifying generic character types. The
-following are always recognized:
-.sp
- \ed any decimal digit
- \eD any character that is not a decimal digit
- \es any whitespace character
- \eS any character that is not a whitespace character
- \ew any "word" character
- \eW any "non-word" character
-.sp
-Each pair of escape sequences partitions the complete set of characters into
-two disjoint sets. Any given character matches one, and only one, of each pair.
-.P
-These character type sequences can appear both inside and outside character
-classes. They each match one character of the appropriate type. If the current
-matching point is at the end of the subject string, all of them fail, since
-there is no character to match.
-.P
-For compatibility with Perl, \es does not match the VT character (code 11).
-This makes it different from the the POSIX "space" class. The \es characters
-are HT (9), LF (10), FF (12), CR (13), and space (32).
-.P
-A "word" character is an underscore or any character less than 256 that is a
-letter or digit. The definition of letters and digits is controlled by PCRE's
-low-valued character tables, and may vary if locale-specific matching is taking
-place (see
-.\" HTML <a href="pcreapi.html#localesupport">
-.\" </a>
-"Locale support"
-.\"
-in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-page). For example, in the "fr_FR" (French) locale, 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
-character property support is available.
-.
-.
-.\" HTML <a name="uniextseq"></a>
-.SS Unicode character properties
-.rs
-.sp
-When PCRE is built with Unicode character property support, three additional
-escape sequences to match generic character types are available when UTF-8 mode
-is selected. They are:
-.sp
- \ep{\fIxx\fP} a character with the \fIxx\fP property
- \eP{\fIxx\fP} a character without the \fIxx\fP property
- \eX an extended Unicode sequence
-.sp
-The property names represented by \fIxx\fP above are limited to the
-Unicode general category properties. Each character has exactly one such
-property, specified by a two-letter abbreviation. For compatibility with Perl,
-negation can be specified by including a circumflex between the opening brace
-and the property name. For example, \ep{^Lu} is the same as \eP{Lu}.
-.P
-If only one letter is specified with \ep or \eP, it includes all the properties
-that start with that letter. In this case, in the absence of negation, the
-curly brackets in the escape sequence are optional; these two examples have
-the same effect:
-.sp
- \ep{L}
- \epL
-.sp
-The following property codes are supported:
-.sp
- C Other
- Cc Control
- Cf Format
- Cn Unassigned
- Co Private use
- Cs Surrogate
-.sp
- L Letter
- Ll Lower case letter
- Lm Modifier letter
- Lo Other letter
- Lt Title case letter
- Lu Upper case letter
-.sp
- M Mark
- Mc Spacing mark
- Me Enclosing mark
- Mn Non-spacing mark
-.sp
- N Number
- Nd Decimal number
- Nl Letter number
- No Other number
-.sp
- P Punctuation
- Pc Connector punctuation
- Pd Dash punctuation
- Pe Close punctuation
- Pf Final punctuation
- Pi Initial punctuation
- Po Other punctuation
- Ps Open punctuation
-.sp
- S Symbol
- Sc Currency symbol
- Sk Modifier symbol
- Sm Mathematical symbol
- So Other symbol
-.sp
- Z Separator
- Zl Line separator
- Zp Paragraph separator
- Zs Space separator
-.sp
-Extended properties such as "Greek" or "InMusicalSymbols" are not supported by
-PCRE.
-.P
-Specifying caseless matching does not affect these escape sequences. For
-example, \ep{Lu} always matches only upper case letters.
-.P
-The \eX escape matches any number of Unicode characters that form an extended
-Unicode sequence. \eX is equivalent to
-.sp
- (?>\ePM\epM*)
-.sp
-That is, it matches a character without the "mark" property, followed by zero
-or more characters with the "mark" property, and treats the sequence as an
-atomic group
-.\" HTML <a href="#atomicgroup">
-.\" </a>
-(see below).
-.\"
-Characters with the "mark" property are typically accents that affect the
-preceding character.
-.P
-Matching characters by Unicode property is not fast, because PCRE has to search
-a structure that contains data for over fifteen thousand characters. That is
-why the traditional escape sequences such as \ed and \ew do not use Unicode
-properties in PCRE.
-.
-.
-.\" HTML <a name="smallassertions"></a>
-.SS "Simple assertions"
-.rs
-.sp
-The fourth use of backslash is for certain simple assertions. An assertion
-specifies a condition that has to be met at a particular point in a match,
-without consuming any characters from the subject string. The use of
-subpatterns for more complicated assertions is described
-.\" HTML <a href="#bigassertions">
-.\" </a>
-below.
-.\"
-The backslashed
-assertions are:
-.sp
- \eb matches at a word boundary
- \eB matches when not at a word boundary
- \eA matches at start of subject
- \eZ matches at end of subject or before newline at end
- \ez matches at end of subject
- \eG matches at first matching position in subject
-.sp
-These assertions may not appear in character classes (but note that \eb has a
-different meaning, namely the backspace character, inside a character class).
-.P
-A word boundary is a position in the subject string where the current character
-and the previous character do not both match \ew or \eW (i.e. one matches
-\ew and the other matches \eW), or the start or end of the string if the
-first or last character matches \ew, respectively.
-.P
-The \eA, \eZ, and \ez assertions differ from the traditional circumflex and
-dollar (described in the next section) in that they only ever match at the very
-start and end of the subject string, whatever options are set. Thus, they are
-independent of multiline mode. These three assertions are not affected by the
-PCRE_NOTBOL or PCRE_NOTEOL options, which affect only the behaviour of the
-circumflex and dollar metacharacters. However, if the \fIstartoffset\fP
-argument of \fBpcre_exec()\fP is non-zero, indicating that matching is to start
-at a point other than the beginning of the subject, \eA can never match. The
-difference between \eZ and \ez is that \eZ matches before a newline that is the
-last character of the string as well as at the end of the string, whereas \ez
-matches only at the end.
-.P
-The \eG assertion is true only when the current matching position is at the
-start point of the match, as specified by the \fIstartoffset\fP argument of
-\fBpcre_exec()\fP. It differs from \eA when the value of \fIstartoffset\fP is
-non-zero. By calling \fBpcre_exec()\fP multiple times with appropriate
-arguments, you can mimic Perl's /g option, and it is in this kind of
-implementation where \eG can be useful.
-.P
-Note, however, that PCRE's interpretation of \eG, as the start of the current
-match, is subtly different from Perl's, which defines it as the end of the
-previous match. In Perl, these can be different when the previously matched
-string was empty. Because PCRE does just one match at a time, it cannot
-reproduce this behaviour.
-.P
-If all the alternatives of a pattern begin with \eG, the expression is anchored
-to the starting match position, and the "anchored" flag is set in the compiled
-regular expression.
-.
-.
-.SH "CIRCUMFLEX AND DOLLAR"
-.rs
-.sp
-Outside a character class, in the default matching mode, the circumflex
-character is an assertion that is true only if the current matching point is
-at the start of the subject string. If the \fIstartoffset\fP argument of
-\fBpcre_exec()\fP is non-zero, circumflex can never match if the PCRE_MULTILINE
-option is unset. Inside a character class, circumflex has an entirely different
-meaning
-.\" HTML <a href="#characterclass">
-.\" </a>
-(see below).
-.\"
-.P
-Circumflex need not be the first character of the pattern if a number of
-alternatives are involved, but it should be the first thing in each alternative
-in which it appears if the pattern is ever to match that branch. If all
-possible alternatives start with a circumflex, that is, if the pattern is
-constrained to match only at the start of the subject, it is said to be an
-"anchored" pattern. (There are also other constructs that can cause a pattern
-to be anchored.)
-.P
-A dollar character is an assertion that is true only if the current matching
-point is at the end of the subject string, or immediately before a newline
-character that is the last character in the string (by default). Dollar need
-not be the last character of the pattern if a number of alternatives are
-involved, but it should be the last item in any branch in which it appears.
-Dollar has no special meaning in a character class.
-.P
-The meaning of dollar can be changed so that it matches only at the very end of
-the string, by setting the PCRE_DOLLAR_ENDONLY option at compile time. This
-does not affect the \eZ assertion.
-.P
-The meanings of the circumflex and dollar characters are changed if the
-PCRE_MULTILINE option is set. When this is the case, they match immediately
-after and immediately before an internal newline character, respectively, in
-addition to matching at the start and end of the subject string. For example,
-the pattern /^abc$/ matches the subject string "def\enabc" (where \en
-represents a newline character) in multiline mode, but not otherwise.
-Consequently, patterns that are anchored in single line mode because all
-branches start with ^ are not anchored in multiline mode, and a match for
-circumflex is possible when the \fIstartoffset\fP argument of \fBpcre_exec()\fP
-is non-zero. The PCRE_DOLLAR_ENDONLY option is ignored if PCRE_MULTILINE is
-set.
-.P
-Note that the sequences \eA, \eZ, and \ez can be used to match the start and
-end of the subject in both modes, and if all branches of a pattern start with
-\eA it is always anchored, whether PCRE_MULTILINE is set or not.
-.
-.
-.SH "FULL STOP (PERIOD, DOT)"
-.rs
-.sp
-Outside a character class, a dot in the pattern matches any one character in
-the subject, including a non-printing character, but not (by default) newline.
-In UTF-8 mode, a dot matches any UTF-8 character, which might be more than one
-byte long, except (by default) newline. If the PCRE_DOTALL option is set,
-dots match newlines as well. The handling of dot is entirely independent of the
-handling of circumflex and dollar, the only relationship being that they both
-involve newline characters. Dot has no special meaning in a character class.
-.
-.
-.SH "MATCHING A SINGLE BYTE"
-.rs
-.sp
-Outside a character class, the escape sequence \eC matches any one byte, both
-in and out of UTF-8 mode. Unlike a dot, it can match a newline. The feature is
-provided in Perl in order to match individual bytes in UTF-8 mode. Because it
-breaks up UTF-8 characters into individual bytes, what remains in the string
-may be a malformed UTF-8 string. For this reason, the \eC escape sequence is
-best avoided.
-.P
-PCRE does not allow \eC to appear in lookbehind assertions
-.\" HTML <a href="#lookbehind">
-.\" </a>
-(described below),
-.\"
-because in UTF-8 mode this would make it impossible to calculate the length of
-the lookbehind.
-.
-.
-.\" HTML <a name="characterclass"></a>
-.SH "SQUARE BRACKETS AND CHARACTER CLASSES"
-.rs
-.sp
-An opening square bracket introduces a character class, terminated by a closing
-square bracket. A closing square bracket on its own is not special. If a
-closing square bracket is required as a member of the class, it should be the
-first data character in the class (after an initial circumflex, if present) or
-escaped with a backslash.
-.P
-A character class matches a single character in the subject. In UTF-8 mode, the
-character may occupy more than one byte. A matched character must be in the set
-of characters defined by the class, unless the first character in the class
-definition is a circumflex, in which case the subject character must not be in
-the set defined by the class. If a circumflex is actually required as a member
-of the class, ensure it is not the first character, or escape it with a
-backslash.
-.P
-For example, the character class [aeiou] matches any lower case vowel, while
-[^aeiou] matches any character that is not a lower case vowel. Note that a
-circumflex is just a convenient notation for specifying the characters that
-are in the class by enumerating those that are not. A class that starts with a
-circumflex is not an assertion: it still consumes a character from the subject
-string, and therefore it fails if the current pointer is at the end of the
-string.
-.P
-In UTF-8 mode, characters with values greater than 255 can be included in a
-class as a literal string of bytes, or by using the \ex{ escaping mechanism.
-.P
-When caseless matching is set, any letters in a class represent both their
-upper case and lower case versions, so for example, a caseless [aeiou] matches
-"A" as well as "a", and a caseless [^aeiou] does not match "A", whereas a
-caseful version would. When running 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.
-.P
-The newline character is never treated in any special way in character classes,
-whatever the setting of the PCRE_DOTALL or PCRE_MULTILINE options is. A class
-such as [^a] will always match a newline.
-.P
-The minus (hyphen) character can be used to specify a range of characters in a
-character class. For example, [d-m] matches any letter between d and m,
-inclusive. If a minus character is required in a class, it must be escaped with
-a backslash or appear in a position where it cannot be interpreted as
-indicating a range, typically as the first or last character in the class.
-.P
-It is not possible to have the literal character "]" as the end character of a
-range. A pattern such as [W-]46] is interpreted as a class of two characters
-("W" and "-") followed by a literal string "46]", so it would match "W46]" or
-"-46]". However, if the "]" is escaped with a backslash it is interpreted as
-the end of range, so [W-\e]46] is interpreted as a class containing a range
-followed by two other characters. The octal or hexadecimal representation of
-"]" can also be used to end a range.
-.P
-Ranges operate in the collating sequence of character values. They can also be
-used for characters specified numerically, for example [\e000-\e037]. In UTF-8
-mode, ranges can include characters whose values are greater than 255, for
-example [\ex{100}-\ex{2ff}].
-.P
-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
-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.
-.P
-The character types \ed, \eD, \ep, \eP, \es, \eS, \ew, and \eW may also appear
-in a character class, and add the characters that they match to the class. For
-example, [\edABCDEF] matches any hexadecimal digit. A circumflex can
-conveniently be used with the upper case character types to specify a more
-restricted set of characters than the matching lower case type. For example,
-the class [^\eW_] matches any letter or digit, but not underscore.
-.P
-The only metacharacters that are recognized in character classes are backslash,
-hyphen (only where it can be interpreted as specifying a range), circumflex
-(only at the start), opening square bracket (only when it can be interpreted as
-introducing a POSIX class name - see the next section), and the terminating
-closing square bracket. However, escaping other non-alphanumeric characters
-does no harm.
-.
-.
-.SH "POSIX CHARACTER CLASSES"
-.rs
-.sp
-Perl supports the POSIX notation for character classes. This uses names
-enclosed by [: and :] within the enclosing square brackets. PCRE also supports
-this notation. For example,
-.sp
- [01[:alpha:]%]
-.sp
-matches "0", "1", any alphabetic character, or "%". The supported class names
-are
-.sp
- alnum letters and digits
- alpha letters
- ascii character codes 0 - 127
- blank space or tab only
- cntrl control characters
- digit decimal digits (same as \ed)
- graph printing characters, excluding space
- lower lower case letters
- print printing characters, including space
- punct printing characters, excluding letters and digits
- space white space (not quite the same as \es)
- upper upper case letters
- word "word" characters (same as \ew)
- xdigit hexadecimal digits
-.sp
-The "space" characters are HT (9), LF (10), VT (11), FF (12), CR (13), and
-space (32). Notice that this list includes the VT character (code 11). This
-makes "space" different to \es, which does not include VT (for Perl
-compatibility).
-.P
-The name "word" is a Perl extension, and "blank" is a GNU extension from Perl
-5.8. Another Perl extension is negation, which is indicated by a ^ character
-after the colon. For example,
-.sp
- [12[:^digit:]]
-.sp
-matches "1", "2", or any non-digit. PCRE (and Perl) also recognize the POSIX
-syntax [.ch.] and [=ch=] where "ch" is a "collating element", but these are not
-supported, and an error is given if they are encountered.
-.P
-In UTF-8 mode, characters with values greater than 128 do not match any of
-the POSIX character classes.
-.
-.
-.SH "VERTICAL BAR"
-.rs
-.sp
-Vertical bar characters are used to separate alternative patterns. For example,
-the pattern
-.sp
- gilbert|sullivan
-.sp
-matches either "gilbert" or "sullivan". Any number of alternatives may appear,
-and an empty alternative is permitted (matching the empty string).
-The matching process tries each alternative in turn, from left to right,
-and the first one that succeeds is used. If the alternatives are within a
-subpattern
-.\" HTML <a href="#subpattern">
-.\" </a>
-(defined below),
-.\"
-"succeeds" means matching the rest of the main pattern as well as the
-alternative in the subpattern.
-.
-.
-.SH "INTERNAL OPTION SETTING"
-.rs
-.sp
-The settings of the PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, and
-PCRE_EXTENDED options can be changed from within the pattern by a sequence of
-Perl option letters enclosed between "(?" and ")". The option letters are
-.sp
- i for PCRE_CASELESS
- m for PCRE_MULTILINE
- s for PCRE_DOTALL
- x for PCRE_EXTENDED
-.sp
-For example, (?im) sets caseless, multiline matching. It is also possible to
-unset these options by preceding the letter with a hyphen, and a combined
-setting and unsetting such as (?im-sx), which sets PCRE_CASELESS and
-PCRE_MULTILINE while unsetting PCRE_DOTALL and PCRE_EXTENDED, is also
-permitted. If a letter appears both before and after the hyphen, the option is
-unset.
-.P
-When an option change occurs at top level (that is, not inside subpattern
-parentheses), the change applies to the remainder of the pattern that follows.
-If the change is placed right at the start of a pattern, PCRE extracts it into
-the global options (and it will therefore show up in data extracted by the
-\fBpcre_fullinfo()\fP function).
-.P
-An option change within a subpattern affects only that part of the current
-pattern that follows it, so
-.sp
- (a(?i)b)c
-.sp
-matches abc and aBc and no other strings (assuming PCRE_CASELESS is not used).
-By this means, options can be made to have different settings in different
-parts of the pattern. Any changes made in one alternative do carry on
-into subsequent branches within the same subpattern. For example,
-.sp
- (a(?i)b|c)
-.sp
-matches "ab", "aB", "c", and "C", even though when matching "C" the first
-branch is abandoned before the option setting. This is because the effects of
-option settings happen at compile time. There would be some very weird
-behaviour otherwise.
-.P
-The PCRE-specific options PCRE_UNGREEDY and PCRE_EXTRA can be changed in the
-same way as the Perl-compatible options by using the characters U and X
-respectively. The (?X) flag setting is special in that it must always occur
-earlier in the pattern than any of the additional features it turns on, even
-when it is at top level. It is best to put it at the start.
-.
-.
-.\" HTML <a name="subpattern"></a>
-.SH SUBPATTERNS
-.rs
-.sp
-Subpatterns are delimited by parentheses (round brackets), which can be nested.
-Turning part of a pattern into a subpattern does two things:
-.sp
-1. It localizes a set of alternatives. For example, the pattern
-.sp
- cat(aract|erpillar|)
-.sp
-matches one of the words "cat", "cataract", or "caterpillar". Without the
-parentheses, it would match "cataract", "erpillar" or the empty string.
-.sp
-2. It sets up the subpattern as a capturing subpattern. This means that, when
-the whole pattern matches, that portion of the subject string that matched the
-subpattern is passed back to the caller via the \fIovector\fP argument of
-\fBpcre_exec()\fP. Opening parentheses are counted from left to right (starting
-from 1) to obtain numbers for the capturing subpatterns.
-.P
-For example, if the string "the red king" is matched against the pattern
-.sp
- the ((red|white) (king|queen))
-.sp
-the captured substrings are "red king", "red", and "king", and are numbered 1,
-2, and 3, respectively.
-.P
-The fact that plain parentheses fulfil two functions is not always helpful.
-There are often times when a grouping subpattern is required without a
-capturing requirement. If an opening parenthesis is followed by a question mark
-and a colon, the subpattern does not do any capturing, and is not counted when
-computing the number of any subsequent capturing subpatterns. For example, if
-the string "the white queen" is matched against the pattern
-.sp
- the ((?:red|white) (king|queen))
-.sp
-the captured substrings are "white queen" and "queen", and are numbered 1 and
-2. The maximum number of capturing subpatterns is 65535, and the maximum depth
-of nesting of all subpatterns, both capturing and non-capturing, is 200.
-.P
-As a convenient shorthand, if any option settings are required at the start of
-a non-capturing subpattern, the option letters may appear between the "?" and
-the ":". Thus the two patterns
-.sp
- (?i:saturday|sunday)
- (?:(?i)saturday|sunday)
-.sp
-match exactly the same set of strings. Because alternative branches are tried
-from left to right, and options are not reset until the end of the subpattern
-is reached, an option setting in one branch does affect subsequent branches, so
-the above patterns match "SUNDAY" as well as "Saturday".
-.
-.
-.SH "NAMED SUBPATTERNS"
-.rs
-.sp
-Identifying capturing parentheses by number is simple, but it can be very hard
-to keep track of the numbers in complicated regular expressions. Furthermore,
-if an expression is modified, the numbers may change. To help with this
-difficulty, PCRE supports the naming of subpatterns, something that Perl does
-not provide. The Python syntax (?P<name>...) is used. Names consist of
-alphanumeric characters and underscores, and must be unique within a pattern.
-.P
-Named capturing parentheses are still allocated numbers as well as names. The
-PCRE API provides function calls for extracting the name-to-number translation
-table from a compiled pattern. There is also a convenience function for
-extracting a captured substring by name. For further details see the
-.\" HREF
-\fBpcreapi\fP
-.\"
-documentation.
-.
-.
-.SH REPETITION
-.rs
-.sp
-Repetition is specified by quantifiers, which can follow any of the following
-items:
-.sp
- a literal data character
- the . metacharacter
- the \eC escape sequence
- the \eX escape sequence (in UTF-8 mode with Unicode properties)
- an escape such as \ed that matches a single character
- a character class
- a back reference (see next section)
- a parenthesized subpattern (unless it is an assertion)
-.sp
-The general repetition quantifier specifies a minimum and maximum number of
-permitted matches, by giving the two numbers in curly brackets (braces),
-separated by a comma. The numbers must be less than 65536, and the first must
-be less than or equal to the second. For example:
-.sp
- z{2,4}
-.sp
-matches "zz", "zzz", or "zzzz". A closing brace on its own is not a special
-character. If the second number is omitted, but the comma is present, there is
-no upper limit; if the second number and the comma are both omitted, the
-quantifier specifies an exact number of required matches. Thus
-.sp
- [aeiou]{3,}
-.sp
-matches at least 3 successive vowels, but may match many more, while
-.sp
- \ed{8}
-.sp
-matches exactly 8 digits. An opening curly bracket that appears in a position
-where a quantifier is not allowed, or one that does not match the syntax of a
-quantifier, is taken as a literal character. For example, {,6} is not a
-quantifier, but a literal string of four characters.
-.P
-In UTF-8 mode, quantifiers apply to UTF-8 characters rather than to individual
-bytes. Thus, for example, \ex{100}{2} matches two UTF-8 characters, each of
-which is represented by a two-byte sequence. Similarly, when Unicode property
-support is available, \eX{3} matches three Unicode extended sequences, each of
-which may be several bytes long (and they may be of different lengths).
-.P
-The quantifier {0} is permitted, causing the expression to behave as if the
-previous item and the quantifier were not present.
-.P
-For convenience (and historical compatibility) the three most common
-quantifiers have single-character abbreviations:
-.sp
- * is equivalent to {0,}
- + is equivalent to {1,}
- ? is equivalent to {0,1}
-.sp
-It is possible to construct infinite loops by following a subpattern that can
-match no characters with a quantifier that has no upper limit, for example:
-.sp
- (a?)*
-.sp
-Earlier versions of Perl and PCRE used to give an error at compile time for
-such patterns. However, because there are cases where this can be useful, such
-patterns are now accepted, but if any repetition of the subpattern does in fact
-match no characters, the loop is forcibly broken.
-.P
-By default, the quantifiers are "greedy", that is, they match as much as
-possible (up to the maximum number of permitted times), without causing the
-rest of the pattern to fail. The classic example of where this gives problems
-is in trying to match comments in C programs. These appear between /* and */
-and within the comment, individual * and / characters may appear. An attempt to
-match C comments by applying the pattern
-.sp
- /\e*.*\e*/
-.sp
-to the string
-.sp
- /* first comment */ not comment /* second comment */
-.sp
-fails, because it matches the entire string owing to the greediness of the .*
-item.
-.P
-However, if a quantifier is followed by a question mark, it ceases to be
-greedy, and instead matches the minimum number of times possible, so the
-pattern
-.sp
- /\e*.*?\e*/
-.sp
-does the right thing with the C comments. The meaning of the various
-quantifiers is not otherwise changed, just the preferred number of matches.
-Do not confuse this use of question mark with its use as a quantifier in its
-own right. Because it has two uses, it can sometimes appear doubled, as in
-.sp
- \ed??\ed
-.sp
-which matches one digit by preference, but can match two if that is the only
-way the rest of the pattern matches.
-.P
-If the PCRE_UNGREEDY option is set (an option which is not available in Perl),
-the quantifiers are not greedy by default, but individual ones can be made
-greedy by following them with a question mark. In other words, it inverts the
-default behaviour.
-.P
-When a parenthesized subpattern is quantified with a minimum repeat count that
-is greater than 1 or with a limited maximum, more memory is required for the
-compiled pattern, in proportion to the size of the minimum or maximum.
-.P
-If a pattern starts with .* or .{0,} and the PCRE_DOTALL option (equivalent
-to Perl's /s) is set, thus allowing the . to match newlines, the pattern is
-implicitly anchored, because whatever follows will be tried against every
-character position in the subject string, so there is no point in retrying the
-overall match at any position after the first. PCRE normally treats such a
-pattern as though it were preceded by \eA.
-.P
-In cases where it is known that the subject string contains no newlines, it is
-worth setting PCRE_DOTALL in order to obtain this optimization, or
-alternatively using ^ to indicate anchoring explicitly.
-.P
-However, there is one situation where the optimization cannot be used. When .*
-is inside capturing parentheses that are the subject of a backreference
-elsewhere in the pattern, a match at the start may fail, and a later one
-succeed. Consider, for example:
-.sp
- (.*)abc\e1
-.sp
-If the subject is "xyz123abc123" the match point is the fourth character. For
-this reason, such a pattern is not implicitly anchored.
-.P
-When a capturing subpattern is repeated, the value captured is the substring
-that matched the final iteration. For example, after
-.sp
- (tweedle[dume]{3}\es*)+
-.sp
-has matched "tweedledum tweedledee" the value of the captured substring is
-"tweedledee". However, if there are nested capturing subpatterns, the
-corresponding captured values may have been set in previous iterations. For
-example, after
-.sp
- /(a|(b))+/
-.sp
-matches "aba" the value of the second captured substring is "b".
-.
-.
-.\" HTML <a name="atomicgroup"></a>
-.SH "ATOMIC GROUPING AND POSSESSIVE QUANTIFIERS"
-.rs
-.sp
-With both maximizing and minimizing repetition, failure of what follows
-normally causes the repeated item to be re-evaluated to see if a different
-number of repeats allows the rest of the pattern to match. Sometimes it is
-useful to prevent this, either to change the nature of the match, or to cause
-it fail earlier than it otherwise might, when the author of the pattern knows
-there is no point in carrying on.
-.P
-Consider, for example, the pattern \ed+foo when applied to the subject line
-.sp
- 123456bar
-.sp
-After matching all 6 digits and then failing to match "foo", the normal
-action of the matcher is to try again with only 5 digits matching the \ed+
-item, and then with 4, and so on, before ultimately failing. "Atomic grouping"
-(a term taken from Jeffrey Friedl's book) provides the means for specifying
-that once a subpattern has matched, it is not to be re-evaluated in this way.
-.P
-If we use atomic grouping for the previous example, the matcher would give up
-immediately on failing to match "foo" the first time. The notation is a kind of
-special parenthesis, starting with (?> as in this example:
-.sp
- (?>\ed+)foo
-.sp
-This kind of parenthesis "locks up" the part of the pattern it contains once
-it has matched, and a failure further into the pattern is prevented from
-backtracking into it. Backtracking past it to previous items, however, works as
-normal.
-.P
-An alternative description is that a subpattern of this type matches the string
-of characters that an identical standalone pattern would match, if anchored at
-the current point in the subject string.
-.P
-Atomic grouping subpatterns are not capturing subpatterns. Simple cases such as
-the above example can be thought of as a maximizing repeat that must swallow
-everything it can. So, while both \ed+ and \ed+? are prepared to adjust the
-number of digits they match in order to make the rest of the pattern match,
-(?>\ed+) can only match an entire sequence of digits.
-.P
-Atomic groups in general can of course contain arbitrarily complicated
-subpatterns, and can be nested. However, when the subpattern for an atomic
-group is just a single repeated item, as in the example above, a simpler
-notation, called a "possessive quantifier" can be used. This consists of an
-additional + character following a quantifier. Using this notation, the
-previous example can be rewritten as
-.sp
- \ed++foo
-.sp
-Possessive quantifiers are always greedy; the setting of the PCRE_UNGREEDY
-option is ignored. They are a convenient notation for the simpler forms of
-atomic group. However, there is no difference in the meaning or processing of a
-possessive quantifier and the equivalent atomic group.
-.P
-The possessive quantifier syntax is an extension to the Perl syntax. It
-originates in Sun's Java package.
-.P
-When a pattern contains an unlimited repeat inside a subpattern that can itself
-be repeated an unlimited number of times, the use of an atomic group is the
-only way to avoid some failing matches taking a very long time indeed. The
-pattern
-.sp
- (\eD+|<\ed+>)*[!?]
-.sp
-matches an unlimited number of substrings that either consist of non-digits, or
-digits enclosed in <>, followed by either ! or ?. When it matches, it runs
-quickly. However, if it is applied to
-.sp
- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-.sp
-it takes a long time before reporting failure. This is because the string can
-be divided between the internal \eD+ repeat and the external * repeat in a
-large number of ways, and all have to be tried. (The example uses [!?] rather
-than a single character at the end, because both PCRE and Perl have an
-optimization that allows for fast failure when a single character is used. They
-remember the last single character that is required for a match, and fail early
-if it is not present in the string.) If the pattern is changed so that it uses
-an atomic group, like this:
-.sp
- ((?>\eD+)|<\ed+>)*[!?]
-.sp
-sequences of non-digits cannot be broken, and failure happens quickly.
-.
-.
-.\" HTML <a name="backreferences"></a>
-.SH "BACK REFERENCES"
-.rs
-.sp
-Outside a character class, a backslash followed by a digit greater than 0 (and
-possibly further digits) is a back reference to a capturing subpattern earlier
-(that is, to its left) in the pattern, provided there have been that many
-previous capturing left parentheses.
-.P
-However, if the decimal number following the backslash is less than 10, it is
-always taken as a back reference, and causes an error only if there are not
-that many capturing left parentheses in the entire pattern. In other words, the
-parentheses that are referenced need not be to the left of the reference for
-numbers less than 10. See the subsection entitled "Non-printing characters"
-.\" HTML <a href="#digitsafterbackslash">
-.\" </a>
-above
-.\"
-for further details of the handling of digits following a backslash.
-.P
-A back reference matches whatever actually matched the capturing subpattern in
-the current subject string, rather than anything matching the subpattern
-itself (see
-.\" HTML <a href="#subpatternsassubroutines">
-.\" </a>
-"Subpatterns as subroutines"
-.\"
-below for a way of doing that). So the pattern
-.sp
- (sens|respons)e and \e1ibility
-.sp
-matches "sense and sensibility" and "response and responsibility", but not
-"sense and responsibility". If caseful matching is in force at the time of the
-back reference, the case of letters is relevant. For example,
-.sp
- ((?i)rah)\es+\e1
-.sp
-matches "rah rah" and "RAH RAH", but not "RAH rah", even though the original
-capturing subpattern is matched caselessly.
-.P
-Back references to named subpatterns use the Python syntax (?P=name). We could
-rewrite the above example as follows:
-.sp
- (?<p1>(?i)rah)\es+(?P=p1)
-.sp
-There may be more than one back reference to the same subpattern. If a
-subpattern has not actually been used in a particular match, any back
-references to it always fail. For example, the pattern
-.sp
- (a|(bc))\e2
-.sp
-always fails if it starts to match "a" rather than "bc". Because there may be
-many capturing parentheses in a pattern, all digits following the backslash are
-taken as part of a potential back reference number. If the pattern continues
-with a digit character, some delimiter must be used to terminate the back
-reference. If the PCRE_EXTENDED option is set, this can be whitespace.
-Otherwise an empty comment (see
-.\" HTML <a href="#comments">
-.\" </a>
-"Comments"
-.\"
-below) can be used.
-.P
-A back reference that occurs inside the parentheses to which it refers fails
-when the subpattern is first used, so, for example, (a\e1) never matches.
-However, such references can be useful inside repeated subpatterns. For
-example, the pattern
-.sp
- (a|b\e1)+
-.sp
-matches any number of "a"s and also "aba", "ababbaa" etc. At each iteration of
-the subpattern, the back reference matches the character string corresponding
-to the previous iteration. In order for this to work, the pattern must be such
-that the first iteration does not need to match the back reference. This can be
-done using alternation, as in the example above, or by a quantifier with a
-minimum of zero.
-.
-.
-.\" HTML <a name="bigassertions"></a>
-.SH ASSERTIONS
-.rs
-.sp
-An assertion is a test on the characters following or preceding the current
-matching point that does not actually consume any characters. The simple
-assertions coded as \eb, \eB, \eA, \eG, \eZ, \ez, ^ and $ are described
-.\" HTML <a href="#smallassertions">
-.\" </a>
-above.
-.\"
-.P
-More complicated assertions are coded as subpatterns. There are two kinds:
-those that look ahead of the current position in the subject string, and those
-that look behind it. An assertion subpattern is matched in the normal way,
-except that it does not cause the current matching position to be changed.
-.P
-Assertion subpatterns are not capturing subpatterns, and may not be repeated,
-because it makes no sense to assert the same thing several times. If any kind
-of assertion contains capturing subpatterns within it, these are counted for
-the purposes of numbering the capturing subpatterns in the whole pattern.
-However, substring capturing is carried out only for positive assertions,
-because it does not make sense for negative assertions.
-.
-.
-.SS "Lookahead assertions"
-.rs
-.sp
-Lookahead assertions start
-with (?= for positive assertions and (?! for negative assertions. For example,
-.sp
- \ew+(?=;)
-.sp
-matches a word followed by a semicolon, but does not include the semicolon in
-the match, and
-.sp
- foo(?!bar)
-.sp
-matches any occurrence of "foo" that is not followed by "bar". Note that the
-apparently similar pattern
-.sp
- (?!foo)bar
-.sp
-does not find an occurrence of "bar" that is preceded by something other than
-"foo"; it finds any occurrence of "bar" whatsoever, because the assertion
-(?!foo) is always true when the next three characters are "bar". A
-lookbehind assertion is needed to achieve the other effect.
-.P
-If you want to force a matching failure at some point in a pattern, the most
-convenient way to do it is with (?!) because an empty string always matches, so
-an assertion that requires there not to be an empty string must always fail.
-.
-.
-.\" HTML <a name="lookbehind"></a>
-.SS "Lookbehind assertions"
-.rs
-.sp
-Lookbehind assertions start with (?<= for positive assertions and (?<! for
-negative assertions. For example,
-.sp
- (?<!foo)bar
-.sp
-does find an occurrence of "bar" that is not preceded by "foo". The contents of
-a lookbehind assertion are restricted such that all the strings it matches must
-have a fixed length. However, if there are several alternatives, they do not
-all have to have the same fixed length. Thus
-.sp
- (?<=bullock|donkey)
-.sp
-is permitted, but
-.sp
- (?<!dogs?|cats?)
-.sp
-causes an error at compile time. Branches that match different length strings
-are permitted only at the top level of a lookbehind assertion. This is an
-extension compared with Perl (at least for 5.8), which requires all branches to
-match the same length of string. An assertion such as
-.sp
- (?<=ab(c|de))
-.sp
-is not permitted, because its single top-level branch can match two different
-lengths, but it is acceptable if rewritten to use two top-level branches:
-.sp
- (?<=abc|abde)
-.sp
-The implementation of lookbehind assertions is, for each alternative, to
-temporarily move the current position back by the fixed width and then try to
-match. If there are insufficient characters before the current position, the
-match is deemed to fail.
-.P
-PCRE does not allow the \eC escape (which matches a single byte in UTF-8 mode)
-to appear in lookbehind assertions, because it makes it impossible to calculate
-the length of the lookbehind. The \eX escape, which can match different numbers
-of bytes, is also not permitted.
-.P
-Atomic groups can be used in conjunction with lookbehind assertions to specify
-efficient matching at the end of the subject string. Consider a simple pattern
-such as
-.sp
- abcd$
-.sp
-when applied to a long string that does not match. Because matching proceeds
-from left to right, PCRE will look for each "a" in the subject and then see if
-what follows matches the rest of the pattern. If the pattern is specified as
-.sp
- ^.*abcd$
-.sp
-the initial .* matches the entire string at first, but when this fails (because
-there is no following "a"), it backtracks to match all but the last character,
-then all but the last two characters, and so on. Once again the search for "a"
-covers the entire string, from right to left, so we are no better off. However,
-if the pattern is written as
-.sp
- ^(?>.*)(?<=abcd)
-.sp
-or, equivalently, using the possessive quantifier syntax,
-.sp
- ^.*+(?<=abcd)
-.sp
-there can be no backtracking for the .* item; it can match only the entire
-string. The subsequent lookbehind assertion does a single test on the last four
-characters. If it fails, the match fails immediately. For long strings, this
-approach makes a significant difference to the processing time.
-.
-.
-.SS "Using multiple assertions"
-.rs
-.sp
-Several assertions (of any sort) may occur in succession. For example,
-.sp
- (?<=\ed{3})(?<!999)foo
-.sp
-matches "foo" preceded by three digits that are not "999". Notice that each of
-the assertions is applied independently at the same point in the subject
-string. First there is a check that the previous three characters are all
-digits, and then there is a check that the same three characters are not "999".
-This pattern does \fInot\fP match "foo" preceded by six characters, the first
-of which are digits and the last three of which are not "999". For example, it
-doesn't match "123abcfoo". A pattern to do that is
-.sp
- (?<=\ed{3}...)(?<!999)foo
-.sp
-This time the first assertion looks at the preceding six characters, checking
-that the first three are digits, and then the second assertion checks that the
-preceding three characters are not "999".
-.P
-Assertions can be nested in any combination. For example,
-.sp
- (?<=(?<!foo)bar)baz
-.sp
-matches an occurrence of "baz" that is preceded by "bar" which in turn is not
-preceded by "foo", while
-.sp
- (?<=\ed{3}(?!999)...)foo
-.sp
-is another pattern that matches "foo" preceded by three digits and any three
-characters that are not "999".
-.
-.
-.SH "CONDITIONAL SUBPATTERNS"
-.rs
-.sp
-It is possible to cause the matching process to obey a subpattern
-conditionally or to choose between two alternative subpatterns, depending on
-the result of an assertion, or whether a previous capturing subpattern matched
-or not. The two possible forms of conditional subpattern are
-.sp
- (?(condition)yes-pattern)
- (?(condition)yes-pattern|no-pattern)
-.sp
-If the condition is satisfied, the yes-pattern is used; otherwise the
-no-pattern (if present) is used. If there are more than two alternatives in the
-subpattern, a compile-time error occurs.
-.P
-There are three kinds of condition. If the text between the parentheses
-consists of a sequence of digits, the condition is satisfied if the capturing
-subpattern of that number has previously matched. The number must be greater
-than zero. 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 three parts for ease of discussion:
-.sp
- ( \e( )? [^()]+ (?(1) \e) )
-.sp
-The first part matches an optional opening parenthesis, and if that
-character is present, sets it as the first captured substring. The second part
-matches one or more characters that are not parentheses. The third part is a
-conditional subpattern that tests whether the first set of parentheses matched
-or not. If they did, that is, if subject started with an opening parenthesis,
-the condition is true, and so the yes-pattern is executed and a closing
-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 the condition is the string (R), it is satisfied if a recursive call to the
-pattern or subpattern has been made. At "top level", the condition is false.
-This is a PCRE extension. Recursive patterns are described in the next section.
-.P
-If the condition is not a sequence of digits or (R), it must be an assertion.
-This may be a positive or negative lookahead or lookbehind assertion. Consider
-this pattern, again containing non-significant white space, and with the two
-alternatives on the second line:
-.sp
- (?(?=[^a-z]*[a-z])
- \ed{2}-[a-z]{3}-\ed{2} | \ed{2}-\ed{2}-\ed{2} )
-.sp
-The condition is a positive lookahead assertion that matches an optional
-sequence of non-letters followed by a letter. In other words, it tests for the
-presence of at least one letter in the subject. If a letter is found, the
-subject is matched against the first alternative; otherwise it is matched
-against the second. This pattern matches strings in one of the two forms
-dd-aaa-dd or dd-dd-dd, where aaa are letters and dd are digits.
-.
-.
-.\" HTML <a name="comments"></a>
-.SH COMMENTS
-.rs
-.sp
-The sequence (?# marks the start of a comment that continues up to the next
-closing parenthesis. Nested parentheses are not permitted. The characters
-that make up a comment play no part in the pattern matching at all.
-.P
-If the PCRE_EXTENDED option is set, an unescaped # character outside a
-character class introduces a comment that continues up to the next newline
-character in the pattern.
-.
-.
-.SH "RECURSIVE PATTERNS"
-.rs
-.sp
-Consider the problem of matching a string in parentheses, allowing for
-unlimited nested parentheses. Without the use of recursion, the best that can
-be done is to use a pattern that matches up to some fixed depth of nesting. It
-is not possible to handle an arbitrary nesting depth. Perl provides a facility
-that allows regular expressions to recurse (amongst other things). It does this
-by interpolating Perl code in the expression at run time, and the code can
-refer to the expression itself. A Perl pattern to solve the parentheses problem
-can be created like this:
-.sp
- $re = qr{\e( (?: (?>[^()]+) | (?p{$re}) )* \e)}x;
-.sp
-The (?p{...}) item interpolates Perl code at run time, and in this case refers
-recursively to the pattern in which it appears. Obviously, PCRE cannot support
-the interpolation of Perl code. Instead, it supports some special syntax for
-recursion of the entire pattern, and also for individual subpattern recursion.
-.P
-The special item that consists of (? followed by a number greater than zero and
-a closing parenthesis is a recursive call of the subpattern of the given
-number, provided that it occurs inside that subpattern. (If not, it is a
-"subroutine" call, which is described in the next section.) The special item
-(?R) is a recursive call of the entire regular expression.
-.P
-For example, this PCRE pattern solves the nested parentheses problem (assume
-the PCRE_EXTENDED option is set so that white space is ignored):
-.sp
- \e( ( (?>[^()]+) | (?R) )* \e)
-.sp
-First it matches an opening parenthesis. Then it matches any number of
-substrings which can either be a sequence of non-parentheses, or a recursive
-match of the pattern itself (that is a correctly parenthesized substring).
-Finally there is a closing parenthesis.
-.P
-If this were part of a larger pattern, you would not want to recurse the entire
-pattern, so instead you could use this:
-.sp
- ( \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
-parenthesis numbers can be tricky. It may be more convenient to use named
-parentheses instead. For this, PCRE uses (?P>name), which is an extension to
-the Python syntax that PCRE uses for named parentheses (Perl does not provide
-named parentheses). We could rewrite the above example as follows:
-.sp
- (?P<pn> \e( ( (?>[^()]+) | (?P>pn) )* \e) )
-.sp
-This particular example pattern 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
-.sp
- (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()
-.sp
-it yields "no match" quickly. However, if atomic grouping is not used,
-the match runs for a very long time indeed because there are so many different
-ways the + and * repeats can carve up the subject, and all have to be tested
-before failure can be reported.
-.P
-At the end of a match, the values set for any capturing subpatterns are those
-from the outermost level of the recursion at which the subpattern value is set.
-If you want to obtain intermediate values, a callout function can be used (see
-the next section and the
-.\" HREF
-\fBpcrecallout\fP
-.\"
-documentation). If the pattern above is matched against
-.sp
- (ab(cd)ef)
-.sp
-the value for the capturing parentheses is "ef", which is the last value taken
-on at the top level. If additional parentheses are added, giving
-.sp
- \e( ( ( (?>[^()]+) | (?R) )* ) \e)
- ^ ^
- ^ ^
-.sp
-the string they capture is "ab(cd)ef", the contents of the top level
-parentheses. If there are more than 15 capturing parentheses in a pattern, PCRE
-has to obtain extra memory to store data during a recursion, which it does by
-using \fBpcre_malloc\fP, freeing it via \fBpcre_free\fP afterwards. If no
-memory can be obtained, the match fails with the PCRE_ERROR_NOMEMORY error.
-.P
-Do not confuse the (?R) item with the condition (R), which tests for recursion.
-Consider this pattern, which matches text in angle brackets, allowing for
-arbitrary nesting. Only digits are allowed in nested brackets (that is, when
-recursing), whereas any characters are permitted at the outer level.
-.sp
- < (?: (?(R) \ed++ | [^<>]*+) | (?R)) * >
-.sp
-In this pattern, (?(R) is the start of a conditional subpattern, with two
-different alternatives for the recursive and non-recursive cases. The (?R) item
-is the actual recursive call.
-.
-.
-.\" HTML <a name="subpatternsassubroutines"></a>
-.SH "SUBPATTERNS AS SUBROUTINES"
-.rs
-.sp
-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. An earlier example pointed out that the
-pattern
-.sp
- (sens|respons)e and \e1ibility
-.sp
-matches "sense and sensibility" and "response and responsibility", but not
-"sense and responsibility". If instead the pattern
-.sp
- (sens|respons)e and (?1)ibility
-.sp
-is used, it does match "sense and responsibility" as well as the other two
-strings. Such references must, however, follow the subpattern to which they
-refer.
-.
-.
-.SH CALLOUTS
-.rs
-.sp
-Perl has a feature whereby using the sequence (?{...}) causes arbitrary Perl
-code to be obeyed in the middle of matching a regular expression. This makes it
-possible, amongst other things, to extract different substrings that match the
-same pair of parentheses when there is a repetition.
-.P
-PCRE provides a similar feature, but of course it cannot obey arbitrary Perl
-code. The feature is called "callout". The caller of PCRE provides an external
-function by putting its entry point in the global variable \fIpcre_callout\fP.
-By default, this variable contains NULL, which disables all calling out.
-.P
-Within a regular expression, (?C) indicates the points at which the external
-function is to be called. If you want to identify different callout points, you
-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
-.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
-255.
-.P
-During matching, when PCRE reaches a callout point (and \fIpcre_callout\fP is
-set), the external function is called. It is provided with the number of the
-callout, the position in the pattern, and, optionally, one item of data
-originally supplied by the caller of \fBpcre_exec()\fP. The callout function
-may cause matching to proceed, to backtrack, or to fail altogether. A complete
-description of the interface to the callout function is given in the
-.\" HREF
-\fBpcrecallout\fP
-.\"
-documentation.
-.P
-.in 0
-Last updated: 09 September 2004
-.br
-Copyright (c) 1997-2004 University of Cambridge.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH "PCRE PERFORMANCE"
-.rs
-.sp
-Certain items that may appear in regular expression patterns are more efficient
-than others. It is more efficient to use a character class like [aeiou] than a
-set of alternatives such as (a|e|i|o|u). In general, the simplest construction
-that provides the required behaviour is usually the most efficient. Jeffrey
-Friedl's book contains a lot of useful general discussion about optimizing
-regular expressions for efficient performance. This document contains a few
-observations about PCRE.
-.P
-Using Unicode character properties (the \ep, \eP, and \eX escapes) is slow,
-because PCRE has to scan a structure that contains data for over fifteen
-thousand characters whenever it needs a character's property. If you can find
-an alternative pattern that does not use character properties, it will probably
-be faster.
-.P
-When a pattern begins with .* not in parentheses, or in parentheses that are
-not the subject of a backreference, and the PCRE_DOTALL option is set, the
-pattern is implicitly anchored by PCRE, since it can match only at the start of
-a subject string. However, if PCRE_DOTALL is not set, PCRE cannot make this
-optimization, because the . metacharacter does not then match a newline, and if
-the subject string contains newlines, the pattern may match from the character
-immediately following one of them instead of from the very start. For example,
-the pattern
-.sp
- .*second
-.sp
-matches the subject "first\enand second" (where \en stands for a newline
-character), with the match starting at the seventh character. In order to do
-this, PCRE has to retry the match starting after every newline in the subject.
-.P
-If you are using such a pattern with subject strings that do not contain
-newlines, the best performance is obtained by setting PCRE_DOTALL, or starting
-the pattern with ^.* to indicate explicit anchoring. That saves PCRE from
-having to scan along the subject looking for a newline to restart at.
-.P
-Beware of patterns that contain nested indefinite repeats. These can take a
-long time to run when applied to a string that does not match. Consider the
-pattern fragment
-.sp
- (a+)*
-.sp
-This can match "aaaa" in 33 different ways, and this number increases very
-rapidly as the string gets longer. (The * repeat can match 0, 1, 2, 3, or 4
-times, and for each of those cases other than 0, the + repeats can match
-different numbers of times.) When the remainder of the pattern is such that the
-entire match is going to fail, PCRE has in principle to try every possible
-variation, and this can take an extremely long time.
-.P
-An optimization catches some of the more simple cases such as
-.sp
- (a+)*b
-.sp
-where a literal character follows. Before embarking on the standard matching
-procedure, PCRE checks that there is a "b" later in the subject string, and if
-there is not, it fails the match immediately. However, when there is no
-following literal this optimization cannot be used. You can see the difference
-by comparing the behaviour of
-.sp
- (a+)*\ed
-.sp
-with the pattern above. The former gives a failure almost instantly when
-applied to a whole line of "a" characters, whereas the latter takes an
-appreciable time with strings longer than about 20 characters.
-.P
-In many cases, the solution to this kind of performance issue is to use an
-atomic group or a possessive quantifier.
-.P
-.in 0
-Last updated: 09 September 2004
-.br
-Copyright (c) 1997-2004 University of Cambridge.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions.
-.SH "SYNOPSIS OF POSIX API"
-.rs
-.sp
-.B #include <pcreposix.h>
-.PP
-.SM
-.br
-.B int regcomp(regex_t *\fIpreg\fP, const char *\fIpattern\fP,
-.ti +5n
-.B int \fIcflags\fP);
-.PP
-.br
-.B int regexec(regex_t *\fIpreg\fP, const char *\fIstring\fP,
-.ti +5n
-.B size_t \fInmatch\fP, regmatch_t \fIpmatch\fP[], int \fIeflags\fP);
-.PP
-.br
-.B size_t regerror(int \fIerrcode\fP, const regex_t *\fIpreg\fP,
-.ti +5n
-.B char *\fIerrbuf\fP, size_t \fIerrbuf_size\fP);
-.PP
-.br
-.B void regfree(regex_t *\fIpreg\fP);
-.
-.SH DESCRIPTION
-.rs
-.sp
-This set of functions provides a POSIX-style API to the PCRE regular expression
-package. See the
-.\" HREF
-\fBpcreapi\fP
-.\"
-documentation for a description of PCRE's native API, which contains additional
-functionality.
-.P
-The functions described here are just wrapper functions that ultimately call
-the PCRE native API. Their prototypes are defined in the \fBpcreposix.h\fP
-header file, and on Unix systems the library itself is called
-\fBpcreposix.a\fP, so can be accessed by adding \fB-lpcreposix\fP to the
-command for linking an application that uses them. Because the POSIX functions
-call the native ones, it is also necessary to add \fB-lpcre\fP.
-.P
-I have implemented only those option bits that can be reasonably mapped to PCRE
-native options. In addition, the options REG_EXTENDED and REG_NOSUB are defined
-with the value zero. They have no effect, but since programs that are written
-to the POSIX interface often use them, this makes it easier to slot in PCRE as
-a replacement library. Other POSIX options are not even defined.
-.P
-When PCRE is called via these functions, it is only the API that is POSIX-like
-in style. The syntax and semantics of the regular expressions themselves are
-still those of Perl, subject to the setting of various PCRE options, as
-described below. "POSIX-like in style" means that the API approximates to the
-POSIX definition; it is not fully POSIX-compatible, and in multi-byte encoding
-domains it is probably even less compatible.
-.P
-The header for these functions is supplied as \fBpcreposix.h\fP to avoid any
-potential clash with other POSIX libraries. It can, of course, be renamed or
-aliased as \fBregex.h\fP, which is the "correct" name. It provides two
-structure types, \fIregex_t\fP for compiled internal forms, and
-\fIregmatch_t\fP for returning captured substrings. It also defines some
-constants whose names start with "REG_"; these are used for setting options and
-identifying error codes.
-.P
-.SH "COMPILING A PATTERN"
-.rs
-.sp
-The function \fBregcomp()\fP is called to compile a pattern into an
-internal form. The pattern is a C string terminated by a binary zero, and
-is passed in the argument \fIpattern\fP. The \fIpreg\fP argument is a pointer
-to a \fBregex_t\fP structure that is used as a base for storing information
-about the compiled expression.
-.P
-The argument \fIcflags\fP is either zero, or contains one or more of the bits
-defined by the following macros:
-.sp
- REG_ICASE
-.sp
-The PCRE_CASELESS option is set when the expression is passed for compilation
-to the native function.
-.sp
- REG_NEWLINE
-.sp
-The PCRE_MULTILINE option is set when the expression is passed for compilation
-to the native function. Note that this does \fInot\fP mimic the defined POSIX
-behaviour for REG_NEWLINE (see the following section).
-.P
-In the absence of these flags, no options are passed to the native function.
-This means the the regex is compiled with PCRE default semantics. In
-particular, the way it handles newline characters in the subject string is the
-Perl way, not the POSIX way. Note that setting PCRE_MULTILINE has only
-\fIsome\fP of the effects specified for REG_NEWLINE. It does not affect the way
-newlines are matched by . (they aren't) or by a negative class such as [^a]
-(they are).
-.P
-The yield of \fBregcomp()\fP is zero on success, and non-zero otherwise. The
-\fIpreg\fP structure is filled in on success, and one member of the structure
-is public: \fIre_nsub\fP contains the number of capturing subpatterns in
-the regular expression. Various error codes are defined in the header file.
-.
-.
-.SH "MATCHING NEWLINE CHARACTERS"
-.rs
-.sp
-This area is not simple, because POSIX and Perl take different views of things.
-It is not possible to get PCRE to obey POSIX semantics, but then PCRE was never
-intended to be a POSIX engine. The following table lists the different
-possibilities for matching newline characters in PCRE:
-.sp
- Default Change with
-.sp
- . matches newline no PCRE_DOTALL
- newline matches [^a] yes not changeable
- $ matches \en at end yes PCRE_DOLLARENDONLY
- $ matches \en in middle no PCRE_MULTILINE
- ^ matches \en in middle no PCRE_MULTILINE
-.sp
-This is the equivalent table for POSIX:
-.sp
- Default Change with
-.sp
- . matches newline yes REG_NEWLINE
- newline matches [^a] yes REG_NEWLINE
- $ matches \en at end no REG_NEWLINE
- $ matches \en in middle no REG_NEWLINE
- ^ matches \en in middle no REG_NEWLINE
-.sp
-PCRE's behaviour is the same as Perl's, except that there is no equivalent for
-PCRE_DOLLAR_ENDONLY in Perl. In both PCRE and Perl, there is no way to stop
-newline from matching [^a].
-.P
-The default POSIX newline handling can be obtained by setting PCRE_DOTALL and
-PCRE_DOLLAR_ENDONLY, but there is no way to make PCRE behave exactly as for the
-REG_NEWLINE action.
-.
-.
-.SH "MATCHING A PATTERN"
-.rs
-.sp
-The function \fBregexec()\fP is called to match a compiled pattern \fIpreg\fP
-against a given \fIstring\fP, which is terminated by a zero byte, subject to
-the options in \fIeflags\fP. These can be:
-.sp
- REG_NOTBOL
-.sp
-The PCRE_NOTBOL option is set when calling the underlying PCRE matching
-function.
-.sp
- REG_NOTEOL
-.sp
-The PCRE_NOTEOL option is set when calling the underlying PCRE matching
-function.
-.P
-The portion of the string that was matched, and also any captured substrings,
-are returned via the \fIpmatch\fP argument, which points to an array of
-\fInmatch\fP structures of type \fIregmatch_t\fP, containing the members
-\fIrm_so\fP and \fIrm_eo\fP. These contain the offset to the first character of
-each substring and the offset to the first character after the end of each
-substring, respectively. The 0th element of the vector relates to the entire
-portion of \fIstring\fP that was matched; subsequent elements relate to the
-capturing subpatterns of the regular expression. Unused entries in the array
-have both structure members set to -1.
-.P
-A successful match yields a zero return; various error codes are defined in the
-header file, of which REG_NOMATCH is the "expected" failure code.
-.
-.
-.SH "ERROR MESSAGES"
-.rs
-.sp
-The \fBregerror()\fP function maps a non-zero errorcode from either
-\fBregcomp()\fP or \fBregexec()\fP to a printable message. If \fIpreg\fP is not
-NULL, the error should have arisen from the use of that structure. A message
-terminated by a binary zero is placed in \fIerrbuf\fP. The length of the
-message, including the zero, is limited to \fIerrbuf_size\fP. The yield of the
-function is the size of buffer needed to hold the whole message.
-.
-.
-.SH MEMORY USAGE
-.rs
-.sp
-Compiling a regular expression causes memory to be allocated and associated
-with the \fIpreg\fP structure. The function \fBregfree()\fP frees all such
-memory, after which \fIpreg\fP may no longer be used as a compiled expression.
-.
-.
-.SH AUTHOR
-.rs
-.sp
-Philip Hazel <ph10@cam.ac.uk>
-.br
-University Computing Service,
-.br
-Cambridge CB2 3QG, England.
-.P
-.in 0
-Last updated: 07 September 2004
-.br
-Copyright (c) 1997-2004 University of Cambridge.
+++ /dev/null
-<HTML>
-<HEAD>
-<TITLE>pcreposix specification</TITLE>
-</HEAD>
-<body bgcolor="#FFFFFF" text="#00005A">
-<H1>pcreposix specification</H1>
-This HTML document has been generated automatically from the original man page.
-If there is any nonsense in it, please consult the man page in case the
-conversion went wrong.
-<UL>
-<LI><A NAME="TOC1" HREF="#SEC1">NAME</A>
-<LI><A NAME="TOC2" HREF="#SEC2">SYNOPSIS</A>
-<LI><A NAME="TOC3" HREF="#SEC3">DESCRIPTION</A>
-<LI><A NAME="TOC4" HREF="#SEC4">COMPILING A PATTERN</A>
-<LI><A NAME="TOC5" HREF="#SEC5">MATCHING A PATTERN</A>
-<LI><A NAME="TOC6" HREF="#SEC6">ERROR MESSAGES</A>
-<LI><A NAME="TOC7" HREF="#SEC7">STORAGE</A>
-<LI><A NAME="TOC8" HREF="#SEC8">AUTHOR</A>
-</UL>
-<LI><A NAME="SEC1" HREF="#TOC1">NAME</A>
-<P>
-pcreposix - POSIX API for Perl-compatible regular expressions.
-</P>
-<LI><A NAME="SEC2" HREF="#TOC1">SYNOPSIS</A>
-<P>
-<B>#include <pcreposix.h></B>
-</P>
-<P>
-<B>int regcomp(regex_t *<I>preg</I>, const char *<I>pattern</I>,</B>
-<B>int <I>cflags</I>);</B>
-</P>
-<P>
-<B>int regexec(regex_t *<I>preg</I>, const char *<I>string</I>,</B>
-<B>size_t <I>nmatch</I>, regmatch_t <I>pmatch</I>[], int <I>eflags</I>);</B>
-</P>
-<P>
-<B>size_t regerror(int <I>errcode</I>, const regex_t *<I>preg</I>,</B>
-<B>char *<I>errbuf</I>, size_t <I>errbuf_size</I>);</B>
-</P>
-<P>
-<B>void regfree(regex_t *<I>preg</I>);</B>
-</P>
-<LI><A NAME="SEC3" HREF="#TOC1">DESCRIPTION</A>
-<P>
-This set of functions provides a POSIX-style API to the PCRE regular expression
-package. See the <B>pcre</B> documentation for a description of the native API,
-which contains additional functionality.
-</P>
-<P>
-The functions described here are just wrapper functions that ultimately call
-the native API. Their prototypes are defined in the <B>pcreposix.h</B> header
-file, and on Unix systems the library itself is called <B>pcreposix.a</B>, so
-can be accessed by adding <B>-lpcreposix</B> to the command for linking an
-application which uses them. Because the POSIX functions call the native ones,
-it is also necessary to add \fR-lpcre\fR.
-</P>
-<P>
-I have implemented only those option bits that can be reasonably mapped to PCRE
-native options. In addition, the options REG_EXTENDED and REG_NOSUB are defined
-with the value zero. They have no effect, but since programs that are written
-to the POSIX interface often use them, this makes it easier to slot in PCRE as
-a replacement library. Other POSIX options are not even defined.
-</P>
-<P>
-When PCRE is called via these functions, it is only the API that is POSIX-like
-in style. The syntax and semantics of the regular expressions themselves are
-still those of Perl, subject to the setting of various PCRE options, as
-described below.
-</P>
-<P>
-The header for these functions is supplied as <B>pcreposix.h</B> to avoid any
-potential clash with other POSIX libraries. It can, of course, be renamed or
-aliased as <B>regex.h</B>, which is the "correct" name. It provides two
-structure types, <I>regex_t</I> for compiled internal forms, and
-<I>regmatch_t</I> for returning captured substrings. It also defines some
-constants whose names start with "REG_"; these are used for setting options and
-identifying error codes.
-</P>
-<LI><A NAME="SEC4" HREF="#TOC1">COMPILING A PATTERN</A>
-<P>
-The function <B>regcomp()</B> is called to compile a pattern into an
-internal form. The pattern is a C string terminated by a binary zero, and
-is passed in the argument <I>pattern</I>. The <I>preg</I> argument is a pointer
-to a regex_t structure which is used as a base for storing information about
-the compiled expression.
-</P>
-<P>
-The argument <I>cflags</I> is either zero, or contains one or more of the bits
-defined by the following macros:
-</P>
-<P>
-<PRE>
- REG_ICASE
-</PRE>
-</P>
-<P>
-The PCRE_CASELESS option is set when the expression is passed for compilation
-to the native function.
-</P>
-<P>
-<PRE>
- REG_NEWLINE
-</PRE>
-</P>
-<P>
-The PCRE_MULTILINE option is set when the expression is passed for compilation
-to the native function.
-</P>
-<P>
-In the absence of these flags, no options are passed to the native function.
-This means the the regex is compiled with PCRE default semantics. In
-particular, the way it handles newline characters in the subject string is the
-Perl way, not the POSIX way. Note that setting PCRE_MULTILINE has only
-<I>some</I> of the effects specified for REG_NEWLINE. It does not affect the way
-newlines are matched by . (they aren't) or a negative class such as [^a] (they
-are).
-</P>
-<P>
-The yield of <B>regcomp()</B> is zero on success, and non-zero otherwise. The
-<I>preg</I> structure is filled in on success, and one member of the structure
-is publicized: <I>re_nsub</I> contains the number of capturing subpatterns in
-the regular expression. Various error codes are defined in the header file.
-</P>
-<LI><A NAME="SEC5" HREF="#TOC1">MATCHING A PATTERN</A>
-<P>
-The function <B>regexec()</B> is called to match a pre-compiled pattern
-<I>preg</I> against a given <I>string</I>, which is terminated by a zero byte,
-subject to the options in <I>eflags</I>. These can be:
-</P>
-<P>
-<PRE>
- REG_NOTBOL
-</PRE>
-</P>
-<P>
-The PCRE_NOTBOL option is set when calling the underlying PCRE matching
-function.
-</P>
-<P>
-<PRE>
- REG_NOTEOL
-</PRE>
-</P>
-<P>
-The PCRE_NOTEOL option is set when calling the underlying PCRE matching
-function.
-</P>
-<P>
-The portion of the string that was matched, and also any captured substrings,
-are returned via the <I>pmatch</I> argument, which points to an array of
-<I>nmatch</I> structures of type <I>regmatch_t</I>, containing the members
-<I>rm_so</I> and <I>rm_eo</I>. These contain the offset to the first character of
-each substring and the offset to the first character after the end of each
-substring, respectively. The 0th element of the vector relates to the entire
-portion of <I>string</I> that was matched; subsequent elements relate to the
-capturing subpatterns of the regular expression. Unused entries in the array
-have both structure members set to -1.
-</P>
-<P>
-A successful match yields a zero return; various error codes are defined in the
-header file, of which REG_NOMATCH is the "expected" failure code.
-</P>
-<LI><A NAME="SEC6" HREF="#TOC1">ERROR MESSAGES</A>
-<P>
-The <B>regerror()</B> function maps a non-zero errorcode from either
-<B>regcomp</B> or <B>regexec</B> to a printable message. If <I>preg</I> is not
-NULL, the error should have arisen from the use of that structure. A message
-terminated by a binary zero is placed in <I>errbuf</I>. The length of the
-message, including the zero, is limited to <I>errbuf_size</I>. The yield of the
-function is the size of buffer needed to hold the whole message.
-</P>
-<LI><A NAME="SEC7" HREF="#TOC1">STORAGE</A>
-<P>
-Compiling a regular expression causes memory to be allocated and associated
-with the <I>preg</I> structure. The function <B>regfree()</B> frees all such
-memory, after which <I>preg</I> may no longer be used as a compiled expression.
-</P>
-<LI><A NAME="SEC8" HREF="#TOC1">AUTHOR</A>
-<P>
-Philip Hazel <ph10@cam.ac.uk>
-<BR>
-University Computing Service,
-<BR>
-New Museums Site,
-<BR>
-Cambridge CB2 3QG, England.
-<BR>
-Phone: +44 1223 334714
-</P>
-<P>
-Copyright (c) 1997-2000 University of Cambridge.
+++ /dev/null
-NAME
- pcreposix - POSIX API for Perl-compatible regular expres-
- sions.
-
-
-
-SYNOPSIS
- #include <pcreposix.h>
-
- int regcomp(regex_t *preg, const char *pattern,
- int cflags);
-
- int regexec(regex_t *preg, const char *string,
- size_t nmatch, regmatch_t pmatch[], int eflags);
-
- size_t regerror(int errcode, const regex_t *preg,
- char *errbuf, size_t errbuf_size);
-
- void regfree(regex_t *preg);
-
-
-
-DESCRIPTION
- This set of functions provides a POSIX-style API to the PCRE
- regular expression package. See the pcre documentation for a
- description of the native API, which contains additional
- functionality.
-
- The functions described here are just wrapper functions that
- ultimately call the native API. Their prototypes are defined
- in the pcreposix.h header file, and on Unix systems the
- library itself is called pcreposix.a, so can be accessed by
- adding -lpcreposix to the command for linking an application
- which uses them. Because the POSIX functions call the native
- ones, it is also necessary to add -lpcre.
-
- I have implemented only those option bits that can be rea-
- sonably mapped to PCRE native options. In addition, the
- options REG_EXTENDED and REG_NOSUB are defined with the
- value zero. They have no effect, but since programs that are
- written to the POSIX interface often use them, this makes it
- easier to slot in PCRE as a replacement library. Other POSIX
- options are not even defined.
-
- When PCRE is called via these functions, it is only the API
- that is POSIX-like in style. The syntax and semantics of the
- regular expressions themselves are still those of Perl, sub-
- ject to the setting of various PCRE options, as described
- below.
-
- The header for these functions is supplied as pcreposix.h to
- avoid any potential clash with other POSIX libraries. It
- can, of course, be renamed or aliased as regex.h, which is
- the "correct" name. It provides two structure types, regex_t
- for compiled internal forms, and regmatch_t for returning
- captured substrings. It also defines some constants whose
- names start with "REG_"; these are used for setting options
- and identifying error codes.
-
-
-
-COMPILING A PATTERN
- The function regcomp() is called to compile a pattern into
- an internal form. The pattern is a C string terminated by a
- binary zero, and is passed in the argument pattern. The preg
- argument is a pointer to a regex_t structure which is used
- as a base for storing information about the compiled expres-
- sion.
-
- The argument cflags is either zero, or contains one or more
- of the bits defined by the following macros:
-
- REG_ICASE
-
- The PCRE_CASELESS option is set when the expression is
- passed for compilation to the native function.
-
- REG_NEWLINE
-
- The PCRE_MULTILINE option is set when the expression is
- passed for compilation to the native function.
-
- In the absence of these flags, no options are passed to the
- native function. This means the the regex is compiled with
- PCRE default semantics. In particular, the way it handles
- newline characters in the subject string is the Perl way,
- not the POSIX way. Note that setting PCRE_MULTILINE has only
- some of the effects specified for REG_NEWLINE. It does not
- affect the way newlines are matched by . (they aren't) or a
- negative class such as [^a] (they are).
-
- The yield of regcomp() is zero on success, and non-zero oth-
- erwise. The preg structure is filled in on success, and one
- member of the structure is publicized: re_nsub contains the
- number of capturing subpatterns in the regular expression.
- Various error codes are defined in the header file.
-
-
-
-MATCHING A PATTERN
- The function regexec() is called to match a pre-compiled
- pattern preg against a given string, which is terminated by
- a zero byte, subject to the options in eflags. These can be:
-
- REG_NOTBOL
-
- The PCRE_NOTBOL option is set when calling the underlying
- PCRE matching function.
-
- REG_NOTEOL
-
- The PCRE_NOTEOL option is set when calling the underlying
- PCRE matching function.
-
- The portion of the string that was matched, and also any
- captured substrings, are returned via the pmatch argument,
- which points to an array of nmatch structures of type
- regmatch_t, containing the members rm_so and rm_eo. These
- contain the offset to the first character of each substring
- and the offset to the first character after the end of each
- substring, respectively. The 0th element of the vector
- relates to the entire portion of string that was matched;
- subsequent elements relate to the capturing subpatterns of
- the regular expression. Unused entries in the array have
- both structure members set to -1.
-
- A successful match yields a zero return; various error codes
- are defined in the header file, of which REG_NOMATCH is the
- "expected" failure code.
-
-
-
-ERROR MESSAGES
- The regerror() function maps a non-zero errorcode from
- either regcomp or regexec to a printable message. If preg is
- not NULL, the error should have arisen from the use of that
- structure. A message terminated by a binary zero is placed
- in errbuf. The length of the message, including the zero, is
- limited to errbuf_size. The yield of the function is the
- size of buffer needed to hold the whole message.
-
-
-
-STORAGE
- Compiling a regular expression causes memory to be allocated
- and associated with the preg structure. The function reg-
- free() frees all such memory, after which preg may no longer
- be used as a compiled expression.
-
-
-
-AUTHOR
- Philip Hazel <ph10@cam.ac.uk>
- University Computing Service,
- New Museums Site,
- Cambridge CB2 3QG, England.
- Phone: +44 1223 334714
-
- Copyright (c) 1997-2000 University of Cambridge.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH "SAVING AND RE-USING PRECOMPILED PCRE PATTERNS"
-.rs
-.sp
-If you are running an application that uses a large number of regular
-expression patterns, it may be useful to store them in a precompiled form
-instead of having to compile them every time the application is run.
-If you are not using any private character tables (see the
-.\" HREF
-\fBpcre_maketables()\fP
-.\"
-documentation), this is relatively straightforward. If you are using private
-tables, it is a little bit more complicated.
-.P
-If you save compiled patterns to a file, you can copy them to a different host
-and run them there. This works even if the new host has the opposite endianness
-to the one on which the patterns were compiled. There may be a small
-performance penalty, but it should be insignificant.
-.
-.
-.SH "SAVING A COMPILED PATTERN"
-.rs
-.sh
-The value returned by \fBpcre_compile()\fP points to a single block of memory
-that holds the compiled pattern and associated data. You can find the length of
-this block in bytes by calling \fBpcre_fullinfo()\fP with an argument of
-PCRE_INFO_SIZE. You can then save the data in any appropriate manner. Here is
-sample code that compiles a pattern and writes it to a file. It assumes that
-the variable \fIfd\fP refers to a file that is open for output:
-.sp
- int erroroffset, rc, size;
- char *error;
- pcre *re;
-.sp
- re = pcre_compile("my pattern", 0, &error, &erroroffset, NULL);
- if (re == NULL) { ... handle errors ... }
- rc = pcre_fullinfo(re, NULL, PCRE_INFO_SIZE, &size);
- if (rc < 0) { ... handle errors ... }
- rc = fwrite(re, 1, size, fd);
- if (rc != size) { ... handle errors ... }
-.sp
-In this example, the bytes that comprise the compiled pattern are copied
-exactly. Note that this is binary data that may contain any of the 256 possible
-byte values. On systems that make a distinction between binary and non-binary
-data, be sure that the file is opened for binary output.
-.P
-If you want to write more than one pattern to a file, you will have to devise a
-way of separating them. For binary data, preceding each pattern with its length
-is probably the most straightforward approach. Another possibility is to write
-out the data in hexadecimal instead of binary, one pattern to a line.
-.P
-Saving compiled patterns in a file is only one possible way of storing them for
-later use. They could equally well be saved in a database, or in the memory of
-some daemon process that passes them via sockets to the processes that want
-them.
-.P
-If the pattern has been studied, it is also possible to save the study data in
-a similar way to the compiled pattern itself. When studying generates
-additional information, \fBpcre_study()\fP returns a pointer to a
-\fBpcre_extra\fP data block. Its format is defined in the
-.\" HTML <a href="pcreapi.html#extradata">
-.\" </a>
-section on matching a pattern
-.\"
-in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-documentation. The \fIstudy_data\fP field points to the binary study data, and
-this is what you must save (not the \fBpcre_extra\fP block itself). The length
-of the study data can be obtained by calling \fBpcre_fullinfo()\fP with an
-argument of PCRE_INFO_STUDYSIZE. Remember to check that \fBpcre_study()\fP did
-return a non-NULL value before trying to save the study data.
-.
-.
-.SH "RE-USING A PRECOMPILED PATTERN"
-.rs
-.sp
-Re-using a precompiled pattern is straightforward. Having reloaded it into main
-memory, you pass its pointer to \fBpcre_exec()\fP in the usual way. This should
-work even on another host, and even if that host has the opposite endianness to
-the one where the pattern was compiled.
-.P
-However, if you passed a pointer to custom character tables when the pattern
-was compiled (the \fItableptr\fP argument of \fBpcre_compile()\fP), you must
-now pass a similar pointer to \fBpcre_exec()\fP, because the value saved with
-the compiled pattern will obviously be nonsense. A field in a
-\fBpcre_extra()\fP block is used to pass this data, as described in the
-.\" HTML <a href="pcreapi.html#extradata">
-.\" </a>
-section on matching a pattern
-.\"
-in the
-.\" HREF
-\fBpcreapi\fP
-.\"
-documentation.
-.P
-If you did not provide custom character tables when the pattern was compiled,
-the pointer in the compiled pattern is NULL, which causes \fBpcre_exec()\fP to
-use PCRE's internal tables. Thus, you do not need to take any special action at
-run time in this case.
-.P
-If you saved study data with the compiled pattern, you need to create your own
-\fBpcre_extra\fP data block and set the \fIstudy_data\fP field to point to the
-reloaded study data. You must also set the PCRE_EXTRA_STUDY_DATA bit in the
-\fIflags\fP field to indicate that study data is present. Then pass the
-\fBpcre_extra\fP block to \fBpcre_exec()\fP in the usual way.
-.
-.
-.SH "COMPATIBILITY WITH DIFFERENT PCRE RELEASES"
-.rs
-.sp
-The layout of the control block that is at the start of the data that makes up
-a compiled pattern was changed for release 5.0. If you have any saved patterns
-that were compiled with previous releases (not a facility that was previously
-advertised), you will have to recompile them for release 5.0. However, from now
-on, it should be possible to make changes in a compabible manner.
-.P
-.in 0
-Last updated: 10 September 2004
-.br
-Copyright (c) 1997-2004 University of Cambridge.
+++ /dev/null
-.TH PCRE 3
-.SH NAME
-PCRE - Perl-compatible regular expressions
-.SH "PCRE SAMPLE PROGRAM"
-.rs
-.sp
-A simple, complete demonstration program, to get you started with using PCRE,
-is supplied in the file \fIpcredemo.c\fP in the PCRE distribution.
-.P
-The program compiles the regular expression that is its first argument, and
-matches it against the subject string in its second argument. No PCRE options
-are set, and default character tables are used. If matching succeeds, the
-program outputs the portion of the subject that matched, together with the
-contents of any captured substrings.
-.P
-If the -g option is given on the command line, the program then goes on to
-check for further matches of the same regular expression in the same subject
-string. The logic is a little bit tricky because of the possibility of matching
-an empty string. Comments in the code explain what is going on.
-.P
-If PCRE is installed in the standard include and library directories for your
-system, you should be able to compile the demonstration program using this
-command:
-.sp
- gcc -o pcredemo pcredemo.c -lpcre
-.sp
-If PCRE is installed elsewhere, you may need to add additional options to the
-command line. For example, on a Unix-like system that has PCRE installed in
-\fI/usr/local\fP, you can compile the demonstration program using a command
-like this:
-.sp
-.\" JOINSH
- gcc -o pcredemo -I/usr/local/include pcredemo.c \e
- -L/usr/local/lib -lpcre
-.sp
-Once you have compiled the demonstration program, you can run simple tests like
-this:
-.sp
- ./pcredemo 'cat|dog' 'the cat sat on the mat'
- ./pcredemo -g 'cat|dog' 'the dog sat on the cat'
-.sp
-Note that there is a much more comprehensive test program, called
-.\" HREF
-\fBpcretest\fP,
-.\"
-which supports many more facilities for testing regular expressions and the
-PCRE library. The \fBpcredemo\fP program is provided as a simple coding
-example.
-.P
-On some operating systems (e.g. Solaris), when PCRE is not installed in the
-standard library directory, you may get an error like this when you try to run
-\fBpcredemo\fP:
-.sp
- ld.so.1: a.out: fatal: libpcre.so.0: open failed: No such file or directory
-.sp
-This is caused by the way shared library support works on those systems. You
-need to add
-.sp
- -R/usr/local/lib
-.sp
-(for example) to the compile command to get round this problem.
-.P
-.in 0
-Last updated: 09 September 2004
-.br
-Copyright (c) 1997-2004 University of Cambridge.
+++ /dev/null
-.TH PCRETEST 1
-.SH NAME
-pcretest - a program for testing Perl-compatible regular expressions.
-.SH SYNOPSIS
-.rs
-.sp
-.B pcretest "[-C] [-d] [-i] [-m] [-o osize] [-p] [-t] [source]"
-.ti +5n
-.B "[destination]"
-.P
-\fBpcretest\fP was written as a test program for the PCRE regular expression
-library itself, but it can also be used for experimenting with regular
-expressions. This document describes the features of the test program; for
-details of the regular expressions themselves, see the
-.\" HREF
-\fBpcrepattern\fP
-.\"
-documentation. For details of the PCRE library function calls and their
-options, see the
-.\" HREF
-\fBpcreapi\fP
-.\"
-documentation.
-.
-.
-.SH OPTIONS
-.rs
-.TP 10
-\fB-C\fP
-Output the version number of the PCRE library, and all available information
-about the optional features that are included, and then exit.
-.TP 10
-\fB-d\fP
-Behave as if each regex had the \fB/D\fP (debug) modifier; the internal
-form is output after compilation.
-.TP 10
-\fB-i\fP
-Behave as if each regex had the \fB/I\fP modifier; information about the
-compiled pattern is given after compilation.
-.TP 10
-\fB-m\fP
-Output the size of each compiled pattern after it has been compiled. This is
-equivalent to adding \fB/M\fP to each regular expression. For compatibility
-with earlier versions of pcretest, \fB-s\fP is a synonym for \fB-m\fP.
-.TP 10
-\fB-o\fP \fIosize\fP
-Set the number of elements in the output vector that is used when calling
-\fBpcre_exec()\fP to be \fIosize\fP. The default value is 45, which is enough
-for 14 capturing subexpressions. The vector size can be changed for individual
-matching calls by including \eO in the data line (see below).
-.TP 10
-\fB-p\fP
-Behave as if each regex has \fB/P\fP modifier; the POSIX wrapper API is used
-to call PCRE. None of the other options has any effect when \fB-p\fP is set.
-.TP 10
-\fB-t\fP
-Run each compile, study, and match many times with a timer, and output
-resulting time per compile or match (in milliseconds). Do not set \fB-m\fP with
-\fB-t\fP, because you will then get the size output a zillion times, and the
-timing will be distorted.
-.
-.
-.SH DESCRIPTION
-.rs
-.sp
-If \fBpcretest\fP is given two filename arguments, it reads from the first and
-writes to the second. If it is given only one filename argument, it reads from
-that file and writes to stdout. Otherwise, it reads from stdin and writes to
-stdout, and prompts for each line of input, using "re>" to prompt for regular
-expressions, and "data>" to prompt for data lines.
-.P
-The program handles any number of sets of input on a single input file. Each
-set starts with a regular expression, and continues with any number of data
-lines to be matched against the pattern.
-.P
-Each data line is matched separately and independently. If you want to do
-multiple-line matches, you have to use the \en escape sequence in a single line
-of input to encode the newline characters. The maximum length of data line is
-30,000 characters.
-.P
-An empty line signals the end of the data lines, at which point a new regular
-expression is read. The regular expressions are given enclosed in any
-non-alphanumeric delimiters other than backslash, for example
-.sp
- /(a|bc)x+yz/
-.sp
-White space before the initial delimiter is ignored. A regular expression may
-be continued over several input lines, in which case the newline characters are
-included within it. It is possible to include the delimiter within the pattern
-by escaping it, for example
-.sp
- /abc\e/def/
-.sp
-If you do so, the escape and the delimiter form part of the pattern, but since
-delimiters are always non-alphanumeric, this does not affect its interpretation.
-If the terminating delimiter is immediately followed by a backslash, for
-example,
-.sp
- /abc/\e
-.sp
-then a backslash is added to the end of the pattern. This is done to provide a
-way of testing the error condition that arises if a pattern finishes with a
-backslash, because
-.sp
- /abc\e/
-.sp
-is interpreted as the first line of a pattern that starts with "abc/", causing
-pcretest to read the next line as a continuation of the regular expression.
-.
-.
-.SH "PATTERN MODIFIERS"
-.rs
-.sp
-A pattern may be followed by any number of modifiers, which are mostly single
-characters. Following Perl usage, these are referred to below as, for example,
-"the \fB/i\fP modifier", even though the delimiter of the pattern need not
-always be a slash, and no slash is used when writing modifiers. Whitespace may
-appear between the final pattern delimiter and the first modifier, and between
-the modifiers themselves.
-.P
-The \fB/i\fP, \fB/m\fP, \fB/s\fP, and \fB/x\fP modifiers set the PCRE_CASELESS,
-PCRE_MULTILINE, PCRE_DOTALL, or PCRE_EXTENDED options, respectively, when
-\fBpcre_compile()\fP is called. These four modifier letters have the same
-effect as they do in Perl. For example:
-.sp
- /caseless/i
-.sp
-The following table shows additional modifiers for setting PCRE options that do
-not correspond to anything in Perl:
-.sp
- \fB/A\fP PCRE_ANCHORED
- \fB/C\fP PCRE_AUTO_CALLOUT
- \fB/E\fP PCRE_DOLLAR_ENDONLY
- \fB/N\fP PCRE_NO_AUTO_CAPTURE
- \fB/U\fP PCRE_UNGREEDY
- \fB/X\fP PCRE_EXTRA
-.sp
-Searching for all possible matches within each subject string can be requested
-by the \fB/g\fP or \fB/G\fP modifier. After finding a match, PCRE is called
-again to search the remainder of the subject string. The difference between
-\fB/g\fP and \fB/G\fP is that the former uses the \fIstartoffset\fP argument to
-\fBpcre_exec()\fP to start searching at a new point within the entire string
-(which is in effect what Perl does), whereas the latter passes over a shortened
-substring. This makes a difference to the matching process if the pattern
-begins with a lookbehind assertion (including \eb or \eB).
-.P
-If any call to \fBpcre_exec()\fP in a \fB/g\fP or \fB/G\fP sequence matches an
-empty string, the next call is done with the PCRE_NOTEMPTY and PCRE_ANCHORED
-flags set in order to search for another, non-empty, match at the same point.
-If this second match fails, the start offset is advanced by one, and the normal
-match is retried. This imitates the way Perl handles such cases when using the
-\fB/g\fP modifier or the \fBsplit()\fP function.
-.P
-There are yet more modifiers for controlling the way \fBpcretest\fP
-operates.
-.P
-The \fB/+\fP modifier requests that as well as outputting the substring that
-matched the entire pattern, pcretest should in addition output the remainder of
-the subject string. This is useful for tests where the subject contains
-multiple copies of the same substring.
-.P
-The \fB/L\fP modifier must be followed directly by the name of a locale, for
-example,
-.sp
- /pattern/Lfr_FR
-.sp
-For this reason, it must be the last modifier. The given locale is set,
-\fBpcre_maketables()\fP is called to build a set of character tables for the
-locale, and this is then passed to \fBpcre_compile()\fP when compiling the
-regular expression. Without an \fB/L\fP modifier, NULL is passed as the tables
-pointer; that is, \fB/L\fP applies only to the expression on which it appears.
-.P
-The \fB/I\fP modifier requests that \fBpcretest\fP output information about the
-compiled pattern (whether it is anchored, has a fixed first character, and
-so on). It does this by calling \fBpcre_fullinfo()\fP after compiling a
-pattern. If the pattern is studied, the results of that are also output.
-.P
-The \fB/D\fP modifier is a PCRE debugging feature, which also assumes \fB/I\fP.
-It causes the internal form of compiled regular expressions to be output after
-compilation. If the pattern was studied, the information returned is also
-output.
-.P
-The \fB/F\fP modifier causes \fBpcretest\fP to flip the byte order of the
-fields in the compiled pattern that contain 2-byte and 4-byte numbers. This
-facility is for testing the feature in PCRE that allows it to execute patterns
-that were compiled on a host with a different endianness. This feature is not
-available when the POSIX interface to PCRE is being used, that is, when the
-\fB/P\fP pattern modifier is specified. See also the section about saving and
-reloading compiled patterns below.
-.P
-The \fB/S\fP modifier causes \fBpcre_study()\fP to be called after the
-expression has been compiled, and the results used when the expression is
-matched.
-.P
-The \fB/M\fP modifier causes the size of memory block used to hold the compiled
-pattern to be output.
-.P
-The \fB/P\fP modifier causes \fBpcretest\fP to call PCRE via the POSIX wrapper
-API rather than its native API. When this is done, all other modifiers except
-\fB/i\fP, \fB/m\fP, and \fB/+\fP are ignored. REG_ICASE is set if \fB/i\fP is
-present, and REG_NEWLINE is set if \fB/m\fP is present. The wrapper functions
-force PCRE_DOLLAR_ENDONLY always, and PCRE_DOTALL unless REG_NEWLINE is set.
-.P
-The \fB/8\fP modifier causes \fBpcretest\fP to call PCRE with the PCRE_UTF8
-option set. This turns on support for UTF-8 character handling in PCRE,
-provided that it was compiled with this support enabled. This modifier also
-causes any non-printing characters in output strings to be printed using the
-\ex{hh...} notation if they are valid UTF-8 sequences.
-.P
-If the \fB/?\fP modifier is used with \fB/8\fP, it causes \fBpcretest\fP to
-call \fBpcre_compile()\fP with the PCRE_NO_UTF8_CHECK option, to suppress the
-checking of the string for UTF-8 validity.
-.
-.
-.SH "DATA LINES"
-.rs
-.sp
-Before each data line is passed to \fBpcre_exec()\fP, leading and trailing
-whitespace is removed, and it is then scanned for \e escapes. Some of these are
-pretty esoteric features, intended for checking out some of the more
-complicated features of PCRE. If you are just testing "ordinary" regular
-expressions, you probably don't need any of these. The following escapes are
-recognized:
-.sp
- \ea alarm (= BEL)
- \eb backspace
- \ee escape
- \ef formfeed
- \en newline
- \er carriage return
- \et tab
- \ev vertical tab
- \ennn octal character (up to 3 octal digits)
- \exhh hexadecimal character (up to 2 hex digits)
-.\" JOIN
- \ex{hh...} hexadecimal character, any number of digits
- in UTF-8 mode
- \eA pass the PCRE_ANCHORED option to \fBpcre_exec()\fP
- \eB pass the PCRE_NOTBOL option to \fBpcre_exec()\fP
-.\" JOIN
- \eCdd call pcre_copy_substring() for substring dd
- after a successful match (number less than 32)
-.\" JOIN
- \eCname call pcre_copy_named_substring() for substring
- "name" after a successful match (name termin-
- ated by next non alphanumeric character)
-.\" JOIN
- \eC+ show the current captured substrings at callout
- time
- \eC- do not supply a callout function
-.\" JOIN
- \eC!n return 1 instead of 0 when callout number n is
- reached
-.\" JOIN
- \eC!n!m return 1 instead of 0 when callout number n is
- reached for the nth time
-.\" JOIN
- \eC*n pass the number n (may be negative) as callout
- data; this is used as the callout return value
-.\" JOIN
- \eGdd call pcre_get_substring() for substring dd
- after a successful match (number less than 32)
-.\" JOIN
- \eGname call pcre_get_named_substring() for substring
- "name" after a successful match (name termin-
- ated by next non-alphanumeric character)
-.\" JOIN
- \eL call pcre_get_substringlist() after a
- successful match
- \eM discover the minimum MATCH_LIMIT setting
- \eN pass the PCRE_NOTEMPTY option to \fBpcre_exec()\fP
-.\" JOIN
- \eOdd set the size of the output vector passed to
- \fBpcre_exec()\fP to dd (any number of digits)
- \eP pass the PCRE_PARTIAL option to \fBpcre_exec()\fP
- \eS output details of memory get/free calls during matching
- \eZ pass the PCRE_NOTEOL option to \fBpcre_exec()\fP
-.\" JOIN
- \e? pass the PCRE_NO_UTF8_CHECK option to
- \fBpcre_exec()\fP
- \e>dd start the match at offset dd (any number of digits);
- this sets the \fIstartoffset\fP argument for \fBpcre_exec()\fP
-.sp
-A backslash followed by anything else just escapes the anything else. If the
-very last character is a backslash, it is ignored. This gives a way of passing
-an empty line as data, since a real empty line terminates the data input.
-.P
-If \eM is present, \fBpcretest\fP calls \fBpcre_exec()\fP several times, with
-different values in the \fImatch_limit\fP field of the \fBpcre_extra\fP data
-structure, until it finds the minimum number that is needed for
-\fBpcre_exec()\fP to complete. This number is a measure of the amount of
-recursion and backtracking that takes place, and checking it out can be
-instructive. For most simple matches, the number is quite small, but for
-patterns with very large numbers of matching possibilities, it can become large
-very quickly with increasing length of subject string.
-.P
-When \eO is used, the value specified may be higher or lower than the size set
-by the \fB-O\fP command line option (or defaulted to 45); \eO applies only to
-the call of \fBpcre_exec()\fP for the line in which it appears.
-.P
-If the \fB/P\fP modifier was present on the pattern, causing the POSIX wrapper
-API to be used, only \eB and \eZ have any effect, causing REG_NOTBOL and
-REG_NOTEOL to be passed to \fBregexec()\fP respectively.
-.P
-The use of \ex{hh...} to represent UTF-8 characters is not dependent on the use
-of the \fB/8\fP modifier on the pattern. It is recognized always. There may be
-any number of hexadecimal digits inside the braces. The result is from one to
-six bytes, encoded according to the UTF-8 rules.
-.
-.
-.SH "OUTPUT FROM PCRETEST"
-.rs
-.sp
-When a match succeeds, pcretest outputs the list of captured substrings that
-\fBpcre_exec()\fP returns, starting with number 0 for the string that matched
-the whole pattern. Otherwise, it outputs "No match" or "Partial match"
-when \fBpcre_exec()\fP returns PCRE_ERROR_NOMATCH or PCRE_ERROR_PARTIAL,
-respectively, and otherwise the PCRE negative error number. Here is an example
-of an interactive pcretest run.
-.sp
- $ pcretest
- PCRE version 5.00 07-Sep-2004
-.sp
- re> /^abc(\ed+)/
- data> abc123
- 0: abc123
- 1: 123
- data> xyz
- No match
-.sp
-If the strings contain any non-printing characters, they are output as \e0x
-escapes, or as \ex{...} escapes if the \fB/8\fP modifier was present on the
-pattern. If the pattern has the \fB/+\fP modifier, the output for substring 0
-is followed by the the rest of the subject string, identified by "0+" like
-this:
-.sp
- re> /cat/+
- data> cataract
- 0: cat
- 0+ aract
-.sp
-If the pattern has the \fB/g\fP or \fB/G\fP modifier, the results of successive
-matching attempts are output in sequence, like this:
-.sp
- re> /\eBi(\ew\ew)/g
- data> Mississippi
- 0: iss
- 1: ss
- 0: iss
- 1: ss
- 0: ipp
- 1: pp
-.sp
-"No match" is output only if the first match attempt fails.
-.P
-If any of the sequences \fB\eC\fP, \fB\eG\fP, or \fB\eL\fP are present in a
-data line that is successfully matched, the substrings extracted by the
-convenience functions are output with C, G, or L after the string number
-instead of a colon. This is in addition to the normal full list. The string
-length (that is, the return from the extraction function) is given in
-parentheses after each string for \fB\eC\fP and \fB\eG\fP.
-.P
-Note that while patterns can be continued over several lines (a plain ">"
-prompt is used for continuations), data lines may not. However newlines can be
-included in data by means of the \en escape.
-.
-.
-.SH CALLOUTS
-.rs
-.sp
-If the pattern contains any callout requests, \fBpcretest\fP's callout function
-is called during matching. By default, it displays the callout number, the
-start and current positions in the text at the callout time, and the next
-pattern item to be tested. For example, the output
-.sp
- --->pqrabcdef
- 0 ^ ^ \ed
-.sp
-indicates that callout number 0 occurred for a match attempt starting at the
-fourth character of the subject string, when the pointer was at the seventh
-character of the data, and when the next pattern item was \ed. Just one
-circumflex is output if the start and current positions are the same.
-.P
-Callouts numbered 255 are assumed to be automatic callouts, inserted as a
-result of the \fB/C\fP pattern modifier. In this case, instead of showing the
-callout number, the offset in the pattern, preceded by a plus, is output. For
-example:
-.sp
- re> /\ed?[A-E]\e*/C
- data> E*
- --->E*
- +0 ^ \ed?
- +3 ^ [A-E]
- +8 ^^ \e*
- +10 ^ ^
- 0: E*
-.sp
-The callout function in \fBpcretest\fP returns zero (carry on matching) by
-default, but you can use an \eC item in a data line (as described above) to
-change this.
-.P
-Inserting callouts can be helpful when using \fBpcretest\fP to check
-complicated regular expressions. For further information about callouts, see
-the
-.\" HREF
-\fBpcrecallout\fP
-.\"
-documentation.
-.
-.
-.SH "SAVING AND RELOADING COMPILED PATTERNS"
-.rs
-.sp
-The facilities described in this section are not available when the POSIX
-inteface to PCRE is being used, that is, when the \fB/P\fP pattern modifier is
-specified.
-.P
-When the POSIX interface is not in use, you can cause \fBpcretest\fP to write a
-compiled pattern to a file, by following the modifiers with > and a file name.
-For example:
-.sp
- /pattern/im >/some/file
-.sp
-See the
-.\" HREF
-\fBpcreprecompile\fP
-.\"
-documentation for a discussion about saving and re-using compiled patterns.
-.P
-The data that is written is binary. The first eight bytes are the length of the
-compiled pattern data followed by the length of the optional study data, each
-written as four bytes in big-endian order (most significant byte first). If
-there is no study data (either the pattern was not studied, or studying did not
-return any data), the second length is zero. The lengths are followed by an
-exact copy of the compiled pattern. If there is additional study data, this
-follows immediately after the compiled pattern. After writing the file,
-\fBpcretest\fP expects to read a new pattern.
-.P
-A saved pattern can be reloaded into \fBpcretest\fP by specifing < and a file
-name instead of a pattern. The name of the file must not contain a < character,
-as otherwise \fBpcretest\fP will interpret the line as a pattern delimited by <
-characters.
-For example:
-.sp
- re> </some/file
- Compiled regex loaded from /some/file
- No study data
-.sp
-When the pattern has been loaded, \fBpcretest\fP proceeds to read data lines in
-the usual way.
-.P
-You can copy a file written by \fBpcretest\fP to a different host and reload it
-there, even if the new host has opposite endianness to the one on which the
-pattern was compiled. For example, you can compile on an i86 machine and run on
-a SPARC machine.
-.P
-File names for saving and reloading can be absolute or relative, but note that
-the shell facility of expanding a file name that starts with a tilde (~) is not
-available.
-.P
-The ability to save and reload files in \fBpcretest\fP is intended for testing
-and experimentation. It is not intended for production use because only a
-single pattern can be written to a file. Furthermore, there is no facility for
-supplying custom character tables for use with a reloaded pattern. If the
-original pattern was compiled with custom tables, an attempt to match a subject
-string using a reloaded pattern is likely to cause \fBpcretest\fP to crash.
-Finally, if you attempt to load a file that is not in the correct format, the
-result is undefined.
-.
-.
-.SH AUTHOR
-.rs
-.sp
-Philip Hazel <ph10@cam.ac.uk>
-.br
-University Computing Service,
-.br
-Cambridge CB2 3QG, England.
-.P
-.in 0
-Last updated: 10 September 2004
-.br
-Copyright (c) 1997-2004 University of Cambridge.
+++ /dev/null
-<HTML>
-<HEAD>
-<TITLE>pcretest specification</TITLE>
-</HEAD>
-<body bgcolor="#FFFFFF" text="#00005A">
-<H1>pcretest specification</H1>
-This HTML document has been generated automatically from the original man page.
-If there is any nonsense in it, please consult the man page in case the
-conversion went wrong.
-<UL>
-<LI><A NAME="TOC1" HREF="#SEC1">NAME</A>
-<LI><A NAME="TOC2" HREF="#SEC2">SYNOPSIS</A>
-<LI><A NAME="TOC3" HREF="#SEC3">OPTIONS</A>
-<LI><A NAME="TOC4" HREF="#SEC4">DESCRIPTION</A>
-<LI><A NAME="TOC5" HREF="#SEC5">PATTERN MODIFIERS</A>
-<LI><A NAME="TOC6" HREF="#SEC6">DATA LINES</A>
-<LI><A NAME="TOC7" HREF="#SEC7">OUTPUT FROM PCRETEST</A>
-<LI><A NAME="TOC8" HREF="#SEC8">AUTHOR</A>
-</UL>
-<LI><A NAME="SEC1" HREF="#TOC1">NAME</A>
-<P>
-pcretest - a program for testing Perl-compatible regular expressions.
-</P>
-<LI><A NAME="SEC2" HREF="#TOC1">SYNOPSIS</A>
-<P>
-<B>pcretest [-d] [-i] [-m] [-o osize] [-p] [-t] [source] [destination]</B>
-</P>
-<P>
-<B>pcretest</B> was written as a test program for the PCRE regular expression
-library itself, but it can also be used for experimenting with regular
-expressions. This man page describes the features of the test program; for
-details of the regular expressions themselves, see the <B>pcre</B> man page.
-</P>
-<LI><A NAME="SEC3" HREF="#TOC1">OPTIONS</A>
-<P>
-<B>-d</B>
-Behave as if each regex had the <B>/D</B> modifier (see below); the internal
-form is output after compilation.
-</P>
-<P>
-<B>-i</B>
-Behave as if each regex had the <B>/I</B> modifier; information about the
-compiled pattern is given after compilation.
-</P>
-<P>
-<B>-m</B>
-Output the size of each compiled pattern after it has been compiled. This is
-equivalent to adding /M to each regular expression. For compatibility with
-earlier versions of pcretest, <B>-s</B> is a synonym for <B>-m</B>.
-</P>
-<P>
-<B>-o</B> <I>osize</I>
-Set the number of elements in the output vector that is used when calling PCRE
-to be <I>osize</I>. The default value is 45, which is enough for 14 capturing
-subexpressions. The vector size can be changed for individual matching calls by
-including \O in the data line (see below).
-</P>
-<P>
-<B>-p</B>
-Behave as if each regex has <B>/P</B> modifier; the POSIX wrapper API is used
-to call PCRE. None of the other options has any effect when <B>-p</B> is set.
-</P>
-<P>
-<B>-t</B>
-Run each compile, study, and match 20000 times with a timer, and output
-resulting time per compile or match (in milliseconds). Do not set <B>-t</B> with
-<B>-m</B>, because you will then get the size output 20000 times and the timing
-will be distorted.
-</P>
-<LI><A NAME="SEC4" HREF="#TOC1">DESCRIPTION</A>
-<P>
-If <B>pcretest</B> is given two filename arguments, it reads from the first and
-writes to the second. If it is given only one filename argument, it reads from
-that file and writes to stdout. Otherwise, it reads from stdin and writes to
-stdout, and prompts for each line of input, using "re>" to prompt for regular
-expressions, and "data>" to prompt for data lines.
-</P>
-<P>
-The program handles any number of sets of input on a single input file. Each
-set starts with a regular expression, and continues with any number of data
-lines to be matched against the pattern. An empty line signals the end of the
-data lines, at which point a new regular expression is read. The regular
-expressions are given enclosed in any non-alphameric delimiters other than
-backslash, for example
-</P>
-<P>
-<PRE>
- /(a|bc)x+yz/
-</PRE>
-</P>
-<P>
-White space before the initial delimiter is ignored. A regular expression may
-be continued over several input lines, in which case the newline characters are
-included within it. It is possible to include the delimiter within the pattern
-by escaping it, for example
-</P>
-<P>
-<PRE>
- /abc\/def/
-</PRE>
-</P>
-<P>
-If you do so, the escape and the delimiter form part of the pattern, but since
-delimiters are always non-alphameric, this does not affect its interpretation.
-If the terminating delimiter is immediately followed by a backslash, for
-example,
-</P>
-<P>
-<PRE>
- /abc/\
-</PRE>
-</P>
-<P>
-then a backslash is added to the end of the pattern. This is done to provide a
-way of testing the error condition that arises if a pattern finishes with a
-backslash, because
-</P>
-<P>
-<PRE>
- /abc\/
-</PRE>
-</P>
-<P>
-is interpreted as the first line of a pattern that starts with "abc/", causing
-pcretest to read the next line as a continuation of the regular expression.
-</P>
-<LI><A NAME="SEC5" HREF="#TOC1">PATTERN MODIFIERS</A>
-<P>
-The pattern may be followed by <B>i</B>, <B>m</B>, <B>s</B>, or <B>x</B> to set the
-PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, or PCRE_EXTENDED options,
-respectively. For example:
-</P>
-<P>
-<PRE>
- /caseless/i
-</PRE>
-</P>
-<P>
-These modifier letters have the same effect as they do in Perl. There are
-others which set PCRE options that do not correspond to anything in Perl:
-<B>/A</B>, <B>/E</B>, and <B>/X</B> set PCRE_ANCHORED, PCRE_DOLLAR_ENDONLY, and
-PCRE_EXTRA respectively.
-</P>
-<P>
-Searching for all possible matches within each subject string can be requested
-by the <B>/g</B> or <B>/G</B> modifier. After finding a match, PCRE is called
-again to search the remainder of the subject string. The difference between
-<B>/g</B> and <B>/G</B> is that the former uses the <I>startoffset</I> argument to
-<B>pcre_exec()</B> to start searching at a new point within the entire string
-(which is in effect what Perl does), whereas the latter passes over a shortened
-substring. This makes a difference to the matching process if the pattern
-begins with a lookbehind assertion (including \b or \B).
-</P>
-<P>
-If any call to <B>pcre_exec()</B> in a <B>/g</B> or <B>/G</B> sequence matches an
-empty string, the next call is done with the PCRE_NOTEMPTY and PCRE_ANCHORED
-flags set in order to search for another, non-empty, match at the same point.
-If this second match fails, the start offset is advanced by one, and the normal
-match is retried. This imitates the way Perl handles such cases when using the
-<B>/g</B> modifier or the <B>split()</B> function.
-</P>
-<P>
-There are a number of other modifiers for controlling the way <B>pcretest</B>
-operates.
-</P>
-<P>
-The <B>/+</B> modifier requests that as well as outputting the substring that
-matched the entire pattern, pcretest should in addition output the remainder of
-the subject string. This is useful for tests where the subject contains
-multiple copies of the same substring.
-</P>
-<P>
-The <B>/L</B> modifier must be followed directly by the name of a locale, for
-example,
-</P>
-<P>
-<PRE>
- /pattern/Lfr
-</PRE>
-</P>
-<P>
-For this reason, it must be the last modifier letter. The given locale is set,
-<B>pcre_maketables()</B> is called to build a set of character tables for the
-locale, and this is then passed to <B>pcre_compile()</B> when compiling the
-regular expression. Without an <B>/L</B> modifier, NULL is passed as the tables
-pointer; that is, <B>/L</B> applies only to the expression on which it appears.
-</P>
-<P>
-The <B>/I</B> modifier requests that <B>pcretest</B> output information about the
-compiled expression (whether it is anchored, has a fixed first character, and
-so on). It does this by calling <B>pcre_fullinfo()</B> after compiling an
-expression, and outputting the information it gets back. If the pattern is
-studied, the results of that are also output.
-</P>
-<P>
-The <B>/D</B> modifier is a PCRE debugging feature, which also assumes <B>/I</B>.
-It causes the internal form of compiled regular expressions to be output after
-compilation.
-</P>
-<P>
-The <B>/S</B> modifier causes <B>pcre_study()</B> to be called after the
-expression has been compiled, and the results used when the expression is
-matched.
-</P>
-<P>
-The <B>/M</B> modifier causes the size of memory block used to hold the compiled
-pattern to be output.
-</P>
-<P>
-The <B>/P</B> modifier causes <B>pcretest</B> to call PCRE via the POSIX wrapper
-API rather than its native API. When this is done, all other modifiers except
-<B>/i</B>, <B>/m</B>, and <B>/+</B> are ignored. REG_ICASE is set if <B>/i</B> is
-present, and REG_NEWLINE is set if <B>/m</B> is present. The wrapper functions
-force PCRE_DOLLAR_ENDONLY always, and PCRE_DOTALL unless REG_NEWLINE is set.
-</P>
-<P>
-The <B>/8</B> modifier causes <B>pcretest</B> to call PCRE with the PCRE_UTF8
-option set. This turns on the (currently incomplete) support for UTF-8
-character handling in PCRE, provided that it was compiled with this support
-enabled. This modifier also causes any non-printing characters in output
-strings to be printed using the \x{hh...} notation if they are valid UTF-8
-sequences.
-</P>
-<LI><A NAME="SEC6" HREF="#TOC1">DATA LINES</A>
-<P>
-Before each data line is passed to <B>pcre_exec()</B>, leading and trailing
-whitespace is removed, and it is then scanned for \ escapes. The following are
-recognized:
-</P>
-<P>
-<PRE>
- \a alarm (= BEL)
- \b backspace
- \e escape
- \f formfeed
- \n newline
- \r carriage return
- \t tab
- \v vertical tab
- \nnn octal character (up to 3 octal digits)
- \xhh hexadecimal character (up to 2 hex digits)
- \x{hh...} hexadecimal UTF-8 character
-</PRE>
-</P>
-<P>
-<PRE>
- \A pass the PCRE_ANCHORED option to <B>pcre_exec()</B>
- \B pass the PCRE_NOTBOL option to <B>pcre_exec()</B>
- \Cdd call pcre_copy_substring() for substring dd
- after a successful match (any decimal number
- less than 32)
- \Gdd call pcre_get_substring() for substring dd
- after a successful match (any decimal number
- less than 32)
- \L call pcre_get_substringlist() after a
- successful match
- \N pass the PCRE_NOTEMPTY option to <B>pcre_exec()</B>
- \Odd set the size of the output vector passed to
- <B>pcre_exec()</B> to dd (any number of decimal
- digits)
- \Z pass the PCRE_NOTEOL option to <B>pcre_exec()</B>
-</PRE>
-</P>
-<P>
-When \O is used, it may be higher or lower than the size set by the <B>-O</B>
-option (or defaulted to 45); \O applies only to the call of <B>pcre_exec()</B>
-for the line in which it appears.
-</P>
-<P>
-A backslash followed by anything else just escapes the anything else. If the
-very last character is a backslash, it is ignored. This gives a way of passing
-an empty line as data, since a real empty line terminates the data input.
-</P>
-<P>
-If <B>/P</B> was present on the regex, causing the POSIX wrapper API to be used,
-only <B>\B</B>, and <B>\Z</B> have any effect, causing REG_NOTBOL and REG_NOTEOL
-to be passed to <B>regexec()</B> respectively.
-</P>
-<P>
-The use of \x{hh...} to represent UTF-8 characters is not dependent on the use
-of the <B>/8</B> modifier on the pattern. It is recognized always. There may be
-any number of hexadecimal digits inside the braces. The result is from one to
-six bytes, encoded according to the UTF-8 rules.
-</P>
-<LI><A NAME="SEC7" HREF="#TOC1">OUTPUT FROM PCRETEST</A>
-<P>
-When a match succeeds, pcretest outputs the list of captured substrings that
-<B>pcre_exec()</B> returns, starting with number 0 for the string that matched
-the whole pattern. Here is an example of an interactive pcretest run.
-</P>
-<P>
-<PRE>
- $ pcretest
- PCRE version 2.06 08-Jun-1999
-</PRE>
-</P>
-<P>
-<PRE>
- re> /^abc(\d+)/
- data> abc123
- 0: abc123
- 1: 123
- data> xyz
- No match
-</PRE>
-</P>
-<P>
-If the strings contain any non-printing characters, they are output as \0x
-escapes, or as \x{...} escapes if the <B>/8</B> modifier was present on the
-pattern. If the pattern has the <B>/+</B> modifier, then the output for
-substring 0 is followed by the the rest of the subject string, identified by
-"0+" like this:
-</P>
-<P>
-<PRE>
- re> /cat/+
- data> cataract
- 0: cat
- 0+ aract
-</PRE>
-</P>
-<P>
-If the pattern has the <B>/g</B> or <B>/G</B> modifier, the results of successive
-matching attempts are output in sequence, like this:
-</P>
-<P>
-<PRE>
- re> /\Bi(\w\w)/g
- data> Mississippi
- 0: iss
- 1: ss
- 0: iss
- 1: ss
- 0: ipp
- 1: pp
-</PRE>
-</P>
-<P>
-"No match" is output only if the first match attempt fails.
-</P>
-<P>
-If any of the sequences <B>\C</B>, <B>\G</B>, or <B>\L</B> are present in a
-data line that is successfully matched, the substrings extracted by the
-convenience functions are output with C, G, or L after the string number
-instead of a colon. This is in addition to the normal full list. The string
-length (that is, the return from the extraction function) is given in
-parentheses after each string for <B>\C</B> and <B>\G</B>.
-</P>
-<P>
-Note that while patterns can be continued over several lines (a plain ">"
-prompt is used for continuations), data lines may not. However newlines can be
-included in data by means of the \n escape.
-</P>
-<LI><A NAME="SEC8" HREF="#TOC1">AUTHOR</A>
-<P>
-Philip Hazel <ph10@cam.ac.uk>
-<BR>
-University Computing Service,
-<BR>
-New Museums Site,
-<BR>
-Cambridge CB2 3QG, England.
-<BR>
-Phone: +44 1223 334714
-</P>
-<P>
-Last updated: 15 August 2001
-<BR>
-Copyright (c) 1997-2001 University of Cambridge.
+++ /dev/null
-PCRETEST(1) PCRETEST(1)
-
-
-
-NAME
- pcretest - a program for testing Perl-compatible regular expressions.
-
-SYNOPSIS
-
- pcretest [-C] [-d] [-i] [-m] [-o osize] [-p] [-t] [source]
- [destination]
-
- pcretest was written as a test program for the PCRE regular expression
- library itself, but it can also be used for experimenting with regular
- expressions. This document describes the features of the test program;
- for details of the regular expressions themselves, see the pcrepattern
- documentation. For details of the PCRE library function calls and their
- options, see the pcreapi documentation.
-
-
-OPTIONS
-
- -C Output the version number of the PCRE library, and all avail-
- able information about the optional features that are
- included, and then exit.
-
- -d Behave as if each regex had the /D (debug) modifier; the
- internal form is output after compilation.
-
- -i Behave as if each regex had the /I modifier; information
- about the compiled pattern is given after compilation.
-
- -m Output the size of each compiled pattern after it has been
- compiled. This is equivalent to adding /M to each regular
- expression. For compatibility with earlier versions of
- pcretest, -s is a synonym for -m.
-
- -o osize Set the number of elements in the output vector that is used
- when calling pcre_exec() to be osize. The default value is
- 45, which is enough for 14 capturing subexpressions. The vec-
- tor size can be changed for individual matching calls by
- including \O in the data line (see below).
-
- -p Behave as if each regex has /P modifier; the POSIX wrapper
- API is used to call PCRE. None of the other options has any
- effect when -p is set.
-
- -t Run each compile, study, and match many times with a timer,
- and output resulting time per compile or match (in millisec-
- onds). Do not set -m with -t, because you will then get the
- size output a zillion times, and the timing will be dis-
- torted.
-
-
-DESCRIPTION
-
- If pcretest is given two filename arguments, it reads from the first
- and writes to the second. If it is given only one filename argument, it
- reads from that file and writes to stdout. Otherwise, it reads from
- stdin and writes to stdout, and prompts for each line of input, using
- "re>" to prompt for regular expressions, and "data>" to prompt for data
- lines.
-
- The program handles any number of sets of input on a single input file.
- Each set starts with a regular expression, and continues with any num-
- ber of data lines to be matched against the pattern.
-
- Each data line is matched separately and independently. If you want to
- do multiple-line matches, you have to use the \n escape sequence in a
- single line of input to encode the newline characters. The maximum
- length of data line is 30,000 characters.
-
- An empty line signals the end of the data lines, at which point a new
- regular expression is read. The regular expressions are given enclosed
- in any non-alphanumeric delimiters other than backslash, for example
-
- /(a|bc)x+yz/
-
- White space before the initial delimiter is ignored. A regular expres-
- sion may be continued over several input lines, in which case the new-
- line characters are included within it. It is possible to include the
- delimiter within the pattern by escaping it, for example
-
- /abc\/def/
-
- If you do so, the escape and the delimiter form part of the pattern,
- but since delimiters are always non-alphanumeric, this does not affect
- its interpretation. If the terminating delimiter is immediately fol-
- lowed by a backslash, for example,
-
- /abc/\
-
- then a backslash is added to the end of the pattern. This is done to
- provide a way of testing the error condition that arises if a pattern
- finishes with a backslash, because
-
- /abc\/
-
- is interpreted as the first line of a pattern that starts with "abc/",
- causing pcretest to read the next line as a continuation of the regular
- expression.
-
-
-PATTERN MODIFIERS
-
- A pattern may be followed by any number of modifiers, which are mostly
- single characters. Following Perl usage, these are referred to below
- as, for example, "the /i modifier", even though the delimiter of the
- pattern need not always be a slash, and no slash is used when writing
- modifiers. Whitespace may appear between the final pattern delimiter
- and the first modifier, and between the modifiers themselves.
-
- The /i, /m, /s, and /x modifiers set the PCRE_CASELESS, PCRE_MULTILINE,
- PCRE_DOTALL, or PCRE_EXTENDED options, respectively, when pcre_com-
- pile() is called. These four modifier letters have the same effect as
- they do in Perl. For example:
-
- /caseless/i
-
- The following table shows additional modifiers for setting PCRE options
- that do not correspond to anything in Perl:
-
- /A PCRE_ANCHORED
- /C PCRE_AUTO_CALLOUT
- /E PCRE_DOLLAR_ENDONLY
- /N PCRE_NO_AUTO_CAPTURE
- /U PCRE_UNGREEDY
- /X PCRE_EXTRA
-
- Searching for all possible matches within each subject string can be
- requested by the /g or /G modifier. After finding a match, PCRE is
- called again to search the remainder of the subject string. The differ-
- ence between /g and /G is that the former uses the startoffset argument
- to pcre_exec() to start searching at a new point within the entire
- string (which is in effect what Perl does), whereas the latter passes
- over a shortened substring. This makes a difference to the matching
- process if the pattern begins with a lookbehind assertion (including \b
- or \B).
-
- If any call to pcre_exec() in a /g or /G sequence matches an empty
- string, the next call is done with the PCRE_NOTEMPTY and PCRE_ANCHORED
- flags set in order to search for another, non-empty, match at the same
- point. If this second match fails, the start offset is advanced by
- one, and the normal match is retried. This imitates the way Perl han-
- dles such cases when using the /g modifier or the split() function.
-
- There are yet more modifiers for controlling the way pcretest operates.
-
- The /+ modifier requests that as well as outputting the substring that
- matched the entire pattern, pcretest should in addition output the
- remainder of the subject string. This is useful for tests where the
- subject contains multiple copies of the same substring.
-
- The /L modifier must be followed directly by the name of a locale, for
- example,
-
- /pattern/Lfr_FR
-
- For this reason, it must be the last modifier. The given locale is set,
- pcre_maketables() is called to build a set of character tables for the
- locale, and this is then passed to pcre_compile() when compiling the
- regular expression. Without an /L modifier, NULL is passed as the
- tables pointer; that is, /L applies only to the expression on which it
- appears.
-
- The /I modifier requests that pcretest output information about the
- compiled pattern (whether it is anchored, has a fixed first character,
- and so on). It does this by calling pcre_fullinfo() after compiling a
- pattern. If the pattern is studied, the results of that are also out-
- put.
-
- The /D modifier is a PCRE debugging feature, which also assumes /I. It
- causes the internal form of compiled regular expressions to be output
- after compilation. If the pattern was studied, the information returned
- is also output.
-
- The /F modifier causes pcretest to flip the byte order of the fields in
- the compiled pattern that contain 2-byte and 4-byte numbers. This
- facility is for testing the feature in PCRE that allows it to execute
- patterns that were compiled on a host with a different endianness. This
- feature is not available when the POSIX interface to PCRE is being
- used, that is, when the /P pattern modifier is specified. See also the
- section about saving and reloading compiled patterns below.
-
- The /S modifier causes pcre_study() to be called after the expression
- has been compiled, and the results used when the expression is matched.
-
- The /M modifier causes the size of memory block used to hold the com-
- piled pattern to be output.
-
- The /P modifier causes pcretest to call PCRE via the POSIX wrapper API
- rather than its native API. When this is done, all other modifiers
- except /i, /m, and /+ are ignored. REG_ICASE is set if /i is present,
- and REG_NEWLINE is set if /m is present. The wrapper functions force
- PCRE_DOLLAR_ENDONLY always, and PCRE_DOTALL unless REG_NEWLINE is set.
-
- The /8 modifier causes pcretest to call PCRE with the PCRE_UTF8 option
- set. This turns on support for UTF-8 character handling in PCRE, pro-
- vided that it was compiled with this support enabled. This modifier
- also causes any non-printing characters in output strings to be printed
- using the \x{hh...} notation if they are valid UTF-8 sequences.
-
- If the /? modifier is used with /8, it causes pcretest to call
- pcre_compile() with the PCRE_NO_UTF8_CHECK option, to suppress the
- checking of the string for UTF-8 validity.
-
-
-DATA LINES
-
- Before each data line is passed to pcre_exec(), leading and trailing
- whitespace is removed, and it is then scanned for \ escapes. Some of
- these are pretty esoteric features, intended for checking out some of
- the more complicated features of PCRE. If you are just testing "ordi-
- nary" regular expressions, you probably don't need any of these. The
- following escapes are recognized:
-
- \a alarm (= BEL)
- \b backspace
- \e escape
- \f formfeed
- \n newline
- \r carriage return
- \t tab
- \v vertical tab
- \nnn octal character (up to 3 octal digits)
- \xhh hexadecimal character (up to 2 hex digits)
- \x{hh...} hexadecimal character, any number of digits
- in UTF-8 mode
- \A pass the PCRE_ANCHORED option to pcre_exec()
- \B pass the PCRE_NOTBOL option to pcre_exec()
- \Cdd call pcre_copy_substring() for substring dd
- after a successful match (number less than 32)
- \Cname call pcre_copy_named_substring() for substring
- "name" after a successful match (name termin-
- ated by next non alphanumeric character)
- \C+ show the current captured substrings at callout
- time
- \C- do not supply a callout function
- \C!n return 1 instead of 0 when callout number n is
- reached
- \C!n!m return 1 instead of 0 when callout number n is
- reached for the nth time
- \C*n pass the number n (may be negative) as callout
- data; this is used as the callout return value
- \Gdd call pcre_get_substring() for substring dd
- after a successful match (number less than 32)
- \Gname call pcre_get_named_substring() for substring
- "name" after a successful match (name termin-
- ated by next non-alphanumeric character)
- \L call pcre_get_substringlist() after a
- successful match
- \M discover the minimum MATCH_LIMIT setting
- \N pass the PCRE_NOTEMPTY option to pcre_exec()
- \Odd set the size of the output vector passed to
- pcre_exec() to dd (any number of digits)
- \P pass the PCRE_PARTIAL option to pcre_exec()
- \S output details of memory get/free calls during matching
- \Z pass the PCRE_NOTEOL option to pcre_exec()
- \? pass the PCRE_NO_UTF8_CHECK option to
- pcre_exec()
- \>dd start the match at offset dd (any number of digits);
- this sets the startoffset argument for pcre_exec()
-
- A backslash followed by anything else just escapes the anything else.
- If the very last character is a backslash, it is ignored. This gives a
- way of passing an empty line as data, since a real empty line termi-
- nates the data input.
-
- If \M is present, pcretest calls pcre_exec() several times, with dif-
- ferent values in the match_limit field of the pcre_extra data struc-
- ture, until it finds the minimum number that is needed for pcre_exec()
- to complete. This number is a measure of the amount of recursion and
- backtracking that takes place, and checking it out can be instructive.
- For most simple matches, the number is quite small, but for patterns
- with very large numbers of matching possibilities, it can become large
- very quickly with increasing length of subject string.
-
- When \O is used, the value specified may be higher or lower than the
- size set by the -O command line option (or defaulted to 45); \O applies
- only to the call of pcre_exec() for the line in which it appears.
-
- If the /P modifier was present on the pattern, causing the POSIX wrap-
- per API to be used, only \B and \Z have any effect, causing REG_NOTBOL
- and REG_NOTEOL to be passed to regexec() respectively.
-
- The use of \x{hh...} to represent UTF-8 characters is not dependent on
- the use of the /8 modifier on the pattern. It is recognized always.
- There may be any number of hexadecimal digits inside the braces. The
- result is from one to six bytes, encoded according to the UTF-8 rules.
-
-
-OUTPUT FROM PCRETEST
-
- When a match succeeds, pcretest outputs the list of captured substrings
- that pcre_exec() returns, starting with number 0 for the string that
- matched the whole pattern. Otherwise, it outputs "No match" or "Partial
- match" when pcre_exec() returns PCRE_ERROR_NOMATCH or PCRE_ERROR_PAR-
- TIAL, respectively, and otherwise the PCRE negative error number. Here
- is an example of an interactive pcretest run.
-
- $ pcretest
- PCRE version 5.00 07-Sep-2004
-
- re> /^abc(\d+)/
- data> abc123
- 0: abc123
- 1: 123
- data> xyz
- No match
-
- If the strings contain any non-printing characters, they are output as
- \0x escapes, or as \x{...} escapes if the /8 modifier was present on
- the pattern. If the pattern has the /+ modifier, the output for sub-
- string 0 is followed by the the rest of the subject string, identified
- by "0+" like this:
-
- re> /cat/+
- data> cataract
- 0: cat
- 0+ aract
-
- If the pattern has the /g or /G modifier, the results of successive
- matching attempts are output in sequence, like this:
-
- re> /\Bi(\w\w)/g
- data> Mississippi
- 0: iss
- 1: ss
- 0: iss
- 1: ss
- 0: ipp
- 1: pp
-
- "No match" is output only if the first match attempt fails.
-
- If any of the sequences \C, \G, or \L are present in a data line that
- is successfully matched, the substrings extracted by the convenience
- functions are output with C, G, or L after the string number instead of
- a colon. This is in addition to the normal full list. The string length
- (that is, the return from the extraction function) is given in paren-
- theses after each string for \C and \G.
-
- Note that while patterns can be continued over several lines (a plain
- ">" prompt is used for continuations), data lines may not. However new-
- lines can be included in data by means of the \n escape.
-
-
-CALLOUTS
-
- If the pattern contains any callout requests, pcretest's callout func-
- tion is called during matching. By default, it displays the callout
- number, the start and current positions in the text at the callout
- time, and the next pattern item to be tested. For example, the output
-
- --->pqrabcdef
- 0 ^ ^ \d
-
- indicates that callout number 0 occurred for a match attempt starting
- at the fourth character of the subject string, when the pointer was at
- the seventh character of the data, and when the next pattern item was
- \d. Just one circumflex is output if the start and current positions
- are the same.
-
- Callouts numbered 255 are assumed to be automatic callouts, inserted as
- a result of the /C pattern modifier. In this case, instead of showing
- the callout number, the offset in the pattern, preceded by a plus, is
- output. For example:
-
- re> /\d?[A-E]\*/C
- data> E*
- --->E*
- +0 ^ \d?
- +3 ^ [A-E]
- +8 ^^ \*
- +10 ^ ^
- 0: E*
-
- The callout function in pcretest returns zero (carry on matching) by
- default, but you can use an \C item in a data line (as described above)
- to change this.
-
- Inserting callouts can be helpful when using pcretest to check compli-
- cated regular expressions. For further information about callouts, see
- the pcrecallout documentation.
-
-
-SAVING AND RELOADING COMPILED PATTERNS
-
- The facilities described in this section are not available when the
- POSIX inteface to PCRE is being used, that is, when the /P pattern mod-
- ifier is specified.
-
- When the POSIX interface is not in use, you can cause pcretest to write
- a compiled pattern to a file, by following the modifiers with > and a
- file name. For example:
-
- /pattern/im >/some/file
-
- See the pcreprecompile documentation for a discussion about saving and
- re-using compiled patterns.
-
- The data that is written is binary. The first eight bytes are the
- length of the compiled pattern data followed by the length of the
- optional study data, each written as four bytes in big-endian order
- (most significant byte first). If there is no study data (either the
- pattern was not studied, or studying did not return any data), the sec-
- ond length is zero. The lengths are followed by an exact copy of the
- compiled pattern. If there is additional study data, this follows imme-
- diately after the compiled pattern. After writing the file, pcretest
- expects to read a new pattern.
-
- A saved pattern can be reloaded into pcretest by specifing < and a file
- name instead of a pattern. The name of the file must not contain a <
- character, as otherwise pcretest will interpret the line as a pattern
- delimited by < characters. For example:
-
- re> </some/file
- Compiled regex loaded from /some/file
- No study data
-
- When the pattern has been loaded, pcretest proceeds to read data lines
- in the usual way.
-
- You can copy a file written by pcretest to a different host and reload
- it there, even if the new host has opposite endianness to the one on
- which the pattern was compiled. For example, you can compile on an i86
- machine and run on a SPARC machine.
-
- File names for saving and reloading can be absolute or relative, but
- note that the shell facility of expanding a file name that starts with
- a tilde (~) is not available.
-
- The ability to save and reload files in pcretest is intended for test-
- ing and experimentation. It is not intended for production use because
- only a single pattern can be written to a file. Furthermore, there is
- no facility for supplying custom character tables for use with a
- reloaded pattern. If the original pattern was compiled with custom
- tables, an attempt to match a subject string using a reloaded pattern
- is likely to cause pcretest to crash. Finally, if you attempt to load
- a file that is not in the correct format, the result is undefined.
-
-
-AUTHOR
-
- Philip Hazel <ph10@cam.ac.uk>
- University Computing Service,
- Cambridge CB2 3QG, England.
-
-Last updated: 10 September 2004
-Copyright (c) 1997-2004 University of Cambridge.
+++ /dev/null
-The perltest program
---------------------
-
-The perltest program tests Perl's regular expressions; it has the same
-specification as pcretest, and so can be given identical input, except that
-input patterns can be followed only by Perl's lower case modifiers and /+ (as
-used by pcretest), which is recognized and handled by the program.
-
-The data lines are processed as Perl double-quoted strings, so if they contain
-" $ or @ characters, these have to be escaped. For this reason, all such
-characters in testinput1 and testinput4 are escaped so that they can be used
-for perltest as well as for pcretest. The special upper case pattern
-modifiers such as /A that pcretest recognizes, and its special data line
-escapes, are not used in these files. The output should be identical, apart
-from the initial identifying banner.
-
-The perltest script can also test UTF-8 features. It works as is for Perl 5.8
-or higher. It recognizes the special modifier /8 that pcretest uses to invoke
-UTF-8 functionality. The testinput4 file can be fed to perltest to run
-compatible UTF-8 tests.
-
-For Perl 5.6, perltest won't work unmodified for the UTF-8 tests. You need to
-uncomment the "use utf8" lines that it contains. It is best to do this on a
-copy of the script, because for non-UTF-8 tests, these lines should remain
-commented out.
-
-The other testinput files are not suitable for feeding to perltest, since they
-make use of the special upper case modifiers and escapes that pcretest uses to
-test some features of PCRE. Some of these files also contains malformed regular
-expressions, in order to check that PCRE diagnoses them correctly.
-
-Philip Hazel <ph10@cam.ac.uk>
-September 2004
+++ /dev/null
-.TH PGREP 1
-.SH NAME
-pgrep - a grep with Perl-compatible regular expressions.
-.SH SYNOPSIS
-.B pgrep [-Vchilnsvx] pattern [file] ...
-
-
-.SH DESCRIPTION
-\fBpgrep\fR searches files for character patterns, in the same way as other
-grep commands do, but it uses the PCRE regular expression library to support
-patterns that are compatible with the regular expressions of Perl 5. See
-\fBpcre(3)\fR for a full description of syntax and semantics.
-
-If no files are specified, \fBpgrep\fR reads the standard input. By default,
-each line that matches the pattern is copied to the standard output, and if
-there is more than one file, the file name is printed before each line of
-output. However, there are options that can change how \fBpgrep\fR behaves.
-
-Lines are limited to BUFSIZ characters. BUFSIZ is defined in \fB<stdio.h>\fR.
-The newline character is removed from the end of each line before it is matched
-against the pattern.
-
-
-.SH OPTIONS
-.TP 10
-\fB-V\fR
-Write the version number of the PCRE library being used to the standard error
-stream.
-.TP
-\fB-c\fR
-Do not print individual lines; instead just print a count of the number of
-lines that would otherwise have been printed. If several files are given, a
-count is printed for each of them.
-.TP
-\fB-h\fR
-Suppress printing of filenames when searching multiple files.
-.TP
-\fB-i\fR
-Ignore upper/lower case distinctions during comparisons.
-.TP
-\fB-l\fR
-Instead of printing lines from the files, just print the names of the files
-containing lines that would have been printed. Each file name is printed
-once, on a separate line.
-.TP
-\fB-n\fR
-Precede each line by its line number in the file.
-.TP
-\fB-s\fR
-Work silently, that is, display nothing except error messages.
-The exit status indicates whether any matches were found.
-.TP
-\fB-v\fR
-Invert the sense of the match, so that lines which do \fInot\fR match the
-pattern are now the ones that are found.
-.TP
-\fB-x\fR
-Force the pattern to be anchored (it must start matching at the beginning of
-the line) and in addition, require it to match the entire line. This is
-equivalent to having ^ and $ characters at the start and end of each
-alternative branch in the regular expression.
-
-
-.SH SEE ALSO
-\fBpcre(3)\fR, Perl 5 documentation
-
-
-.SH DIAGNOSTICS
-Exit status is 0 if any matches were found, 1 if no matches were found, and 2
-for syntax errors or inacessible files (even if matches were found).
-
-
-.SH AUTHOR
-Philip Hazel <ph10@cam.ac.uk>
-.br
-Copyright (c) 1997-1999 University of Cambridge.
+++ /dev/null
-<HTML>
-<HEAD>
-<TITLE>pgrep specification</TITLE>
-</HEAD>
-<body bgcolor="#FFFFFF" text="#00005A">
-<H1>pgrep specification</H1>
-This HTML document has been generated automatically from the original man page.
-If there is any nonsense in it, please consult the man page in case the
-conversion went wrong.
-<UL>
-<LI><A NAME="TOC1" HREF="#SEC1">NAME</A>
-<LI><A NAME="TOC2" HREF="#SEC2">SYNOPSIS</A>
-<LI><A NAME="TOC3" HREF="#SEC3">DESCRIPTION</A>
-<LI><A NAME="TOC4" HREF="#SEC4">OPTIONS</A>
-<LI><A NAME="TOC5" HREF="#SEC5">SEE ALSO</A>
-<LI><A NAME="TOC6" HREF="#SEC6">DIAGNOSTICS</A>
-<LI><A NAME="TOC7" HREF="#SEC7">AUTHOR</A>
-</UL>
-<LI><A NAME="SEC1" HREF="#TOC1">NAME</A>
-<P>
-pgrep - a grep with Perl-compatible regular expressions.
-</P>
-<LI><A NAME="SEC2" HREF="#TOC1">SYNOPSIS</A>
-<P>
-<B>pgrep [-Vchilnsvx] pattern [file] ...</B>
-</P>
-<LI><A NAME="SEC3" HREF="#TOC1">DESCRIPTION</A>
-<P>
-<B>pgrep</B> searches files for character patterns, in the same way as other
-grep commands do, but it uses the PCRE regular expression library to support
-patterns that are compatible with the regular expressions of Perl 5. See
-<B>pcre(3)</B> for a full description of syntax and semantics.
-</P>
-<P>
-If no files are specified, <B>pgrep</B> reads the standard input. By default,
-each line that matches the pattern is copied to the standard output, and if
-there is more than one file, the file name is printed before each line of
-output. However, there are options that can change how <B>pgrep</B> behaves.
-</P>
-<P>
-Lines are limited to BUFSIZ characters. BUFSIZ is defined in <B><stdio.h></B>.
-The newline character is removed from the end of each line before it is matched
-against the pattern.
-</P>
-<LI><A NAME="SEC4" HREF="#TOC1">OPTIONS</A>
-<P>
-<B>-V</B>
-Write the version number of the PCRE library being used to the standard error
-stream.
-</P>
-<P>
-<B>-c</B>
-Do not print individual lines; instead just print a count of the number of
-lines that would otherwise have been printed. If several files are given, a
-count is printed for each of them.
-</P>
-<P>
-<B>-h</B>
-Suppress printing of filenames when searching multiple files.
-</P>
-<P>
-<B>-i</B>
-Ignore upper/lower case distinctions during comparisons.
-</P>
-<P>
-<B>-l</B>
-Instead of printing lines from the files, just print the names of the files
-containing lines that would have been printed. Each file name is printed
-once, on a separate line.
-</P>
-<P>
-<B>-n</B>
-Precede each line by its line number in the file.
-</P>
-<P>
-<B>-s</B>
-Work silently, that is, display nothing except error messages.
-The exit status indicates whether any matches were found.
-</P>
-<P>
-<B>-v</B>
-Invert the sense of the match, so that lines which do <I>not</I> match the
-pattern are now the ones that are found.
-</P>
-<P>
-<B>-x</B>
-Force the pattern to be anchored (it must start matching at the beginning of
-the line) and in addition, require it to match the entire line. This is
-equivalent to having ^ and $ characters at the start and end of each
-alternative branch in the regular expression.
-</P>
-<LI><A NAME="SEC5" HREF="#TOC1">SEE ALSO</A>
-<P>
-<B>pcre(3)</B>, Perl 5 documentation
-</P>
-<LI><A NAME="SEC6" HREF="#TOC1">DIAGNOSTICS</A>
-<P>
-Exit status is 0 if any matches were found, 1 if no matches were found, and 2
-for syntax errors or inacessible files (even if matches were found).
-</P>
-<LI><A NAME="SEC7" HREF="#TOC1">AUTHOR</A>
-<P>
-Philip Hazel <ph10@cam.ac.uk>
-<BR>
-Copyright (c) 1997-1999 University of Cambridge.
+++ /dev/null
-NAME
- pgrep - a grep with Perl-compatible regular expressions.
-
-
-
-SYNOPSIS
- pgrep [-Vchilnsvx] pattern [file] ...
-
-
-
-DESCRIPTION
- pgrep searches files for character patterns, in the same way
- as other grep commands do, but it uses the PCRE regular
- expression library to support patterns that are compatible
- with the regular expressions of Perl 5. See pcre(3) for a
- full description of syntax and semantics.
-
- If no files are specified, pgrep reads the standard input.
- By default, each line that matches the pattern is copied to
- the standard output, and if there is more than one file, the
- file name is printed before each line of output. However,
- there are options that can change how pgrep behaves.
-
- Lines are limited to BUFSIZ characters. BUFSIZ is defined in
- <stdio.h>. The newline character is removed from the end of
- each line before it is matched against the pattern.
-
-
-
-OPTIONS
- -V Write the version number of the PCRE library being
- used to the standard error stream.
-
- -c Do not print individual lines; instead just print
- a count of the number of lines that would other-
- wise have been printed. If several files are
- given, a count is printed for each of them.
-
- -h Suppress printing of filenames when searching mul-
- tiple files.
-
- -i Ignore upper/lower case distinctions during com-
- parisons.
-
- -l Instead of printing lines from the files, just
- print the names of the files containing lines that
- would have been printed. Each file name is printed
- once, on a separate line.
-
- -n Precede each line by its line number in the file.
-
- -s Work silently, that is, display nothing except
- error messages. The exit status indicates whether
- any matches were found.
-
- -v Invert the sense of the match, so that lines which
- do not match the pattern are now the ones that are
- found.
-
- -x Force the pattern to be anchored (it must start
- matching at the beginning of the line) and in
- addition, require it to match the entire line.
- This is equivalent to having ^ and $ characters at
- the start and end of each alternative branch in
- the regular expression.
-
-
-
-SEE ALSO
- pcre(3), Perl 5 documentation
-
-
-
-
-
-DIAGNOSTICS
- Exit status is 0 if any matches were found, 1 if no matches
- were found, and 2 for syntax errors or inacessible files
- (even if matches were found).
-
-
-
-AUTHOR
- Philip Hazel <ph10@cam.ac.uk>
- Copyright (c) 1997-1999 University of Cambridge.
-
projects / apache / commitdiff