diff options
| author | Brian Pane <brianp@apache.org> | 2004-11-27 20:43:25 +0100 |
|---|---|---|
| committer | Brian Pane <brianp@apache.org> | 2004-11-27 20:43:25 +0100 |
| commit | 5a4f391433cbc7b94edb1f30ae3a835e5e320d0f (patch) | |
| tree | ee39962437943b04b66dff3ff1e95cd91602e7b3 | |
| parent | Add htcacheclean to the NetWare build. (diff) | |
| download | apache2-5a4f391433cbc7b94edb1f30ae3a835e5e320d0f.tar.xz apache2-5a4f391433cbc7b94edb1f30ae3a835e5e320d0f.zip | |
Removed the documentation files because they were making the httpd
source checkout too large, added a README file pointing to the reference
copy of the docs in the PCRE vendor branch
git-svn-id: https://svn.apache.org/repos/asf/httpd/httpd/trunk@106747 13f79535-47bb-0310-9956-ffa450edef68
73 files changed, 6 insertions, 19441 deletions
diff --git a/srclib/pcre/doc/README_httpd b/srclib/pcre/doc/README_httpd new file mode 100644 index 0000000000..322c39c4f2 --- /dev/null +++ b/srclib/pcre/doc/README_httpd @@ -0,0 +1,6 @@ +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/ diff --git a/srclib/pcre/doc/Tech.Notes b/srclib/pcre/doc/Tech.Notes deleted file mode 100644 index 18eb72bce7..0000000000 --- a/srclib/pcre/doc/Tech.Notes +++ /dev/null @@ -1,315 +0,0 @@ -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 diff --git a/srclib/pcre/doc/html/index.html b/srclib/pcre/doc/html/index.html deleted file mode 100644 index c0dbf59d15..0000000000 --- a/srclib/pcre/doc/html/index.html +++ /dev/null @@ -1,108 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre.html b/srclib/pcre/doc/html/pcre.html deleted file mode 100644 index b1caf80701..0000000000 --- a/srclib/pcre/doc/html/pcre.html +++ /dev/null @@ -1,214 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_compile.html b/srclib/pcre/doc/html/pcre_compile.html deleted file mode 100644 index 0d417a1fc9..0000000000 --- a/srclib/pcre/doc/html/pcre_compile.html +++ /dev/null @@ -1,75 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_config.html b/srclib/pcre/doc/html/pcre_config.html deleted file mode 100644 index 8d8cc6073d..0000000000 --- a/srclib/pcre/doc/html/pcre_config.html +++ /dev/null @@ -1,60 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_copy_named_substring.html b/srclib/pcre/doc/html/pcre_copy_named_substring.html deleted file mode 100644 index 2185518c8a..0000000000 --- a/srclib/pcre/doc/html/pcre_copy_named_substring.html +++ /dev/null @@ -1,53 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_copy_substring.html b/srclib/pcre/doc/html/pcre_copy_substring.html deleted file mode 100644 index 9aa87c1746..0000000000 --- a/srclib/pcre/doc/html/pcre_copy_substring.html +++ /dev/null @@ -1,51 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_exec.html b/srclib/pcre/doc/html/pcre_exec.html deleted file mode 100644 index fc3d32282d..0000000000 --- a/srclib/pcre/doc/html/pcre_exec.html +++ /dev/null @@ -1,78 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_free_substring.html b/srclib/pcre/doc/html/pcre_free_substring.html deleted file mode 100644 index fe6261474c..0000000000 --- a/srclib/pcre/doc/html/pcre_free_substring.html +++ /dev/null @@ -1,40 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_free_substring_list.html b/srclib/pcre/doc/html/pcre_free_substring_list.html deleted file mode 100644 index a92c9603f0..0000000000 --- a/srclib/pcre/doc/html/pcre_free_substring_list.html +++ /dev/null @@ -1,40 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_fullinfo.html b/srclib/pcre/doc/html/pcre_fullinfo.html deleted file mode 100644 index 3488285c2a..0000000000 --- a/srclib/pcre/doc/html/pcre_fullinfo.html +++ /dev/null @@ -1,71 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_get_named_substring.html b/srclib/pcre/doc/html/pcre_get_named_substring.html deleted file mode 100644 index ff8456bb57..0000000000 --- a/srclib/pcre/doc/html/pcre_get_named_substring.html +++ /dev/null @@ -1,54 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_get_stringnumber.html b/srclib/pcre/doc/html/pcre_get_stringnumber.html deleted file mode 100644 index 9c8bea0b4b..0000000000 --- a/srclib/pcre/doc/html/pcre_get_stringnumber.html +++ /dev/null @@ -1,46 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_get_substring.html b/srclib/pcre/doc/html/pcre_get_substring.html deleted file mode 100644 index 14a413222a..0000000000 --- a/srclib/pcre/doc/html/pcre_get_substring.html +++ /dev/null @@ -1,52 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_get_substring_list.html b/srclib/pcre/doc/html/pcre_get_substring_list.html deleted file mode 100644 index d278b1793d..0000000000 --- a/srclib/pcre/doc/html/pcre_get_substring_list.html +++ /dev/null @@ -1,51 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_info.html b/srclib/pcre/doc/html/pcre_info.html deleted file mode 100644 index 6693ffee6c..0000000000 --- a/srclib/pcre/doc/html/pcre_info.html +++ /dev/null @@ -1,39 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_maketables.html b/srclib/pcre/doc/html/pcre_maketables.html deleted file mode 100644 index cf8d69ecfd..0000000000 --- a/srclib/pcre/doc/html/pcre_maketables.html +++ /dev/null @@ -1,42 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_study.html b/srclib/pcre/doc/html/pcre_study.html deleted file mode 100644 index d290420e54..0000000000 --- a/srclib/pcre/doc/html/pcre_study.html +++ /dev/null @@ -1,56 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcre_version.html b/srclib/pcre/doc/html/pcre_version.html deleted file mode 100644 index 7bc8f8653e..0000000000 --- a/srclib/pcre/doc/html/pcre_version.html +++ /dev/null @@ -1,39 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcreapi.html b/srclib/pcre/doc/html/pcreapi.html deleted file mode 100644 index 72639f4cc3..0000000000 --- a/srclib/pcre/doc/html/pcreapi.html +++ /dev/null @@ -1,1287 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcrebuild.html b/srclib/pcre/doc/html/pcrebuild.html deleted file mode 100644 index 98c7d27e6e..0000000000 --- a/srclib/pcre/doc/html/pcrebuild.html +++ /dev/null @@ -1,186 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcrecallout.html b/srclib/pcre/doc/html/pcrecallout.html deleted file mode 100644 index dc2ef51697..0000000000 --- a/srclib/pcre/doc/html/pcrecallout.html +++ /dev/null @@ -1,180 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcrecompat.html b/srclib/pcre/doc/html/pcrecompat.html deleted file mode 100644 index 6529c0966a..0000000000 --- a/srclib/pcre/doc/html/pcrecompat.html +++ /dev/null @@ -1,150 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcregrep.html b/srclib/pcre/doc/html/pcregrep.html deleted file mode 100644 index 922487d440..0000000000 --- a/srclib/pcre/doc/html/pcregrep.html +++ /dev/null @@ -1,158 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcrepartial.html b/srclib/pcre/doc/html/pcrepartial.html deleted file mode 100644 index c4dd88613b..0000000000 --- a/srclib/pcre/doc/html/pcrepartial.html +++ /dev/null @@ -1,111 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcrepattern.html b/srclib/pcre/doc/html/pcrepattern.html deleted file mode 100644 index 1220eb7e02..0000000000 --- a/srclib/pcre/doc/html/pcrepattern.html +++ /dev/null @@ -1,1470 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcreperform.html b/srclib/pcre/doc/html/pcreperform.html deleted file mode 100644 index f0ffa68188..0000000000 --- a/srclib/pcre/doc/html/pcreperform.html +++ /dev/null @@ -1,97 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcreposix.html b/srclib/pcre/doc/html/pcreposix.html deleted file mode 100644 index 2f7aaa9d9c..0000000000 --- a/srclib/pcre/doc/html/pcreposix.html +++ /dev/null @@ -1,218 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcreprecompile.html b/srclib/pcre/doc/html/pcreprecompile.html deleted file mode 100644 index f1c109e7c3..0000000000 --- a/srclib/pcre/doc/html/pcreprecompile.html +++ /dev/null @@ -1,133 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcresample.html b/srclib/pcre/doc/html/pcresample.html deleted file mode 100644 index 91cd41137d..0000000000 --- a/srclib/pcre/doc/html/pcresample.html +++ /dev/null @@ -1,81 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/html/pcretest.html b/srclib/pcre/doc/html/pcretest.html deleted file mode 100644 index d82dfcc6a5..0000000000 --- a/srclib/pcre/doc/html/pcretest.html +++ /dev/null @@ -1,495 +0,0 @@ -<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> diff --git a/srclib/pcre/doc/pcre.3 b/srclib/pcre/doc/pcre.3 deleted file mode 100644 index 54b0c3359b..0000000000 --- a/srclib/pcre/doc/pcre.3 +++ /dev/null @@ -1,204 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre.html b/srclib/pcre/doc/pcre.html deleted file mode 100644 index 3e9eb36b68..0000000000 --- a/srclib/pcre/doc/pcre.html +++ /dev/null @@ -1,2669 +0,0 @@ -<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. diff --git a/srclib/pcre/doc/pcre.txt b/srclib/pcre/doc/pcre.txt deleted file mode 100644 index fdf0d6ff67..0000000000 --- a/srclib/pcre/doc/pcre.txt +++ /dev/null @@ -1,3769 +0,0 @@ ------------------------------------------------------------------------------ -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. ------------------------------------------------------------------------------ - diff --git a/srclib/pcre/doc/pcre_compile.3 b/srclib/pcre/doc/pcre_compile.3 deleted file mode 100644 index 37a5f2d936..0000000000 --- a/srclib/pcre/doc/pcre_compile.3 +++ /dev/null @@ -1,64 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre_config.3 b/srclib/pcre/doc/pcre_config.3 deleted file mode 100644 index 1ba934435a..0000000000 --- a/srclib/pcre/doc/pcre_config.3 +++ /dev/null @@ -1,48 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre_copy_named_substring.3 b/srclib/pcre/doc/pcre_copy_named_substring.3 deleted file mode 100644 index 92e47bee20..0000000000 --- a/srclib/pcre/doc/pcre_copy_named_substring.3 +++ /dev/null @@ -1,44 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre_copy_substring.3 b/srclib/pcre/doc/pcre_copy_substring.3 deleted file mode 100644 index c467b502d1..0000000000 --- a/srclib/pcre/doc/pcre_copy_substring.3 +++ /dev/null @@ -1,41 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre_exec.3 b/srclib/pcre/doc/pcre_exec.3 deleted file mode 100644 index 7e071a9be6..0000000000 --- a/srclib/pcre/doc/pcre_exec.3 +++ /dev/null @@ -1,67 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre_free_substring.3 b/srclib/pcre/doc/pcre_free_substring.3 deleted file mode 100644 index 1aafd877bf..0000000000 --- a/srclib/pcre/doc/pcre_free_substring.3 +++ /dev/null @@ -1,28 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre_free_substring_list.3 b/srclib/pcre/doc/pcre_free_substring_list.3 deleted file mode 100644 index d68c3a10bb..0000000000 --- a/srclib/pcre/doc/pcre_free_substring_list.3 +++ /dev/null @@ -1,28 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre_fullinfo.3 b/srclib/pcre/doc/pcre_fullinfo.3 deleted file mode 100644 index 4738127df0..0000000000 --- a/srclib/pcre/doc/pcre_fullinfo.3 +++ /dev/null @@ -1,59 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre_get_named_substring.3 b/srclib/pcre/doc/pcre_get_named_substring.3 deleted file mode 100644 index 9ce27ba39e..0000000000 --- a/srclib/pcre/doc/pcre_get_named_substring.3 +++ /dev/null @@ -1,45 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre_get_stringnumber.3 b/srclib/pcre/doc/pcre_get_stringnumber.3 deleted file mode 100644 index 8c7289474d..0000000000 --- a/srclib/pcre/doc/pcre_get_stringnumber.3 +++ /dev/null @@ -1,35 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre_get_substring.3 b/srclib/pcre/doc/pcre_get_substring.3 deleted file mode 100644 index 9bef5d3abd..0000000000 --- a/srclib/pcre/doc/pcre_get_substring.3 +++ /dev/null @@ -1,42 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre_get_substring_list.3 b/srclib/pcre/doc/pcre_get_substring_list.3 deleted file mode 100644 index 29ae4420f3..0000000000 --- a/srclib/pcre/doc/pcre_get_substring_list.3 +++ /dev/null @@ -1,40 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre_info.3 b/srclib/pcre/doc/pcre_info.3 deleted file mode 100644 index 540c152822..0000000000 --- a/srclib/pcre/doc/pcre_info.3 +++ /dev/null @@ -1,27 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre_maketables.3 b/srclib/pcre/doc/pcre_maketables.3 deleted file mode 100644 index fdc5914e5c..0000000000 --- a/srclib/pcre/doc/pcre_maketables.3 +++ /dev/null @@ -1,30 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre_study.3 b/srclib/pcre/doc/pcre_study.3 deleted file mode 100644 index df428d0afc..0000000000 --- a/srclib/pcre/doc/pcre_study.3 +++ /dev/null @@ -1,43 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcre_version.3 b/srclib/pcre/doc/pcre_version.3 deleted file mode 100644 index 9b07407a42..0000000000 --- a/srclib/pcre/doc/pcre_version.3 +++ /dev/null @@ -1,27 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcreapi.3 b/srclib/pcre/doc/pcreapi.3 deleted file mode 100644 index 42a4e59c96..0000000000 --- a/srclib/pcre/doc/pcreapi.3 +++ /dev/null @@ -1,1288 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcrebuild.3 b/srclib/pcre/doc/pcrebuild.3 deleted file mode 100644 index 8ac588281d..0000000000 --- a/srclib/pcre/doc/pcrebuild.3 +++ /dev/null @@ -1,174 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcrecallout.3 b/srclib/pcre/doc/pcrecallout.3 deleted file mode 100644 index 5fd8ff8712..0000000000 --- a/srclib/pcre/doc/pcrecallout.3 +++ /dev/null @@ -1,155 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcrecompat.3 b/srclib/pcre/doc/pcrecompat.3 deleted file mode 100644 index 6a853e072a..0000000000 --- a/srclib/pcre/doc/pcrecompat.3 +++ /dev/null @@ -1,121 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcregrep.1 b/srclib/pcre/doc/pcregrep.1 deleted file mode 100644 index 56c37d8725..0000000000 --- a/srclib/pcre/doc/pcregrep.1 +++ /dev/null @@ -1,130 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcregrep.html b/srclib/pcre/doc/pcregrep.html deleted file mode 100644 index 7bc210c65a..0000000000 --- a/srclib/pcre/doc/pcregrep.html +++ /dev/null @@ -1,120 +0,0 @@ -<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. diff --git a/srclib/pcre/doc/pcregrep.txt b/srclib/pcre/doc/pcregrep.txt deleted file mode 100644 index 1dca003c8b..0000000000 --- a/srclib/pcre/doc/pcregrep.txt +++ /dev/null @@ -1,122 +0,0 @@ -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. diff --git a/srclib/pcre/doc/pcrepartial.3 b/srclib/pcre/doc/pcrepartial.3 deleted file mode 100644 index 3489c18195..0000000000 --- a/srclib/pcre/doc/pcrepartial.3 +++ /dev/null @@ -1,95 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcrepattern.3 b/srclib/pcre/doc/pcrepattern.3 deleted file mode 100644 index 6f6a21ab1a..0000000000 --- a/srclib/pcre/doc/pcrepattern.3 +++ /dev/null @@ -1,1456 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcreperform.3 b/srclib/pcre/doc/pcreperform.3 deleted file mode 100644 index 999268eaf6..0000000000 --- a/srclib/pcre/doc/pcreperform.3 +++ /dev/null @@ -1,76 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcreposix.3 b/srclib/pcre/doc/pcreposix.3 deleted file mode 100644 index 321dcd7ac9..0000000000 --- a/srclib/pcre/doc/pcreposix.3 +++ /dev/null @@ -1,201 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcreposix.html b/srclib/pcre/doc/pcreposix.html deleted file mode 100644 index 9c89478420..0000000000 --- a/srclib/pcre/doc/pcreposix.html +++ /dev/null @@ -1,191 +0,0 @@ -<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. diff --git a/srclib/pcre/doc/pcreposix.txt b/srclib/pcre/doc/pcreposix.txt deleted file mode 100644 index 2d76f7cdcc..0000000000 --- a/srclib/pcre/doc/pcreposix.txt +++ /dev/null @@ -1,159 +0,0 @@ -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. diff --git a/srclib/pcre/doc/pcreprecompile.3 b/srclib/pcre/doc/pcreprecompile.3 deleted file mode 100644 index f08939bae0..0000000000 --- a/srclib/pcre/doc/pcreprecompile.3 +++ /dev/null @@ -1,125 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcresample.3 b/srclib/pcre/doc/pcresample.3 deleted file mode 100644 index 8d949a671e..0000000000 --- a/srclib/pcre/doc/pcresample.3 +++ /dev/null @@ -1,66 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcretest.1 b/srclib/pcre/doc/pcretest.1 deleted file mode 100644 index 0c06cb701e..0000000000 --- a/srclib/pcre/doc/pcretest.1 +++ /dev/null @@ -1,483 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pcretest.html b/srclib/pcre/doc/pcretest.html deleted file mode 100644 index 918e6dec2b..0000000000 --- a/srclib/pcre/doc/pcretest.html +++ /dev/null @@ -1,369 +0,0 @@ -<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. diff --git a/srclib/pcre/doc/pcretest.txt b/srclib/pcre/doc/pcretest.txt deleted file mode 100644 index 7da68894a1..0000000000 --- a/srclib/pcre/doc/pcretest.txt +++ /dev/null @@ -1,450 +0,0 @@ -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. diff --git a/srclib/pcre/doc/perltest.txt b/srclib/pcre/doc/perltest.txt deleted file mode 100644 index f1d2c15961..0000000000 --- a/srclib/pcre/doc/perltest.txt +++ /dev/null @@ -1,33 +0,0 @@ -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 diff --git a/srclib/pcre/doc/pgrep.1 b/srclib/pcre/doc/pgrep.1 deleted file mode 100644 index d9e9b575e0..0000000000 --- a/srclib/pcre/doc/pgrep.1 +++ /dev/null @@ -1,76 +0,0 @@ -.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. diff --git a/srclib/pcre/doc/pgrep.html b/srclib/pcre/doc/pgrep.html deleted file mode 100644 index 54efed6785..0000000000 --- a/srclib/pcre/doc/pgrep.html +++ /dev/null @@ -1,105 +0,0 @@ -<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. diff --git a/srclib/pcre/doc/pgrep.txt b/srclib/pcre/doc/pgrep.txt deleted file mode 100644 index bcd08c0aab..0000000000 --- a/srclib/pcre/doc/pgrep.txt +++ /dev/null @@ -1,86 +0,0 @@ -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. - |