version 1.1.1.2, 2012/02/21 23:50:25
|
version 1.1.1.3, 2012/10/09 09:19:17
|
Line 1
|
Line 1
|
.TH PCREAPI 3 | .TH PCREAPI 3 "04 May 2012" "PCRE 8.31" |
.SH NAME |
.SH NAME |
PCRE - Perl-compatible regular expressions |
PCRE - Perl-compatible regular expressions |
.sp |
.sp |
Line 302 PCRE supports five different conventions for indicatin
|
Line 302 PCRE supports five different conventions for indicatin
|
strings: a single CR (carriage return) character, a single LF (linefeed) |
strings: a single CR (carriage return) character, a single LF (linefeed) |
character, the two-character sequence CRLF, any of the three preceding, or any |
character, the two-character sequence CRLF, any of the three preceding, or any |
Unicode newline sequence. The Unicode newline sequences are the three just |
Unicode newline sequence. The Unicode newline sequences are the three just |
mentioned, plus the single characters VT (vertical tab, U+000B), FF (formfeed, | mentioned, plus the single characters VT (vertical tab, U+000B), FF (form feed, |
U+000C), NEL (next line, U+0085), LS (line separator, U+2028), and PS |
U+000C), NEL (next line, U+0085), LS (line separator, U+2028), and PS |
(paragraph separator, U+2029). |
(paragraph separator, U+2029). |
.P |
.P |
Line 526 documentation). For those options that can be differen
|
Line 526 documentation). For those options that can be differen
|
the pattern, the contents of the \fIoptions\fP argument specifies their |
the pattern, the contents of the \fIoptions\fP argument specifies their |
settings at the start of compilation and execution. The PCRE_ANCHORED, |
settings at the start of compilation and execution. The PCRE_ANCHORED, |
PCRE_BSR_\fIxxx\fP, PCRE_NEWLINE_\fIxxx\fP, PCRE_NO_UTF8_CHECK, and |
PCRE_BSR_\fIxxx\fP, PCRE_NEWLINE_\fIxxx\fP, PCRE_NO_UTF8_CHECK, and |
PCRE_NO_START_OPT options can be set at the time of matching as well as at | PCRE_NO_START_OPTIMIZE options can be set at the time of matching as well as at |
compile time. |
compile time. |
.P |
.P |
If \fIerrptr\fP is NULL, \fBpcre_compile()\fP returns NULL immediately. |
If \fIerrptr\fP is NULL, \fBpcre_compile()\fP returns NULL immediately. |
Line 642 documentation.
|
Line 642 documentation.
|
.sp |
.sp |
PCRE_EXTENDED |
PCRE_EXTENDED |
.sp |
.sp |
If this bit is set, whitespace data characters in the pattern are totally | If this bit is set, white space data characters in the pattern are totally |
ignored except when escaped or inside a character class. Whitespace does not | ignored except when escaped or inside a character class. White space does not |
include the VT character (code 11). In addition, characters between an |
include the VT character (code 11). In addition, characters between an |
unescaped # outside a character class and the next newline, inclusive, are also |
unescaped # outside a character class and the next newline, inclusive, are also |
ignored. This is equivalent to Perl's /x option, and it can be changed within a |
ignored. This is equivalent to Perl's /x option, and it can be changed within a |
Line 661 comment is a literal newline sequence in the pattern;
|
Line 661 comment is a literal newline sequence in the pattern;
|
happen to represent a newline do not count. |
happen to represent a newline do not count. |
.P |
.P |
This option makes it possible to include comments inside complicated patterns. |
This option makes it possible to include comments inside complicated patterns. |
Note, however, that this applies only to data characters. Whitespace characters | Note, however, that this applies only to data characters. White space characters |
may never appear within special character sequences in a pattern, for example |
may never appear within special character sequences in a pattern, for example |
within the sequence (?( that introduces a conditional subpattern. |
within the sequence (?( that introduces a conditional subpattern. |
.sp |
.sp |
Line 741 CRLF sequence. Setting PCRE_NEWLINE_ANYCRLF specifies
|
Line 741 CRLF sequence. Setting PCRE_NEWLINE_ANYCRLF specifies
|
preceding sequences should be recognized. Setting PCRE_NEWLINE_ANY specifies |
preceding sequences should be recognized. Setting PCRE_NEWLINE_ANY specifies |
that any Unicode newline sequence should be recognized. The Unicode newline |
that any Unicode newline sequence should be recognized. The Unicode newline |
sequences are the three just mentioned, plus the single characters VT (vertical |
sequences are the three just mentioned, plus the single characters VT (vertical |
tab, U+000B), FF (formfeed, U+000C), NEL (next line, U+0085), LS (line | tab, U+000B), FF (form feed, U+000C), NEL (next line, U+0085), LS (line |
separator, U+2028), and PS (paragraph separator, U+2029). For the 8-bit |
separator, U+2028), and PS (paragraph separator, U+2029). For the 8-bit |
library, the last two are recognized only in UTF-8 mode. |
library, the last two are recognized only in UTF-8 mode. |
.P |
.P |
Line 753 PCRE_NEWLINE_CR with PCRE_NEWLINE_LF is equivalent to
|
Line 753 PCRE_NEWLINE_CR with PCRE_NEWLINE_LF is equivalent to
|
other combinations may yield unused numbers and cause an error. |
other combinations may yield unused numbers and cause an error. |
.P |
.P |
The only time that a line break in a pattern is specially recognized when |
The only time that a line break in a pattern is specially recognized when |
compiling is when PCRE_EXTENDED is set. CR and LF are whitespace characters, | compiling is when PCRE_EXTENDED is set. CR and LF are white space characters, |
and so are ignored in this mode. Also, an unescaped # outside a character class |
and so are ignored in this mode. Also, an unescaped # outside a character class |
indicates a comment that lasts until after the next line break sequence. In |
indicates a comment that lasts until after the next line break sequence. In |
other circumstances, line break sequences in patterns are treated as literal |
other circumstances, line break sequences in patterns are treated as literal |
Line 926 fallen out of use. To avoid confusion, they have not b
|
Line 926 fallen out of use. To avoid confusion, they have not b
|
72 too many forward references |
72 too many forward references |
73 disallowed Unicode code point (>= 0xd800 && <= 0xdfff) |
73 disallowed Unicode code point (>= 0xd800 && <= 0xdfff) |
74 invalid UTF-16 string (specifically UTF-16) |
74 invalid UTF-16 string (specifically UTF-16) |
|
75 name is too long in (*MARK), (*PRUNE), (*SKIP), or (*THEN) |
|
76 character value in \eu.... sequence is too large |
.sp |
.sp |
The numbers 32 and 10000 in errors 48 and 49 are defaults; different values may |
The numbers 32 and 10000 in errors 48 and 49 are defaults; different values may |
be used if the limits were changed when PCRE was built. |
be used if the limits were changed when PCRE was built. |
Line 962 If studying the pattern does not produce any useful in
|
Line 964 If studying the pattern does not produce any useful in
|
wants to pass any of the other fields to \fBpcre_exec()\fP or |
wants to pass any of the other fields to \fBpcre_exec()\fP or |
\fBpcre_dfa_exec()\fP, it must set up its own \fBpcre_extra\fP block. |
\fBpcre_dfa_exec()\fP, it must set up its own \fBpcre_extra\fP block. |
.P |
.P |
The second argument of \fBpcre_study()\fP contains option bits. There is only | The second argument of \fBpcre_study()\fP contains option bits. There are three |
one option: PCRE_STUDY_JIT_COMPILE. If this is set, and the just-in-time | options: |
compiler is available, the pattern is further compiled into machine code that | .sp |
executes much faster than the \fBpcre_exec()\fP matching function. If | PCRE_STUDY_JIT_COMPILE |
the just-in-time compiler is not available, this option is ignored. All other | PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE |
bits in the \fIoptions\fP argument must be zero. | PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE |
| .sp |
| If any of these are set, and the just-in-time compiler is available, the |
| pattern is further compiled into machine code that executes much faster than |
| the \fBpcre_exec()\fP interpretive matching function. If the just-in-time |
| compiler is not available, these options are ignored. All other bits in the |
| \fIoptions\fP argument must be zero. |
.P |
.P |
JIT compilation is a heavyweight optimization. It can take some time for |
JIT compilation is a heavyweight optimization. It can take some time for |
patterns to be analyzed, and for one-off matches and simple patterns the |
patterns to be analyzed, and for one-off matches and simple patterns the |
Line 991 When you are finished with a pattern, you can free the
|
Line 999 When you are finished with a pattern, you can free the
|
study data by calling \fBpcre_free_study()\fP. This function was added to the |
study data by calling \fBpcre_free_study()\fP. This function was added to the |
API for release 8.20. For earlier versions, the memory could be freed with |
API for release 8.20. For earlier versions, the memory could be freed with |
\fBpcre_free()\fP, just like the pattern itself. This will still work in cases |
\fBpcre_free()\fP, just like the pattern itself. This will still work in cases |
where PCRE_STUDY_JIT_COMPILE is not used, but it is advisable to change to the | where JIT optimization is not used, but it is advisable to change to the new |
new function when convenient. | function when convenient. |
.P |
.P |
This is a typical way in which \fBpcre_study\fP() is used (except that in a |
This is a typical way in which \fBpcre_study\fP() is used (except that in a |
real application there should be tests for errors): |
real application there should be tests for errors): |
Line 1025 created. This speeds up finding a position in the subj
|
Line 1033 created. This speeds up finding a position in the subj
|
matching. (In 16-bit mode, the bitmap is used for 16-bit values less than 256.) |
matching. (In 16-bit mode, the bitmap is used for 16-bit values less than 256.) |
.P |
.P |
These two optimizations apply to both \fBpcre_exec()\fP and |
These two optimizations apply to both \fBpcre_exec()\fP and |
\fBpcre_dfa_exec()\fP. However, they are not used by \fBpcre_exec()\fP if | \fBpcre_dfa_exec()\fP, and the information is also used by the JIT compiler. |
\fBpcre_study()\fP is called with the PCRE_STUDY_JIT_COMPILE option, and | The optimizations can be disabled by setting the PCRE_NO_START_OPTIMIZE option |
just-in-time compiling is successful. The optimizations can be disabled by | when calling \fBpcre_exec()\fP or \fBpcre_dfa_exec()\fP, but if this is done, |
setting the PCRE_NO_START_OPTIMIZE option when calling \fBpcre_exec()\fP or | JIT execution is also disabled. You might want to do this if your pattern |
\fBpcre_dfa_exec()\fP. You might want to do this if your pattern contains | contains callouts or (*MARK) and you want to make use of these facilities in |
callouts or (*MARK) (which cannot be handled by the JIT compiler), and you want | cases where matching fails. See the discussion of PCRE_NO_START_OPTIMIZE |
to make use of these facilities in cases where matching fails. See the | |
discussion of PCRE_NO_START_OPTIMIZE | |
.\" HTML <a href="#execoptions"> |
.\" HTML <a href="#execoptions"> |
.\" </a> |
.\" </a> |
below. |
below. |
Line 1205 Return 1 if the (?J) or (?-J) option setting is used i
|
Line 1211 Return 1 if the (?J) or (?-J) option setting is used i
|
.sp |
.sp |
PCRE_INFO_JIT |
PCRE_INFO_JIT |
.sp |
.sp |
Return 1 if the pattern was studied with the PCRE_STUDY_JIT_COMPILE option, and | Return 1 if the pattern was studied with one of the JIT options, and |
just-in-time compiling was successful. The fourth argument should point to an |
just-in-time compiling was successful. The fourth argument should point to an |
\fBint\fP variable. A return value of 0 means that JIT support is not available |
\fBint\fP variable. A return value of 0 means that JIT support is not available |
in this version of PCRE, or that the pattern was not studied with the | in this version of PCRE, or that the pattern was not studied with a JIT option, |
PCRE_STUDY_JIT_COMPILE option, or that the JIT compiler could not handle this | or that the JIT compiler could not handle this particular pattern. See the |
particular pattern. See the | |
.\" HREF |
.\" HREF |
\fBpcrejit\fP |
\fBpcrejit\fP |
.\" |
.\" |
Line 1218 documentation for details of what can and cannot be ha
|
Line 1223 documentation for details of what can and cannot be ha
|
.sp |
.sp |
PCRE_INFO_JITSIZE |
PCRE_INFO_JITSIZE |
.sp |
.sp |
If the pattern was successfully studied with the PCRE_STUDY_JIT_COMPILE option, | If the pattern was successfully studied with a JIT option, return the size of |
return the size of the JIT compiled code, otherwise return zero. The fourth | the JIT compiled code, otherwise return zero. The fourth argument should point |
argument should point to a \fBsize_t\fP variable. | to a \fBsize_t\fP variable. |
.sp |
.sp |
PCRE_INFO_LASTLITERAL |
PCRE_INFO_LASTLITERAL |
.sp |
.sp |
Line 1232 only if it follows something of variable length. For e
|
Line 1237 only if it follows something of variable length. For e
|
/^a\ed+z\ed+/ the returned value is "z", but for /^a\edz\ed/ the returned value |
/^a\ed+z\ed+/ the returned value is "z", but for /^a\edz\ed/ the returned value |
is -1. |
is -1. |
.sp |
.sp |
|
PCRE_INFO_MAXLOOKBEHIND |
|
.sp |
|
Return the number of characters (NB not bytes) in the longest lookbehind |
|
assertion in the pattern. Note that the simple assertions \eb and \eB require a |
|
one-character lookbehind. This information is useful when doing multi-segment |
|
matching using the partial matching facilities. |
|
.sp |
PCRE_INFO_MINLENGTH |
PCRE_INFO_MINLENGTH |
.sp |
.sp |
If the pattern was studied and a minimum length for matching subject strings |
If the pattern was studied and a minimum length for matching subject strings |
Line 1462 fields (not necessarily in this order):
|
Line 1474 fields (not necessarily in this order):
|
In the 16-bit version of this structure, the \fImark\fP field has type |
In the 16-bit version of this structure, the \fImark\fP field has type |
"PCRE_UCHAR16 **". |
"PCRE_UCHAR16 **". |
.P |
.P |
The \fIflags\fP field is a bitmap that specifies which of the other fields | The \fIflags\fP field is used to specify which of the other fields are set. The |
are set. The flag bits are: | flag bits are: |
.sp |
.sp |
PCRE_EXTRA_STUDY_DATA | PCRE_EXTRA_CALLOUT_DATA |
PCRE_EXTRA_EXECUTABLE_JIT |
PCRE_EXTRA_EXECUTABLE_JIT |
|
PCRE_EXTRA_MARK |
PCRE_EXTRA_MATCH_LIMIT |
PCRE_EXTRA_MATCH_LIMIT |
PCRE_EXTRA_MATCH_LIMIT_RECURSION |
PCRE_EXTRA_MATCH_LIMIT_RECURSION |
PCRE_EXTRA_CALLOUT_DATA | PCRE_EXTRA_STUDY_DATA |
PCRE_EXTRA_TABLES |
PCRE_EXTRA_TABLES |
PCRE_EXTRA_MARK |
|
.sp |
.sp |
Other flag bits should be set to zero. The \fIstudy_data\fP field and sometimes |
Other flag bits should be set to zero. The \fIstudy_data\fP field and sometimes |
the \fIexecutable_jit\fP field are set in the \fBpcre_extra\fP block that is |
the \fIexecutable_jit\fP field are set in the \fBpcre_extra\fP block that is |
returned by \fBpcre_study()\fP, together with the appropriate flag bits. You |
returned by \fBpcre_study()\fP, together with the appropriate flag bits. You |
should not set these yourself, but you may add to the block by setting the | should not set these yourself, but you may add to the block by setting other |
other fields and their corresponding flag bits. | fields and their corresponding flag bits. |
.P |
.P |
The \fImatch_limit\fP field provides a means of preventing PCRE from using up a |
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, |
vast amount of resources when running patterns that are not going to match, |
Line 1492 patterns that are not anchored, the count restarts fro
|
Line 1504 patterns that are not anchored, the count restarts fro
|
in the subject string. |
in the subject string. |
.P |
.P |
When \fBpcre_exec()\fP is called with a pattern that was successfully studied |
When \fBpcre_exec()\fP is called with a pattern that was successfully studied |
with the PCRE_STUDY_JIT_COMPILE option, the way that the matching is executed | with a JIT option, the way that the matching is executed is entirely different. |
is entirely different. However, there is still the possibility of runaway | However, there is still the possibility of runaway matching that goes on for a |
matching that goes on for a very long time, and so the \fImatch_limit\fP value | very long time, and so the \fImatch_limit\fP value is also used in this case |
is also used in this case (but in a different way) to limit how long the | (but in a different way) to limit how long the matching can continue. |
matching can continue. | |
.P |
.P |
The default value for the limit can be set when PCRE is built; the default |
The default value for the limit can be set when PCRE is built; the default |
default is 10 million, which handles all but the most extreme cases. You can |
default is 10 million, which handles all but the most extreme cases. You can |
Line 1514 This limit is of use only if it is set smaller than \f
|
Line 1525 This limit is of use only if it is set smaller than \f
|
Limiting the recursion depth limits the amount of machine stack that can be |
Limiting the recursion depth limits the amount of machine stack that can be |
used, or, when PCRE has been compiled to use memory on the heap instead of the |
used, or, when PCRE has been compiled to use memory on the heap instead of the |
stack, the amount of heap memory that can be used. This limit is not relevant, |
stack, the amount of heap memory that can be used. This limit is not relevant, |
and is ignored, if the pattern was successfully studied with | and is ignored, when matching is done using JIT compiled code. |
PCRE_STUDY_JIT_COMPILE. | |
.P |
.P |
The default value for \fImatch_limit_recursion\fP can be set when PCRE is |
The default value for \fImatch_limit_recursion\fP can be set when PCRE is |
built; the default default is the same value as the default for |
built; the default default is the same value as the default for |
Line 1572 documentation.
|
Line 1582 documentation.
|
The unused bits of the \fIoptions\fP argument for \fBpcre_exec()\fP must be |
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_NEWLINE_\fIxxx\fP, |
zero. The only bits that may be set are PCRE_ANCHORED, PCRE_NEWLINE_\fIxxx\fP, |
PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, PCRE_NOTEMPTY_ATSTART, |
PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, PCRE_NOTEMPTY_ATSTART, |
PCRE_NO_START_OPTIMIZE, PCRE_NO_UTF8_CHECK, PCRE_PARTIAL_SOFT, and | PCRE_NO_START_OPTIMIZE, PCRE_NO_UTF8_CHECK, PCRE_PARTIAL_HARD, and |
PCRE_PARTIAL_HARD. | PCRE_PARTIAL_SOFT. |
.P |
.P |
If the pattern was successfully studied with the PCRE_STUDY_JIT_COMPILE option, | If the pattern was successfully studied with one of the just-in-time (JIT) |
the only supported options for JIT execution are PCRE_NO_UTF8_CHECK, | compile options, the only supported options for JIT execution are |
PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, and PCRE_NOTEMPTY_ATSTART. Note in | PCRE_NO_UTF8_CHECK, PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, |
particular that partial matching is not supported. If an unsupported option is | PCRE_NOTEMPTY_ATSTART, PCRE_PARTIAL_HARD, and PCRE_PARTIAL_SOFT. If an |
used, JIT execution is disabled and the normal interpretive code in | unsupported option is used, JIT execution is disabled and the normal |
\fBpcre_exec()\fP is run. | interpretive code in \fBpcre_exec()\fP is run. |
.sp |
.sp |
PCRE_ANCHORED |
PCRE_ANCHORED |
.sp |
.sp |
Line 1699 causing performance to suffer, but ensuring that in ca
|
Line 1709 causing performance to suffer, but ensuring that in ca
|
"no match", the callouts do occur, and that items such as (*COMMIT) and (*MARK) |
"no match", the callouts do occur, and that items such as (*COMMIT) and (*MARK) |
are considered at every possible starting position in the subject string. If |
are considered at every possible starting position in the subject string. If |
PCRE_NO_START_OPTIMIZE is set at compile time, it cannot be unset at matching |
PCRE_NO_START_OPTIMIZE is set at compile time, it cannot be unset at matching |
time. | time. The use of PCRE_NO_START_OPTIMIZE disables JIT execution; when it is set, |
| matching is always done using interpretively. |
.P |
.P |
Setting PCRE_NO_START_OPTIMIZE can change the outcome of a matching operation. |
Setting PCRE_NO_START_OPTIMIZE can change the outcome of a matching operation. |
Consider the pattern |
Consider the pattern |
Line 1732 returned.
|
Line 1743 returned.
|
.sp |
.sp |
When PCRE_UTF8 is set at compile time, the validity of the subject as a UTF-8 |
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. |
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 | The entire string is checked before any other processing takes place. The value |
start of a UTF-8 character. There is a discussion about the validity of UTF-8 | of \fIstartoffset\fP is also checked to ensure that it points to the start of a |
strings in the | UTF-8 character. There is a discussion about the |
| .\" HTML <a href="pcreunicode.html#utf8strings"> |
| .\" </a> |
| validity of UTF-8 strings |
| .\" |
| in the |
.\" HREF |
.\" HREF |
\fBpcreunicode\fP |
\fBpcreunicode\fP |
.\" |
.\" |
Line 1882 string that it matched that is returned.
|
Line 1898 string that it matched that is returned.
|
.P |
.P |
If the vector is too small to hold all the captured substring offsets, it is |
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 |
used as far as possible (up to two-thirds of its length), and the function |
returns a value of zero. If neither the actual string matched not any captured | returns a value of zero. If neither the actual string matched nor any captured |
substrings are of interest, \fBpcre_exec()\fP may be called with \fIovector\fP |
substrings are of interest, \fBpcre_exec()\fP may be called with \fIovector\fP |
passed as NULL and \fIovecsize\fP as zero. However, if the pattern contains |
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 |
back references and the \fIovector\fP is not big enough to remember the related |
Line 2082 time.
|
Line 2098 time.
|
.sp |
.sp |
PCRE_ERROR_JIT_STACKLIMIT (-27) |
PCRE_ERROR_JIT_STACKLIMIT (-27) |
.sp |
.sp |
This error is returned when a pattern that was successfully studied using the | This error is returned when a pattern that was successfully studied using a |
PCRE_STUDY_JIT_COMPILE option is being matched, but the memory available for | JIT compile option is being matched, but the memory available for the |
the just-in-time processing stack is not large enough. See the | just-in-time processing stack is not large enough. See the |
.\" HREF |
.\" HREF |
\fBpcrejit\fP |
\fBpcrejit\fP |
.\" |
.\" |
documentation for more details. |
documentation for more details. |
.sp |
.sp |
PCRE_ERROR_BADMODE (-28) | PCRE_ERROR_BADMODE (-28) |
.sp |
.sp |
This error is given if a pattern that was compiled by the 8-bit library is |
This error is given if a pattern that was compiled by the 8-bit library is |
passed to a 16-bit library function, or vice versa. |
passed to a 16-bit library function, or vice versa. |
.sp |
.sp |
PCRE_ERROR_BADENDIANNESS (-29) | PCRE_ERROR_BADENDIANNESS (-29) |
.sp |
.sp |
This error is given if a pattern that was compiled and saved is reloaded on a |
This error is given if a pattern that was compiled and saved is reloaded on a |
host with different endianness. The utility function |
host with different endianness. The utility function |
\fBpcre_pattern_to_host_byte_order()\fP can be used to convert such a pattern |
\fBpcre_pattern_to_host_byte_order()\fP can be used to convert such a pattern |
so that it runs on the new host. |
so that it runs on the new host. |
.P |
.P |
Error numbers -16 to -20 and -22 are not used by \fBpcre_exec()\fP. | Error numbers -16 to -20, -22, and -30 are not used by \fBpcre_exec()\fP. |
. |
. |
. |
. |
.\" HTML <a name="badutf8reasons"></a> |
.\" HTML <a name="badutf8reasons"></a> |
Line 2620 When a recursive subpattern is processed, the matching
|
Line 2636 When a recursive subpattern is processed, the matching
|
recursively, using private vectors for \fIovector\fP and \fIworkspace\fP. This |
recursively, using private vectors for \fIovector\fP and \fIworkspace\fP. This |
error is given if the output vector is not large enough. This should be |
error is given if the output vector is not large enough. This should be |
extremely rare, as a vector of size 1000 is used. |
extremely rare, as a vector of size 1000 is used. |
|
.sp |
|
PCRE_ERROR_DFA_BADRESTART (-30) |
|
.sp |
|
When \fBpcre_dfa_exec()\fP is called with the \fBPCRE_DFA_RESTART\fP option, |
|
some plausibility checks are made on the contents of the workspace, which |
|
should contain data about the previous partial match. If any of these checks |
|
fail, this error is given. |
. |
. |
. |
. |
.SH "SEE ALSO" |
.SH "SEE ALSO" |
Line 2644 Cambridge CB2 3QH, England.
|
Line 2667 Cambridge CB2 3QH, England.
|
.rs |
.rs |
.sp |
.sp |
.nf |
.nf |
Last updated: 21 January 2012 | Last updated: 17 June 2012 |
Copyright (c) 1997-2012 University of Cambridge. |
Copyright (c) 1997-2012 University of Cambridge. |
.fi |
.fi |