int pcre_config(int what, void *where);
The function pcre_config() makes it possible for a PCRE client to
discover which optional features have been compiled into the PCRE
library. The pcrebuild documentation has more details about these
optional features.
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 returned
value is zero on success, or the negative error code
PCRE_ERROR_BADOPTION if the value in the first argument is not
recognized. The following information is available:
PCRE_CONFIG_UTF8
The output is an integer that is set to one if UTF-8 support is
available; otherwise it is set to zero. This value should
normally be given to the 8-bit version of this function,
pcre_config(). If it is given to the 16-bit or 32-bit version of
this function, the result is PCRE_ERROR_BADOPTION.
PCRE_CONFIG_UTF16
The output is an integer that is set to one if UTF-16 support is
available; otherwise it is set to zero. This value should
normally be given to the 16-bit version of this function,
pcre16_config(). If it is given to the 8-bit or 32-bit version of
this function, the result is PCRE_ERROR_BADOPTION.
PCRE_CONFIG_UTF32
The output is an integer that is set to one if UTF-32 support is
available; otherwise it is set to zero. This value should
normally be given to the 32-bit version of this function,
pcre32_config(). If it is given to the 8-bit or 16-bit version of
this function, the result is PCRE_ERROR_BADOPTION.
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_JIT
The output is an integer that is set to one if support for just-
in-time compiling is available; otherwise it is set to zero.
PCRE_CONFIG_JITTARGET
The output is a pointer to a zero-terminated "const char *"
string. If JIT support is available, the string contains the name
of the architecture for which the JIT compiler is configured, for
example "x86 32bit (little endian + unaligned)". If JIT support
is not available, the result is NULL.
PCRE_CONFIG_NEWLINE
The output is an integer whose value specifies the default
character sequence that is recognized as meaning "newline". The
values that are supported in ASCII/Unicode environments are: 10
for LF, 13 for CR, 3338 for CRLF, -2 for ANYCRLF, and -1 for ANY.
In EBCDIC environments, CR, ANYCRLF, and ANY yield the same
values. However, the value for LF is normally 21, though some
EBCDIC environments use 37. The corresponding values for CRLF are
3349 and 3365. The default should normally correspond to the
standard sequence for your operating system.
PCRE_CONFIG_BSR
The output is an integer whose value indicates what character
sequences the \R escape sequence matches by default. A value of 0
means that \R matches any Unicode line ending sequence; a value
of 1 means that \R matches only CR, LF, or CRLF. The default can
be overridden when a pattern is compiled or matched.
PCRE_CONFIG_LINK_SIZE
The output is an integer that contains the number of bytes used
for internal linkage in compiled regular expressions. For the
8-bit library, the value can be 2, 3, or 4. For the 16-bit
library, the value is either 2 or 4 and is still a number of
bytes. For the 32-bit library, the value is either 2 or 4 and is
still a number of bytes. 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. Larger values allow larger
regular expressions to be compiled, at the expense of slower
matching.
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_PARENS_LIMIT
The output is a long integer that gives the maximum depth of
nesting of parentheses (of any kind) in a pattern. This limit is
imposed to cap the amount of system stack used when a pattern is
compiled. It is specified when PCRE is built; the default is 250.
This limit does not take into account the stack that may already
be used by the calling application. For finer control over
compilation stack usage, you can set a pointer to an external
checking function in pcre_stack_guard.
PCRE_CONFIG_MATCH_LIMIT
The output is a long 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_MATCH_LIMIT_RECURSION
The output is a long integer that gives the default limit for the
depth of recursion when calling the internal matching function 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
when running pcre_exec() 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.
