#include <sys/types.h>
#include <strings.h>
#include "regex.h"
#include <ctype.h>
Go to the source code of this file.
Classes | |
struct | compile_stack_elt_t |
struct | compile_stack_type |
struct | fail_stack_type |
union | register_info_type |
Defines | |
#define | _GNU_SOURCE |
#define | assert(e) |
#define | AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) || !size2) |
#define | AT_STRINGS_END(d) ((d) == end2) |
#define | AT_WORD_BOUNDARY(d) |
#define | BUF_PUSH(c) |
#define | BUF_PUSH_2(c1, c2) |
#define | BUF_PUSH_3(c1, c2, c3) |
#define | BYTEWIDTH 8 |
#define | CHAR_CLASS_MAX_LENGTH 6 |
#define | CHAR_SET_SIZE 256 |
#define | COMPILE_STACK_EMPTY (compile_stack.avail == 0) |
#define | COMPILE_STACK_FULL (compile_stack.avail == compile_stack.size) |
#define | COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail]) |
#define | const |
#define | DEBUG_POP(item_addr) |
#define | DEBUG_PRINT1(x) |
#define | DEBUG_PRINT2(x1, x2) |
#define | DEBUG_PRINT3(x1, x2, x3) |
#define | DEBUG_PRINT4(x1, x2, x3, x4) |
#define | DEBUG_PRINT_COMPILED_PATTERN(p, s, e) |
#define | DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2) |
#define | DEBUG_PUSH(item) |
#define | DEBUG_STATEMENT(e) |
#define | DOUBLE_FAIL_STACK(fail_stack) |
#define | EVER_MATCHED_SOMETHING(R) ((R).bits.ever_matched_something) |
#define | EXTEND_BUFFER() |
#define | EXTRACT_NUMBER(destination, source) |
#define | EXTRACT_NUMBER_AND_INCR(destination, source) |
#define | FAIL_STACK_EMPTY() (fail_stack.avail == 0) |
#define | FAIL_STACK_FULL() (fail_stack.avail == fail_stack.size) |
#define | FAIL_STACK_PTR_EMPTY() (fail_stack_ptr->avail == 0) |
#define | FAIL_STACK_TOP() (fail_stack.stack[fail_stack.avail]) |
#define | false 0 |
#define | FIRST_STRING_P(ptr) (size1 && string1 <= (ptr) && (ptr) <= string1 + size1) |
#define | FREE_VARIABLES() alloca (0) |
#define | GET_BUFFER_SPACE(n) |
#define | GET_UNSIGNED_NUMBER(num) |
#define | INIT_BUF_SIZE 32 |
#define | INIT_COMPILE_STACK_SIZE 32 |
#define | INIT_FAIL_STACK() |
#define | INIT_FAILURE_ALLOC 5 |
#define | INSERT_JUMP(op, loc, to) insert_op1 (op, loc, (to) - (loc) - 3, b) |
#define | INSERT_JUMP2(op, loc, to, arg) insert_op2 (op, loc, (to) - (loc) - 3, arg, b) |
#define | IS_ACTIVE(R) ((R).bits.is_active) |
#define | IS_CHAR_CLASS(string) |
#define | ISALNUM(c) (isascii (c) && isalnum (c)) |
#define | ISALPHA(c) (isascii (c) && isalpha (c)) |
#define | isascii(c) 1 |
#define | ISBLANK(c) ((c) == ' ' || (c) == '\t') |
#define | ISCNTRL(c) (isascii (c) && iscntrl (c)) |
#define | ISDIGIT(c) (isascii (c) && isdigit (c)) |
#define | ISGRAPH(c) (isascii (c) && isprint (c) && !isspace (c)) |
#define | ISLOWER(c) (isascii (c) && islower (c)) |
#define | ISPRINT(c) (isascii (c) && isprint (c)) |
#define | ISPUNCT(c) (isascii (c) && ispunct (c)) |
#define | ISSPACE(c) (isascii (c) && isspace (c)) |
#define | ISUPPER(c) (isascii (c) && isupper (c)) |
#define | ISXDIGIT(c) (isascii (c) && isxdigit (c)) |
#define | MATCH_NULL_UNSET_VALUE 3 |
#define | MATCHED_SOMETHING(R) ((R).bits.matched_something) |
#define | MATCHING_IN_FIRST_STRING (dend == end_match_1) |
#define | MAX(a, b) ((a) > (b) ? (a) : (b)) |
#define | MAX_BUF_SIZE (1L << 16) |
#define | MAX_FAILURE_ITEMS ((num_regs - 1) * NUM_REG_ITEMS + NUM_NONREG_ITEMS) |
#define | MAX_REGNUM 255 |
#define | MIN(a, b) ((a) < (b) ? (a) : (b)) |
#define | NO_HIGHEST_ACTIVE_REG (1 << BYTEWIDTH) |
#define | NO_LOWEST_ACTIVE_REG (NO_HIGHEST_ACTIVE_REG + 1) |
#define | NULL 0 |
#define | NUM_FAILURE_ITEMS |
#define | NUM_NONREG_ITEMS 4 |
#define | NUM_REG_ITEMS 3 |
#define | PATFETCH(c) |
#define | PATFETCH_RAW(c) |
#define | PATUNFETCH p-- |
#define | POINTER_TO_OFFSET(ptr) (FIRST_STRING_P (ptr) ? (ptr) - string1 : (ptr) - string2 + size1) |
#define | POP_FAILURE_ITEM() fail_stack.stack[--fail_stack.avail] |
#define | POP_FAILURE_POINT(str, pat, low_reg, high_reg, regstart, regend, reg_info) |
#define | PREFETCH() |
#define | PUSH_FAILURE_ITEM(item) fail_stack.stack[fail_stack.avail++] = (fail_stack_elt_t) item |
#define | PUSH_FAILURE_POINT(pattern_place, string_place, failure_code) |
#define | PUSH_PATTERN_OP(pattern_op, fail_stack) |
#define | REG_MATCH_NULL_STRING_P(R) ((R).bits.match_null_string_p) |
#define | REG_UNSET(e) ((e) == REG_UNSET_VALUE) |
#define | REG_UNSET_VALUE ((char *) -1) |
#define | REGEX_ALLOCATE alloca |
#define | REGEX_REALLOCATE(source, osize, nsize) |
#define | REGEX_TALLOC(n, t) ((t *) REGEX_ALLOCATE ((n) * sizeof (t))) |
#define | REMAINING_AVAIL_SLOTS ((fail_stack).size - (fail_stack).avail) |
#define | RETALLOC(addr, n, t) ((addr) = (t *) realloc (addr, (n) * sizeof (t))) |
#define | SET_LIST_BIT(c) |
#define | SET_REGS_MATCHED() |
#define | SIGN_EXTEND_CHAR(c) ((((unsigned char) (c)) ^ 128) - 128) |
#define | STORE_JUMP(op, loc, to) store_op1 (op, loc, (to) - (loc) - 3) |
#define | STORE_JUMP2(op, loc, to, arg) store_op2 (op, loc, (to) - (loc) - 3, arg) |
#define | STORE_NUMBER(destination, number) |
#define | STORE_NUMBER_AND_INCR(destination, number) |
#define | STREQ(s1, s2) ((strcmp (s1, s2) == 0)) |
#define | Sword 1 |
#define | SYNTAX(c) re_syntax_table[c] |
#define | TALLOC(n, t) ((t *) malloc ((n) * sizeof (t))) |
#define | TRANSLATE(d) (translate ? translate[(unsigned char) (d)] : (d)) |
#define | true 1 |
#define | WORDCHAR_P(d) |
Typedefs | |
typedef char | boolean |
typedef const unsigned char * | fail_stack_elt_t |
typedef int | pattern_offset_t |
typedef unsigned | regnum_t |
Enumerations | |
enum | re_opcode_t { no_op = 0, exactn = 1, anychar, charset, charset_not, start_memory, stop_memory, duplicate, begline, endline, begbuf, endbuf, jump, jump_past_alt, on_failure_jump, on_failure_keep_string_jump, pop_failure_jump, maybe_pop_jump, dummy_failure_jump, push_dummy_failure, succeed_n, jump_n, set_number_at, wordchar, notwordchar, wordbeg, wordend, wordbound, notwordbound } |
Functions | |
char * | alloca () |
static boolean | alt_match_null_string_p (unsigned char *p, unsigned char *end, register_info_type *reg_info) |
static boolean | alt_match_null_string_p () |
static boolean | at_begline_loc_p (char *pattern, char *p, reg_syntax_t syntax) const |
static boolean | at_begline_loc_p () |
static boolean | at_endline_loc_p (char *p, char *pend, int syntax) const |
static boolean | at_endline_loc_p () |
static int | bcmp_translate (unsigned char *s1, unsigned char *s2, int len, char *translate) |
static int | bcmp_translate () |
static boolean | common_op_match_null_string_p (unsigned char **p, unsigned char *end, register_info_type *reg_info) |
static boolean | common_op_match_null_string_p () |
static reg_errcode_t | compile_range (char **p_ptr, char *pend, char *translate, reg_syntax_t syntax, unsigned char *b) const |
static reg_errcode_t | compile_range () |
static boolean | group_in_compile_stack (compile_stack_type compile_stack, regnum_t regnum) |
static boolean | group_in_compile_stack () |
static boolean | group_match_null_string_p (unsigned char **p, unsigned char *end, register_info_type *reg_info) |
static boolean | group_match_null_string_p () |
static void | init_syntax_once () |
static void | insert_op1 (re_opcode_t op, unsigned char *loc, int arg, unsigned char *end) |
static void | insert_op1 () |
static void | insert_op2 (re_opcode_t op, unsigned char *loc, int arg1, int arg2, unsigned char *end) |
static void | insert_op2 () |
char * | malloc () |
char * | re_comp (char *s) const |
int | re_compile_fastmap (struct re_pattern_buffer *bufp) |
const char * | re_compile_pattern (char *pattern, int length, struct re_pattern_buffer *bufp) const |
int | re_exec (char *s) const |
int | re_match (struct re_pattern_buffer *bufp, const char *string, int size, int pos, struct re_registers *regs) |
int | re_match_2 (struct re_pattern_buffer *bufp, const char *string1, int size1, const char *string2, int size2, int pos, struct re_registers *regs, int stop) |
int | re_search (struct re_pattern_buffer *bufp, const char *string, int size, int startpos, int range, struct re_registers *regs) |
int | re_search_2 (struct re_pattern_buffer *bufp, const char *string1, int size1, const char *string2, int size2, int startpos, int range, struct re_registers *regs, int stop) |
void | re_set_registers (struct re_pattern_buffer *bufp, struct re_registers *regs, unsigned num_regs, regoff_t *starts, regoff_t *ends) |
reg_syntax_t | re_set_syntax (reg_syntax_t syntax) |
char * | realloc () |
int | regcomp (regex_t *preg, const char *pattern, int cflags) |
size_t | regerror (int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size) |
static reg_errcode_t | regex_compile (char const *pattern, int size, reg_syntax_t syntax, struct re_pattern_buffer *bufp) |
int | regexec (regex_t *preg, const char *string, size_t nmatch, pmatch, int eflags) const |
int | regexec1 (regex_t *preg, const char *string, int stringLength, size_t nmatch, pmatch, int eflags) const |
void | regfree (regex_t *preg) |
static void | store_op1 (re_opcode_t op, unsigned char *loc, int arg) |
static void | store_op1 () |
static void | store_op2 (re_opcode_t op, unsigned char *loc, int arg1, int arg2) |
static void | store_op2 () |
Variables | |
static struct re_pattern_buffer | re_comp_buf |
static const char * | re_error_msg [] |
int | re_max_failures = 2000 |
reg_syntax_t | re_syntax_options = RE_SYNTAX_EMACS |
static char | re_syntax_table [CHAR_SET_SIZE] |
#define AT_STRINGS_BEG | ( | d | ) | ((d) == (size1 ? string1 : string2) || !size2) |
#define AT_WORD_BOUNDARY | ( | d | ) |
(AT_STRINGS_BEG (d) || AT_STRINGS_END (d) \ || WORDCHAR_P (d - 1) != WORDCHAR_P (d))
#define BUF_PUSH | ( | c | ) |
do { \ GET_BUFFER_SPACE (1); \ *b++ = (unsigned char) (c); \ } while (0)
#define BUF_PUSH_2 | ( | c1, | |||
c2 | ) |
do { \ GET_BUFFER_SPACE (2); \ *b++ = (unsigned char) (c1); \ *b++ = (unsigned char) (c2); \ } while (0)
#define BUF_PUSH_3 | ( | c1, | |||
c2, | |||||
c3 | ) |
do { \ GET_BUFFER_SPACE (3); \ *b++ = (unsigned char) (c1); \ *b++ = (unsigned char) (c2); \ *b++ = (unsigned char) (c3); \ } while (0)
#define COMPILE_STACK_FULL (compile_stack.avail == compile_stack.size) |
#define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail]) |
#define DOUBLE_FAIL_STACK | ( | fail_stack | ) |
((fail_stack).size > re_max_failures * MAX_FAILURE_ITEMS \ ? 0 \ : ((fail_stack).stack = (fail_stack_elt_t *) \ REGEX_REALLOCATE ((fail_stack).stack, \ (fail_stack).size * sizeof (fail_stack_elt_t), \ ((fail_stack).size << 1) * sizeof (fail_stack_elt_t)), \ \ (fail_stack).stack == NULL \ ? 0 \ : ((fail_stack).size <<= 1, \ 1)))
#define EVER_MATCHED_SOMETHING | ( | R | ) | ((R).bits.ever_matched_something) |
#define EXTEND_BUFFER | ( | ) |
do { \ unsigned char *old_buffer = bufp->buffer; \ if (bufp->allocated == MAX_BUF_SIZE) \ return REG_ESIZE; \ bufp->allocated <<= 1; \ if (bufp->allocated > MAX_BUF_SIZE) \ bufp->allocated = MAX_BUF_SIZE; \ bufp->buffer = (unsigned char *) realloc (bufp->buffer, bufp->allocated);\ if (bufp->buffer == NULL) \ return REG_ESPACE; \ /* If the buffer moved, move all the pointers into it. */ \ if (old_buffer != bufp->buffer) \ { \ b = (b - old_buffer) + bufp->buffer; \ begalt = (begalt - old_buffer) + bufp->buffer; \ if (fixup_alt_jump) \ fixup_alt_jump = (fixup_alt_jump - old_buffer) + bufp->buffer;\ if (laststart) \ laststart = (laststart - old_buffer) + bufp->buffer; \ if (pending_exact) \ pending_exact = (pending_exact - old_buffer) + bufp->buffer; \ } \ } while (0)
#define EXTRACT_NUMBER | ( | destination, | |||
source | ) |
do { \ (destination) = *(source) & 0377; \ (destination) += SIGN_EXTEND_CHAR (*((source) + 1)) << 8; \ } while (0)
#define EXTRACT_NUMBER_AND_INCR | ( | destination, | |||
source | ) |
do { \ EXTRACT_NUMBER (destination, source); \ (source) += 2; \ } while (0)
#define FAIL_STACK_FULL | ( | ) | (fail_stack.avail == fail_stack.size) |
#define FAIL_STACK_PTR_EMPTY | ( | ) | (fail_stack_ptr->avail == 0) |
#define FAIL_STACK_TOP | ( | ) | (fail_stack.stack[fail_stack.avail]) |
#define FIRST_STRING_P | ( | ptr | ) | (size1 && string1 <= (ptr) && (ptr) <= string1 + size1) |
#define GET_BUFFER_SPACE | ( | n | ) |
while (b - bufp->buffer + (n) > bufp->allocated) \ EXTEND_BUFFER ()
#define GET_UNSIGNED_NUMBER | ( | num | ) |
#define INIT_FAIL_STACK | ( | ) |
do { \ fail_stack.stack = (fail_stack_elt_t *) \ REGEX_ALLOCATE (INIT_FAILURE_ALLOC * sizeof (fail_stack_elt_t)); \ \ if (fail_stack.stack == NULL) \ return -2; \ \ fail_stack.size = INIT_FAILURE_ALLOC; \ fail_stack.avail = 0; \ } while (0)
#define INSERT_JUMP | ( | op, | |||
loc, | |||||
to | ) | insert_op1 (op, loc, (to) - (loc) - 3, b) |
#define INSERT_JUMP2 | ( | op, | |||
loc, | |||||
to, | |||||
arg | ) | insert_op2 (op, loc, (to) - (loc) - 3, arg, b) |
#define IS_CHAR_CLASS | ( | string | ) |
(STREQ (string, "alpha") || STREQ (string, "upper") \ || STREQ (string, "lower") || STREQ (string, "digit") \ || STREQ (string, "alnum") || STREQ (string, "xdigit") \ || STREQ (string, "space") || STREQ (string, "print") \ || STREQ (string, "punct") || STREQ (string, "graph") \ || STREQ (string, "cntrl") || STREQ (string, "blank"))
#define ISGRAPH | ( | c | ) | (isascii (c) && isprint (c) && !isspace (c)) |
#define MATCHED_SOMETHING | ( | R | ) | ((R).bits.matched_something) |
#define MAX_FAILURE_ITEMS ((num_regs - 1) * NUM_REG_ITEMS + NUM_NONREG_ITEMS) |
#define NUM_FAILURE_ITEMS |
((highest_active_reg - lowest_active_reg + 1) * NUM_REG_ITEMS \ + NUM_NONREG_ITEMS)
#define PATFETCH | ( | c | ) |
#define PATFETCH_RAW | ( | c | ) |
#define POINTER_TO_OFFSET | ( | ptr | ) | (FIRST_STRING_P (ptr) ? (ptr) - string1 : (ptr) - string2 + size1) |
#define POP_FAILURE_ITEM | ( | ) | fail_stack.stack[--fail_stack.avail] |
#define POP_FAILURE_POINT | ( | str, | |||
pat, | |||||
low_reg, | |||||
high_reg, | |||||
regstart, | |||||
regend, | |||||
reg_info | ) |
#define PREFETCH | ( | ) |
#define PUSH_FAILURE_ITEM | ( | item | ) | fail_stack.stack[fail_stack.avail++] = (fail_stack_elt_t) item |
#define PUSH_FAILURE_POINT | ( | pattern_place, | |||
string_place, | |||||
failure_code | ) |
#define PUSH_PATTERN_OP | ( | pattern_op, | |||
fail_stack | ) |
((FAIL_STACK_FULL () \ && !DOUBLE_FAIL_STACK (fail_stack)) \ ? 0 \ : ((fail_stack).stack[(fail_stack).avail++] = pattern_op, \ 1))
#define REG_MATCH_NULL_STRING_P | ( | R | ) | ((R).bits.match_null_string_p) |
#define REGEX_REALLOCATE | ( | source, | |||
osize, | |||||
nsize | ) |
#define REGEX_TALLOC | ( | n, | |||
t | ) | ((t *) REGEX_ALLOCATE ((n) * sizeof (t))) |
#define REMAINING_AVAIL_SLOTS ((fail_stack).size - (fail_stack).avail) |
#define RETALLOC | ( | addr, | |||
n, | |||||
t | ) | ((addr) = (t *) realloc (addr, (n) * sizeof (t))) |
#define SET_LIST_BIT | ( | c | ) |
#define SET_REGS_MATCHED | ( | ) |
do \ { \ unsigned r; \ for (r = lowest_active_reg; r <= highest_active_reg; r++) \ { \ MATCHED_SOMETHING (reg_info[r]) \ = EVER_MATCHED_SOMETHING (reg_info[r]) \ = 1; \ } \ } \ while (0)
#define SIGN_EXTEND_CHAR | ( | c | ) | ((((unsigned char) (c)) ^ 128) - 128) |
#define STORE_JUMP | ( | op, | |||
loc, | |||||
to | ) | store_op1 (op, loc, (to) - (loc) - 3) |
#define STORE_JUMP2 | ( | op, | |||
loc, | |||||
to, | |||||
arg | ) | store_op2 (op, loc, (to) - (loc) - 3, arg) |
#define STORE_NUMBER | ( | destination, | |||
number | ) |
#define STORE_NUMBER_AND_INCR | ( | destination, | |||
number | ) |
do { \ STORE_NUMBER (destination, number); \ (destination) += 2; \ } while (0)
#define SYNTAX | ( | c | ) | re_syntax_table[c] |
#define TRANSLATE | ( | d | ) | (translate ? translate[(unsigned char) (d)] : (d)) |
#define WORDCHAR_P | ( | d | ) |
typedef const unsigned char* fail_stack_elt_t |
typedef int pattern_offset_t |
enum re_opcode_t |
char* alloca | ( | ) |
static boolean alt_match_null_string_p | ( | unsigned char * | p, | |
unsigned char * | end, | |||
register_info_type * | reg_info | |||
) | [static] |
static boolean alt_match_null_string_p | ( | ) | [static] |
static boolean at_begline_loc_p | ( | char * | pattern, | |
char * | p, | |||
reg_syntax_t | syntax | |||
) | const [static] |
static boolean at_begline_loc_p | ( | ) | [static] |
static boolean at_endline_loc_p | ( | char * | p, | |
char * | pend, | |||
int | syntax | |||
) | const [static] |
static boolean at_endline_loc_p | ( | ) | [static] |
static int bcmp_translate | ( | unsigned char * | s1, | |
unsigned char * | s2, | |||
int | len, | |||
char * | translate | |||
) | [static] |
static int bcmp_translate | ( | ) | [static] |
static boolean common_op_match_null_string_p | ( | unsigned char ** | p, | |
unsigned char * | end, | |||
register_info_type * | reg_info | |||
) | [static] |
static boolean common_op_match_null_string_p | ( | ) | [static] |
static reg_errcode_t compile_range | ( | char ** | p_ptr, | |
char * | pend, | |||
char * | translate, | |||
reg_syntax_t | syntax, | |||
unsigned char * | b | |||
) | const [static] |
static reg_errcode_t compile_range | ( | ) | [static] |
static boolean group_in_compile_stack | ( | compile_stack_type | compile_stack, | |
regnum_t | regnum | |||
) | [static] |
static boolean group_in_compile_stack | ( | ) | [static] |
static boolean group_match_null_string_p | ( | unsigned char ** | p, | |
unsigned char * | end, | |||
register_info_type * | reg_info | |||
) | [static] |
static boolean group_match_null_string_p | ( | ) | [static] |
static void init_syntax_once | ( | ) | [static] |
static void insert_op1 | ( | re_opcode_t | op, | |
unsigned char * | loc, | |||
int | arg, | |||
unsigned char * | end | |||
) | [static] |
static void insert_op1 | ( | ) | [static] |
static void insert_op2 | ( | re_opcode_t | op, | |
unsigned char * | loc, | |||
int | arg1, | |||
int | arg2, | |||
unsigned char * | end | |||
) | [static] |
static void insert_op2 | ( | ) | [static] |
char* malloc | ( | ) |
int re_compile_fastmap | ( | struct re_pattern_buffer * | bufp | ) |
const char* re_compile_pattern | ( | char * | pattern, | |
int | length, | |||
struct re_pattern_buffer * | bufp | |||
) | const |
int re_exec | ( | char * | s | ) | const |
int re_match | ( | struct re_pattern_buffer * | bufp, | |
const char * | string, | |||
int | size, | |||
int | pos, | |||
struct re_registers * | regs | |||
) |
int re_match_2 | ( | struct re_pattern_buffer * | bufp, | |
const char * | string1, | |||
int | size1, | |||
const char * | string2, | |||
int | size2, | |||
int | pos, | |||
struct re_registers * | regs, | |||
int | stop | |||
) |
int re_search | ( | struct re_pattern_buffer * | bufp, | |
const char * | string, | |||
int | size, | |||
int | startpos, | |||
int | range, | |||
struct re_registers * | regs | |||
) |
int re_search_2 | ( | struct re_pattern_buffer * | bufp, | |
const char * | string1, | |||
int | size1, | |||
const char * | string2, | |||
int | size2, | |||
int | startpos, | |||
int | range, | |||
struct re_registers * | regs, | |||
int | stop | |||
) |
void re_set_registers | ( | struct re_pattern_buffer * | bufp, | |
struct re_registers * | regs, | |||
unsigned | num_regs, | |||
regoff_t * | starts, | |||
regoff_t * | ends | |||
) |
reg_syntax_t re_set_syntax | ( | reg_syntax_t | syntax | ) |
char* realloc | ( | ) |
int regcomp | ( | regex_t * | preg, | |
const char * | pattern, | |||
int | cflags | |||
) |
size_t regerror | ( | int | errcode, | |
const regex_t * | preg, | |||
char * | errbuf, | |||
size_t | errbuf_size | |||
) |
static reg_errcode_t regex_compile | ( | char const* | pattern, | |
int | size, | |||
reg_syntax_t | syntax, | |||
struct re_pattern_buffer * | bufp | |||
) | [static] |
int regexec | ( | regex_t * | preg, | |
const char * | string, | |||
size_t | nmatch, | |||
pmatch | , | |||
int | eflags | |||
) | const |
int regexec1 | ( | regex_t * | preg, | |
const char * | string, | |||
int | stringLength, | |||
size_t | nmatch, | |||
pmatch | , | |||
int | eflags | |||
) | const |
void regfree | ( | regex_t * | preg | ) |
static void store_op1 | ( | re_opcode_t | op, | |
unsigned char * | loc, | |||
int | arg | |||
) | [static] |
static void store_op1 | ( | ) | [static] |
static void store_op2 | ( | re_opcode_t | op, | |
unsigned char * | loc, | |||
int | arg1, | |||
int | arg2 | |||
) | [static] |
static void store_op2 | ( | ) | [static] |
struct re_pattern_buffer re_comp_buf [static] |
const char* re_error_msg[] [static] |
{ NULL, "No match", "Invalid regular expression", "Invalid collation character", "Invalid character class name", "Trailing backslash", "Invalid back reference", "Unmatched [ or [^", "Unmatched ( or \\(", "Unmatched \\{", "Invalid content of \\{\\}", "Invalid range end", "Memory exhausted", "Invalid preceding regular expression", "Premature end of regular expression", "Regular expression too big", "Unmatched ) or \\)", }
int re_max_failures = 2000 |
reg_syntax_t re_syntax_options = RE_SYNTAX_EMACS |
char re_syntax_table[CHAR_SET_SIZE] [static] |