esruby 0.0.0 → 0.0.2

data/resources/mruby/build/mrbgems/mruby-regexp-pcre/pcre/doc/pcre_get_stringnumber.3

@@ -1,45 +0,0 @@
-.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
-.SM
-.B int pcre_get_stringnumber(const pcre *\fIcode\fP,
-.ti +5n
-.B const char *\fIname\fP);
-.PP
-.B int pcre16_get_stringnumber(const pcre16 *\fIcode\fP,
-.ti +5n
-.B PCRE_SPTR16 \fIname\fP);
-.PP
-.B int pcre32_get_stringnumber(const pcre32 *\fIcode\fP,
-.ti +5n
-.B PCRE_SPTR32 \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. 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/resources/mruby/build/mrbgems/mruby-regexp-pcre/pcre/doc/pcre_get_stringtable_entries.3

@@ -1,48 +0,0 @@
-.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
-.SM
-.B int pcre_get_stringtable_entries(const pcre *\fIcode\fP,
-.ti +5n
-.B const char *\fIname\fP, char **\fIfirst\fP, char **\fIlast\fP);
-.PP
-.B int pcre16_get_stringtable_entries(const pcre16 *\fIcode\fP,
-.ti +5n
-.B PCRE_SPTR16 \fIname\fP, PCRE_UCHAR16 **\fIfirst\fP, PCRE_UCHAR16 **\fIlast\fP);
-.PP
-.B int pcre32_get_stringtable_entries(const pcre32 *\fIcode\fP,
-.ti +5n
-.B PCRE_SPTR32 \fIname\fP, PCRE_UCHAR32 **\fIfirst\fP, PCRE_UCHAR32 **\fIlast\fP);
-.
-.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/resources/mruby/build/mrbgems/mruby-regexp-pcre/pcre/doc/pcre_get_substring.3

@@ -1,55 +0,0 @@
-.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
-.SM
-.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
-.B int pcre16_get_substring(PCRE_SPTR16 \fIsubject\fP, int *\fIovector\fP,
-.ti +5n
-.B int \fIstringcount\fP, int \fIstringnumber\fP,
-.ti +5n
-.B PCRE_SPTR16 *\fIstringptr\fP);
-.PP
-.B int pcre32_get_substring(PCRE_SPTR32 \fIsubject\fP, int *\fIovector\fP,
-.ti +5n
-.B int \fIstringcount\fP, int \fIstringnumber\fP,
-.ti +5n
-.B PCRE_SPTR32 *\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[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/resources/mruby/build/mrbgems/mruby-regexp-pcre/pcre/doc/pcre_get_substring_list.3

@@ -1,49 +0,0 @@
-.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
-.SM
-.B int pcre_get_substring_list(const char *\fIsubject\fP,
-.ti +5n
-.B int *\fIovector\fP, int \fIstringcount\fP, "const char ***\fIlistptr\fP);"
-.PP
-.B int pcre16_get_substring_list(PCRE_SPTR16 \fIsubject\fP,
-.ti +5n
-.B int *\fIovector\fP, int \fIstringcount\fP, "PCRE_SPTR16 **\fIlistptr\fP);"
-.PP
-.B int pcre32_get_substring_list(PCRE_SPTR32 \fIsubject\fP,
-.ti +5n
-.B int *\fIovector\fP, int \fIstringcount\fP, "PCRE_SPTR32 **\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[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/resources/mruby/build/mrbgems/mruby-regexp-pcre/pcre/doc/pcre_jit_exec.3

@@ -1,104 +0,0 @@
-.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
-.SM
-.B int pcre_jit_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,
-.ti +5n
-.B pcre_jit_stack *\fIjstack\fP);
-.PP
-.B int pcre16_jit_exec(const pcre16 *\fIcode\fP, "const pcre16_extra *\fIextra\fP,"
-.ti +5n
-.B "PCRE_SPTR16 \fIsubject\fP," int \fIlength\fP, int \fIstartoffset\fP,
-.ti +5n
-.B int \fIoptions\fP, int *\fIovector\fP, int \fIovecsize\fP,
-.ti +5n
-.B pcre_jit_stack *\fIjstack\fP);
-.PP
-.B int pcre32_jit_exec(const pcre32 *\fIcode\fP, "const pcre32_extra *\fIextra\fP,"
-.ti +5n
-.B "PCRE_SPTR32 \fIsubject\fP," int \fIlength\fP, int \fIstartoffset\fP,
-.ti +5n
-.B int \fIoptions\fP, int *\fIovector\fP, int \fIovecsize\fP,
-.ti +5n
-.B pcre_jit_stack *\fIjstack\fP);
-.
-.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/resources/mruby/build/mrbgems/mruby-regexp-pcre/pcre/doc/pcre_jit_stack_alloc.3

@@ -1,45 +0,0 @@
-.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
-.SM
-.B pcre_jit_stack *pcre_jit_stack_alloc(int \fIstartsize\fP,
-.ti +5n
-.B int \fImaxsize\fP);
-.PP
-.B pcre16_jit_stack *pcre16_jit_stack_alloc(int \fIstartsize\fP,
-.ti +5n
-.B int \fImaxsize\fP);
-.PP
-.B pcre32_jit_stack *pcre32_jit_stack_alloc(int \fIstartsize\fP,
-.ti +5n
-.B int \fImaxsize\fP);
-.
-.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/resources/mruby/build/mrbgems/mruby-regexp-pcre/pcre/doc/pcre_jit_stack_free.3

@@ -1,35 +0,0 @@
-.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/resources/mruby/build/mrbgems/mruby-regexp-pcre/pcre/doc/pcre_maketables.3

@@ -1,33 +0,0 @@
-.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/resources/mruby/build/mrbgems/mruby-regexp-pcre/pcre/doc/pcre_pattern_to_host_byte_order.3

@@ -1,46 +0,0 @@
-.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
-.SM
-.B int pcre_pattern_to_host_byte_order(pcre *\fIcode\fP,
-.ti +5n
-.B pcre_extra *\fIextra\fP, const unsigned char *\fItables\fP);
-.PP
-.B int pcre16_pattern_to_host_byte_order(pcre16 *\fIcode\fP,
-.ti +5n
-.B pcre16_extra *\fIextra\fP, const unsigned char *\fItables\fP);
-.PP
-.B int pcre32_pattern_to_host_byte_order(pcre32 *\fIcode\fP,
-.ti +5n
-.B pcre32_extra *\fIextra\fP, const unsigned char *\fItables\fP);
-.
-.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.