glib2 3.0.7-x86-mingw32 → 3.0.8-x86-mingw32

data/vendor/local/share/man/man3/pcre32_get_stringnumber.3

@@ -0,0 +1,43 @@
+.TH PCRE_GET_STRINGNUMBER 3 "24 June 2012" "PCRE 8.30"
+.SH NAME
+PCRE - Perl-compatible regular expressions
+.SH SYNOPSIS
+.rs
+.sp
+.B #include <pcre.h>
+.PP
+.nf
+.B int pcre_get_stringnumber(const pcre *\fIcode\fP,
+.B "     const char *\fIname\fP);"
+.sp
+.B int pcre16_get_stringnumber(const pcre16 *\fIcode\fP,
+.B "     PCRE_SPTR16 \fIname\fP);"
+.sp
+.B int pcre32_get_stringnumber(const pcre32 *\fIcode\fP,
+.B "     PCRE_SPTR32 \fIname\fP);"
+.fi
+.
+.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. When duplicate names are allowed
+(PCRE_DUPNAMES is set), it is not defined which of the numbers is returned by
+\fBpcre[16|32]_get_stringnumber()\fP. You can obtain the complete list by calling
+\fBpcre[16|32]_get_stringtable_entries()\fP.
+.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.

data/vendor/local/share/man/man3/pcre32_get_stringtable_entries.3

@@ -0,0 +1,46 @@
+.TH PCRE_GET_STRINGTABLE_ENTRIES 3 "24 June 2012" "PCRE 8.30"
+.SH NAME
+PCRE - Perl-compatible regular expressions
+.SH SYNOPSIS
+.rs
+.sp
+.B #include <pcre.h>
+.PP
+.nf
+.B int pcre_get_stringtable_entries(const pcre *\fIcode\fP,
+.B "     const char *\fIname\fP, char **\fIfirst\fP, char **\fIlast\fP);"
+.sp
+.B int pcre16_get_stringtable_entries(const pcre16 *\fIcode\fP,
+.B "     PCRE_SPTR16 \fIname\fP, PCRE_UCHAR16 **\fIfirst\fP, PCRE_UCHAR16 **\fIlast\fP);"
+.sp
+.B int pcre32_get_stringtable_entries(const pcre32 *\fIcode\fP,
+.B "     PCRE_SPTR32 \fIname\fP, PCRE_UCHAR32 **\fIfirst\fP, PCRE_UCHAR32 **\fIlast\fP);"
+.fi
+.
+.SH DESCRIPTION
+.rs
+.sp
+This convenience function finds, for a compiled pattern, the first and last
+entries for a given name in the table that translates capturing parenthesis
+names into numbers. When names are required to be unique (PCRE_DUPNAMES is
+\fInot\fP set), it is usually easier to use \fBpcre[16|32]_get_stringnumber()\fP
+instead.
+.sp
+  \fIcode\fP    Compiled regular expression
+  \fIname\fP    Name whose entries required
+  \fIfirst\fP   Where to return a pointer to the first entry
+  \fIlast\fP    Where to return a pointer to the last entry
+.sp
+The yield of the function is the length of each entry, or
+PCRE_ERROR_NOSUBSTRING if none are found.
+.P
+There is a complete description of the PCRE native API, including the format of
+the table entries, in the
+.\" HREF
+\fBpcreapi\fP
+.\"
+page, and a description of the POSIX API in the
+.\" HREF
+\fBpcreposix\fP
+.\"
+page.

data/vendor/local/share/man/man3/pcre32_get_substring.3

@@ -0,0 +1,50 @@
+.TH PCRE_GET_SUBSTRING 3 "24 June 2012" "PCRE 8.30"
+.SH NAME
+PCRE - Perl-compatible regular expressions
+.SH SYNOPSIS
+.rs
+.sp
+.B #include <pcre.h>
+.PP
+.nf
+.B int pcre_get_substring(const char *\fIsubject\fP, int *\fIovector\fP,
+.B "     int \fIstringcount\fP, int \fIstringnumber\fP,"
+.B "     const char **\fIstringptr\fP);"
+.sp
+.B int pcre16_get_substring(PCRE_SPTR16 \fIsubject\fP, int *\fIovector\fP,
+.B "     int \fIstringcount\fP, int \fIstringnumber\fP,"
+.B "     PCRE_SPTR16 *\fIstringptr\fP);"
+.sp
+.B int pcre32_get_substring(PCRE_SPTR32 \fIsubject\fP, int *\fIovector\fP,
+.B "     int \fIstringcount\fP, int \fIstringnumber\fP,"
+.B "     PCRE_SPTR32 *\fIstringptr\fP);"
+.fi
+.
+.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[16|32]_exec()\fP used
+  \fIstringcount\fP   Value returned by \fBpcre[16|32]_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[16|32]_malloc()\fP. The convenience function
+\fBpcre[16|32]_free_substring()\fP can be used to free it when it is no longer
+needed. 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.

data/vendor/local/share/man/man3/pcre32_get_substring_list.3

@@ -0,0 +1,47 @@
+.TH PCRE_GET_SUBSTRING_LIST 3 "24 June 2012" "PCRE 8.30"
+.SH NAME
+PCRE - Perl-compatible regular expressions
+.SH SYNOPSIS
+.rs
+.sp
+.B #include <pcre.h>
+.PP
+.nf
+.B int pcre_get_substring_list(const char *\fIsubject\fP,
+.B "     int *\fIovector\fP, int \fIstringcount\fP, const char ***\fIlistptr\fP);"
+.sp
+.B int pcre16_get_substring_list(PCRE_SPTR16 \fIsubject\fP,
+.B "     int *\fIovector\fP, int \fIstringcount\fP, PCRE_SPTR16 **\fIlistptr\fP);"
+.sp
+.B int pcre32_get_substring_list(PCRE_SPTR32 \fIsubject\fP,
+.B "     int *\fIovector\fP, int \fIstringcount\fP, PCRE_SPTR32 **\fIlistptr\fP);"
+.fi
+.
+.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[16|32]_exec\fP used
+  \fIstringcount\fP   Value returned by \fBpcre[16|32]_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[16|32]_malloc()\fP. The convenience function
+\fBpcre[16|32]_free_substring_list()\fP can be used to free it when it is no
+longer needed. 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.

data/vendor/local/share/man/man3/pcre32_jit_exec.3

@@ -0,0 +1,96 @@
+.TH PCRE_EXEC 3 "31 October 2012" "PCRE 8.30"
+.SH NAME
+PCRE - Perl-compatible regular expressions
+.SH SYNOPSIS
+.rs
+.sp
+.B #include <pcre.h>
+.PP
+.nf
+.B int pcre_jit_exec(const pcre *\fIcode\fP, "const pcre_extra *\fIextra\fP,"
+.B "     const char *\fIsubject\fP, int \fIlength\fP, int \fIstartoffset\fP,"
+.B "     int \fIoptions\fP, int *\fIovector\fP, int \fIovecsize\fP,"
+.B "     pcre_jit_stack *\fIjstack\fP);"
+.sp
+.B int pcre16_jit_exec(const pcre16 *\fIcode\fP, "const pcre16_extra *\fIextra\fP,"
+.B "     PCRE_SPTR16 \fIsubject\fP, int \fIlength\fP, int \fIstartoffset\fP,"
+.B "     int \fIoptions\fP, int *\fIovector\fP, int \fIovecsize\fP,"
+.B "     pcre_jit_stack *\fIjstack\fP);"
+.sp
+.B int pcre32_jit_exec(const pcre32 *\fIcode\fP, "const pcre32_extra *\fIextra\fP,"
+.B "     PCRE_SPTR32 \fIsubject\fP, int \fIlength\fP, int \fIstartoffset\fP,"
+.B "     int \fIoptions\fP, int *\fIovector\fP, int \fIovecsize\fP,"
+.B "     pcre_jit_stack *\fIjstack\fP);"
+.fi
+.
+.SH DESCRIPTION
+.rs
+.sp
+This function matches a compiled regular expression that has been successfully
+studied with one of the JIT options against a given subject string, using a
+matching algorithm that is similar to Perl's. It is a "fast path" interface to
+JIT, and it bypasses some of the sanity checks that \fBpcre_exec()\fP applies.
+It returns offsets to captured substrings. Its arguments are:
+.sp
+  \fIcode\fP         Points to the compiled pattern
+  \fIextra\fP        Points to an associated \fBpcre[16|32]_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)
+  \fIjstack\fP       Pointer to a JIT stack
+.sp
+The allowed options are:
+.sp
+  PCRE_NOTBOL            Subject string is not the beginning of a line
+  PCRE_NOTEOL            Subject string is not the end of a line
+  PCRE_NOTEMPTY          An empty string is not a valid match
+  PCRE_NOTEMPTY_ATSTART  An empty string at the start of the subject
+                           is not a valid match
+  PCRE_NO_UTF16_CHECK    Do not check the subject for UTF-16
+                           validity (only relevant if PCRE_UTF16
+                           was set at compile time)
+  PCRE_NO_UTF32_CHECK    Do not check the subject for UTF-32
+                           validity (only relevant if PCRE_UTF32
+                           was set at compile time)
+  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
+  PCRE_PARTIAL_SOFT      )   match if no full matches are found
+  PCRE_PARTIAL_HARD      Return PCRE_ERROR_PARTIAL for a partial match
+                           if that is found before a full match
+.sp
+However, the PCRE_NO_UTF[8|16|32]_CHECK options have no effect, as this check
+is never applied. For details of partial matching, see the
+.\" HREF
+\fBpcrepartial\fP
+.\"
+page. 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[16|32]_study()\fP
+  \fImatch_limit\fP      Limit on internal resource use
+  \fImatch_limit_recursion\fP  Limit on internal recursion depth
+  \fIcallout_data\fP     Opaque data passed back to callouts
+  \fItables\fP           Points to character tables or is NULL
+  \fImark\fP             For passing back a *MARK pointer
+  \fIexecutable_jit\fP   Opaque data from JIT compilation
+.sp
+The flag bits are PCRE_EXTRA_STUDY_DATA, PCRE_EXTRA_MATCH_LIMIT,
+PCRE_EXTRA_MATCH_LIMIT_RECURSION, PCRE_EXTRA_CALLOUT_DATA,
+PCRE_EXTRA_TABLES, PCRE_EXTRA_MARK and PCRE_EXTRA_EXECUTABLE_JIT.
+.P
+There is a complete description of the PCRE native API in the
+.\" HREF
+\fBpcreapi\fP
+.\"
+page and a description of the JIT API in the
+.\" HREF
+\fBpcrejit\fP
+.\"
+page.

data/vendor/local/share/man/man3/pcre32_jit_stack_alloc.3

@@ -0,0 +1,43 @@
+.TH PCRE_JIT_STACK_ALLOC 3 "24 June 2012" "PCRE 8.30"
+.SH NAME
+PCRE - Perl-compatible regular expressions
+.SH SYNOPSIS
+.rs
+.sp
+.B #include <pcre.h>
+.PP
+.nf
+.B pcre_jit_stack *pcre_jit_stack_alloc(int \fIstartsize\fP,
+.B "     int \fImaxsize\fP);"
+.sp
+.B pcre16_jit_stack *pcre16_jit_stack_alloc(int \fIstartsize\fP,
+.B "     int \fImaxsize\fP);"
+.sp
+.B pcre32_jit_stack *pcre32_jit_stack_alloc(int \fIstartsize\fP,
+.B "     int \fImaxsize\fP);"
+.fi
+.
+.SH DESCRIPTION
+.rs
+.sp
+This function is used to create a stack for use by the code compiled by the JIT
+optimization of \fBpcre[16|32]_study()\fP. The arguments are a starting size for
+the stack, and a maximum size to which it is allowed to grow. The result can be
+passed to the JIT run-time code by \fBpcre[16|32]_assign_jit_stack()\fP, or that
+function can set up a callback for obtaining a stack. A maximum stack size of
+512K to 1M should be more than enough for any pattern. For more details, see
+the
+.\" HREF
+\fBpcrejit\fP
+.\"
+page.
+.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.

data/vendor/local/share/man/man3/pcre32_jit_stack_free.3

@@ -0,0 +1,35 @@
+.TH PCRE_JIT_STACK_FREE 3 "24 June 2012" "PCRE 8.30"
+.SH NAME
+PCRE - Perl-compatible regular expressions
+.SH SYNOPSIS
+.rs
+.sp
+.B #include <pcre.h>
+.PP
+.SM
+.B void pcre_jit_stack_free(pcre_jit_stack *\fIstack\fP);
+.PP
+.B void pcre16_jit_stack_free(pcre16_jit_stack *\fIstack\fP);
+.PP
+.B void pcre32_jit_stack_free(pcre32_jit_stack *\fIstack\fP);
+.
+.SH DESCRIPTION
+.rs
+.sp
+This function is used to free a JIT stack that was created by
+\fBpcre[16|32]_jit_stack_alloc()\fP when it is no longer needed. For more details,
+see the
+.\" HREF
+\fBpcrejit\fP
+.\"
+page.
+.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.

data/vendor/local/share/man/man3/pcre32_maketables.3

@@ -0,0 +1,33 @@
+.TH PCRE_MAKETABLES 3 "24 June 2012" "PCRE 8.30"
+.SH NAME
+PCRE - Perl-compatible regular expressions
+.SH SYNOPSIS
+.rs
+.sp
+.B #include <pcre.h>
+.PP
+.SM
+.B const unsigned char *pcre_maketables(void);
+.PP
+.B const unsigned char *pcre16_maketables(void);
+.PP
+.B const unsigned char *pcre32_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[16|32]_compile()\fP to override PCRE's
+internal, built-in tables (which were made by \fBpcre[16|32]_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.

data/vendor/local/share/man/man3/pcre32_pattern_to_host_byte_order.3

@@ -0,0 +1,44 @@
+.TH PCRE_PATTERN_TO_HOST_BYTE_ORDER 3 "24 June 2012" "PCRE 8.30"
+.SH NAME
+PCRE - Perl-compatible regular expressions
+.SH SYNOPSIS
+.rs
+.sp
+.B #include <pcre.h>
+.PP
+.nf
+.B int pcre_pattern_to_host_byte_order(pcre *\fIcode\fP,
+.B "     pcre_extra *\fIextra\fP, const unsigned char *\fItables\fP);"
+.sp
+.B int pcre16_pattern_to_host_byte_order(pcre16 *\fIcode\fP,
+.B "     pcre16_extra *\fIextra\fP, const unsigned char *\fItables\fP);"
+.sp
+.B int pcre32_pattern_to_host_byte_order(pcre32 *\fIcode\fP,
+.B "     pcre32_extra *\fIextra\fP, const unsigned char *\fItables\fP);"
+.fi
+.
+.SH DESCRIPTION
+.rs
+.sp
+This function ensures that the bytes in 2-byte and 4-byte values in a compiled
+pattern are in the correct order for the current host. It is useful when a
+pattern that has been compiled on one host is transferred to another that might
+have different endianness. The arguments are:
+.sp
+  \fIcode\fP         A compiled regular expression
+  \fIextra\fP        Points to an associated \fBpcre[16|32]_extra\fP structure,
+                 or is NULL
+  \fItables\fP       Pointer to character tables, or NULL to
+                 set the built-in default
+.sp
+The result is 0 for success, a negative PCRE_ERROR_xxx value 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.

data/vendor/local/share/man/man3/pcre32_refcount.3

@@ -0,0 +1,36 @@
+.TH PCRE_REFCOUNT 3 "24 June 2012" "PCRE 8.30"
+.SH NAME
+PCRE - Perl-compatible regular expressions
+.SH SYNOPSIS
+.rs
+.sp
+.B #include <pcre.h>
+.PP
+.SM
+.B int pcre_refcount(pcre *\fIcode\fP, int \fIadjust\fP);
+.PP
+.B int pcre16_refcount(pcre16 *\fIcode\fP, int \fIadjust\fP);
+.PP
+.B int pcre32_refcount(pcre32 *\fIcode\fP, int \fIadjust\fP);
+.
+.SH DESCRIPTION
+.rs
+.sp
+This function is used to maintain a reference count inside a data block that
+contains a compiled pattern. Its arguments are:
+.sp
+  \fIcode\fP                      Compiled regular expression
+  \fIadjust\fP                    Adjustment to reference value
+.sp
+The yield of the function is the adjusted reference value, which is constrained
+to lie between 0 and 65535.
+.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.

data/vendor/local/share/man/man3/pcre32_study.3

@@ -0,0 +1,54 @@
+.TH PCRE_STUDY 3 " 24 June 2012" "PCRE 8.30"
+.SH NAME
+PCRE - Perl-compatible regular expressions
+.SH SYNOPSIS
+.rs
+.sp
+.B #include <pcre.h>
+.PP
+.nf
+.B pcre_extra *pcre_study(const pcre *\fIcode\fP, int \fIoptions\fP,
+.B "     const char **\fIerrptr\fP);"
+.sp
+.B pcre16_extra *pcre16_study(const pcre16 *\fIcode\fP, int \fIoptions\fP,
+.B "     const char **\fIerrptr\fP);"
+.sp
+.B pcre32_extra *pcre32_study(const pcre32 *\fIcode\fP, int \fIoptions\fP,
+.B "     const char **\fIerrptr\fP);"
+.fi
+.
+.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[16|32]_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[16|32]_exec()\fP or \fBpcre[16|32]_dfa_exec()\fP via their \fIextra\fP
+arguments.
+.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
+The only option is PCRE_STUDY_JIT_COMPILE. It requests just-in-time compilation
+if possible. If PCRE has been compiled without JIT support, this option is
+ignored. See the
+.\" HREF
+\fBpcrejit\fP
+.\"
+page for further details.
+.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.

data/vendor/local/share/man/man3/pcre32_utf32_to_host_byte_order.3

@@ -0,0 +1,45 @@
+.TH PCRE_UTF32_TO_HOST_BYTE_ORDER 3 "24 June 2012" "PCRE 8.30"
+.SH NAME
+PCRE - Perl-compatible regular expressions
+.SH SYNOPSIS
+.rs
+.sp
+.B #include <pcre.h>
+.PP
+.nf
+.B int pcre32_utf32_to_host_byte_order(PCRE_UCHAR32 *\fIoutput\fP,
+.B "     PCRE_SPTR32 \fIinput\fP, int \fIlength\fP, int *\fIhost_byte_order\fP,"
+.B "     int \fIkeep_boms\fP);"
+.fi
+.
+.
+.SH DESCRIPTION
+.rs
+.sp
+This function, which exists only in the 32-bit library, converts a UTF-32
+string to the correct order for the current host, taking account of any byte
+order marks (BOMs) within the string. Its arguments are:
+.sp
+  \fIoutput\fP           pointer to output buffer, may be the same as \fIinput\fP
+  \fIinput\fP            pointer to input buffer
+  \fIlength\fP           number of 32-bit units in the input, or negative for
+                     a zero-terminated string
+  \fIhost_byte_order\fP  a NULL value or a non-zero value pointed to means
+                     start in host byte order
+  \fIkeep_boms\fP        if non-zero, BOMs are copied to the output string
+.sp
+The result of the function is the number of 32-bit units placed into the output
+buffer, including the zero terminator if the string was zero-terminated.
+.P
+If \fIhost_byte_order\fP is not NULL, it is set to indicate the byte order that
+is current at the end of 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.

data/vendor/local/share/man/man3/pcre32_version.3

@@ -0,0 +1,31 @@
+.TH PCRE_VERSION 3 "24 June 2012" "PCRE 8.30"
+.SH NAME
+PCRE - Perl-compatible regular expressions
+.SH SYNOPSIS
+.rs
+.sp
+.B #include <pcre.h>
+.PP
+.SM
+.B const char *pcre_version(void);
+.PP
+.B const char *pcre16_version(void);
+.PP
+.B const char *pcre32_version(void);
+.
+.SH DESCRIPTION
+.rs
+.sp
+This function (even in the 16-bit and 32-bit libraries) returns a
+zero-terminated, 8-bit 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.

data/vendor/local/share/man/man3/pcre_assign_jit_stack.3

@@ -0,0 +1,59 @@
+.TH PCRE_ASSIGN_JIT_STACK 3 "24 June 2012" "PCRE 8.30"
+.SH NAME
+PCRE - Perl-compatible regular expressions
+.SH SYNOPSIS
+.rs
+.sp
+.B #include <pcre.h>
+.PP
+.nf
+.B void pcre_assign_jit_stack(pcre_extra *\fIextra\fP,
+.B "     pcre_jit_callback \fIcallback\fP, void *\fIdata\fP);"
+.sp
+.B void pcre16_assign_jit_stack(pcre16_extra *\fIextra\fP,
+.B "     pcre16_jit_callback \fIcallback\fP, void *\fIdata\fP);"
+.sp
+.B void pcre32_assign_jit_stack(pcre32_extra *\fIextra\fP,
+.B "     pcre32_jit_callback \fIcallback\fP, void *\fIdata\fP);"
+.fi
+.
+.SH DESCRIPTION
+.rs
+.sp
+This function provides control over the memory used as a stack at run-time by a
+call to \fBpcre[16|32]_exec()\fP with a pattern that has been successfully
+compiled with JIT optimization. The arguments are:
+.sp
+  extra     the data pointer returned by \fBpcre[16|32]_study()\fP
+  callback  a callback function
+  data      a JIT stack or a value to be passed to the callback
+              function
+.P
+If \fIcallback\fP is NULL and \fIdata\fP is NULL, an internal 32K block on
+the machine stack is used.
+.P
+If \fIcallback\fP is NULL and \fIdata\fP is not NULL, \fIdata\fP must
+be a valid JIT stack, the result of calling \fBpcre[16|32]_jit_stack_alloc()\fP.
+.P
+If \fIcallback\fP not NULL, it is called with \fIdata\fP as an argument at
+the start of matching, in order to set up a JIT stack. If the result is NULL,
+the internal 32K stack is used; otherwise the return value must be a valid JIT
+stack, the result of calling \fBpcre[16|32]_jit_stack_alloc()\fP.
+.P
+You may safely assign the same JIT stack to multiple patterns, as long as they
+are all matched in the same thread. In a multithread application, each thread
+must use its own JIT stack. For more details, see the
+.\" HREF
+\fBpcrejit\fP
+.\"
+page.
+.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.