get back to glibc regex

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-1
This commit is contained in:
Paolo Bonzini committed 2008-01-09 16:10:41 +01:00
1 parent 016372d25f
commit 87c703bf63
5 files changed
+294 -309

No files matched your search

+13 -15
View File
@@ -867,7 +867,7 @@ init_dfa (dfa, pat_len)
else
for (i = 0, ch = 0; i < BITSET_UINTS; ++i)
for (j = 0; j < UINT_BITS; ++j, ++ch)
if (btowc (ch) != WEOF)
if (__btowc (ch) != WEOF)
dfa->sb_char[i] |= 1 << j;
}
#endif
@@ -2239,22 +2239,20 @@ parse_expression (regexp, preg, token, syntax, nest, err)
dfa->has_mb_node = 1;
break;
case OP_WORD:
tree = build_charclass_op (dfa, regexp->trans, "alnum", "_", 0, err);
if (BE (*err != REG_NOERROR && tree == NULL, 0))
return NULL;
break;
case OP_NOTWORD:
tree = build_charclass_op (dfa, regexp->trans, "alnum", "_", 1, err);
tree = build_charclass_op (dfa, regexp->trans,
(const unsigned char *) "alnum",
(const unsigned char *) "_",
token->type == OP_NOTWORD, err);
if (BE (*err != REG_NOERROR && tree == NULL, 0))
return NULL;
break;
case OP_SPACE:
tree = build_charclass_op (dfa, regexp->trans, "space", "", 0, err);
if (BE (*err != REG_NOERROR && tree == NULL, 0))
return NULL;
break;
case OP_NOTSPACE:
tree = build_charclass_op (dfa, regexp->trans, "space", "", 1, err);
tree = build_charclass_op (dfa, regexp->trans,
(const unsigned char *) "space",
(const unsigned char *) "",
token->type == OP_NOTSPACE, err);
if (BE (*err != REG_NOERROR && tree == NULL, 0))
return NULL;
break;
@@ -2684,7 +2682,7 @@ parse_bracket_exp (regexp, dfa, token, syntax, err)
Seek the collating symbol entry correspondings to NAME.
Return the index of the symbol in the SYMB_TABLE. */
static inline int32_t
auto inline int32_t
__attribute ((always_inline))
seek_collating_symbol_entry (name, name_len)
const unsigned char *name;
@@ -2717,7 +2715,7 @@ parse_bracket_exp (regexp, dfa, token, syntax, err)
Look up the collation sequence value of BR_ELEM.
Return the value if succeeded, UINT_MAX otherwise. */
static inline unsigned int
auto inline unsigned int
__attribute ((always_inline))
lookup_collation_sequence_value (br_elem)
bracket_elem_t *br_elem;
@@ -2785,7 +2783,7 @@ parse_bracket_exp (regexp, dfa, token, syntax, err)
mbcset->range_ends, is a pointer argument sinse we may
update it. */
static inline reg_errcode_t
auto inline reg_errcode_t
__attribute ((always_inline))
build_range_exp (sbcset, mbcset, range_alloc, start_elem, end_elem)
re_charset_t *mbcset;
@@ -2868,7 +2866,7 @@ parse_bracket_exp (regexp, dfa, token, syntax, err)
COLL_SYM_ALLOC is the allocated size of mbcset->coll_sym, is a
pointer argument sinse we may update it. */
static inline reg_errcode_t
auto inline reg_errcode_t
__attribute ((always_inline))
build_collating_symbol (sbcset, mbcset, coll_sym_alloc, name)
re_charset_t *mbcset;
+2 -1
View File
@@ -298,7 +298,8 @@ extern reg_syntax_t re_syntax_options;
/* Like REG_NOTBOL, except for the end-of-line. */
#define REG_NOTEOL (1 << 1)
/* Use pmatch[0] to set boundaries for regexec. */
/* Use PMATCH[0] to delimit the start and end of the search in the
buffer. */
#define REG_STARTEND (1 << 2)
+25 -24
View File
@@ -242,7 +242,7 @@ build_wcs_buffer (pstr)
for (i = 0; i < pstr->mb_cur_max && i < remain_len; ++i)
{
ch = pstr->raw_mbs [pstr->raw_mbs_idx + byte_idx + i];
buf[i] = pstr->trans[ch];
buf[i] = pstr->mbs[byte_idx + i] = pstr->trans[ch];
}
p = (const char *) buf;
}
@@ -373,7 +373,9 @@ build_wcs_upper_buffer (pstr)
{
wchar_t wc;
const char *p;
#ifdef _LIBC
offsets_needed:
#endif
remain_len = end_idx - byte_idx;
prev_st = pstr->cur_state;
if (BE (pstr->trans != NULL, 0))
@@ -398,7 +400,7 @@ offsets_needed:
int mbcdlen;
wcu = towupper (wc);
mbcdlen = wcrtomb (buf, wcu, &prev_st);
mbcdlen = wcrtomb ((char *) buf, wcu, &prev_st);
if (BE (mbclen == mbcdlen, 1))
memcpy (pstr->mbs + byte_idx, buf, mbclen);
else
@@ -579,7 +581,7 @@ re_string_reconstruct (pstr, idx, eflags)
int idx, eflags;
{
int offset = idx - pstr->raw_mbs_idx;
if (BE (offset < 0, 0))
if (offset < 0)
{
/* Reset buffer. */
#ifdef RE_ENABLE_I18N
@@ -599,10 +601,10 @@ re_string_reconstruct (pstr, idx, eflags)
offset = idx;
}
if (BE (offset != 0, 1))
if (offset != 0)
{
/* Are the characters which are already checked remain? */
if (BE (offset < pstr->valid_raw_len, 1)
if (offset < pstr->valid_raw_len
#ifdef RE_ENABLE_I18N
/* Handling this would enlarge the code too much.
Accept a slowdown in that case. */
@@ -613,11 +615,11 @@ re_string_reconstruct (pstr, idx, eflags)
/* Yes, move them to the front of the buffer. */
pstr->tip_context = re_string_context_at (pstr, offset - 1, eflags);
#ifdef RE_ENABLE_I18N
if (BE (pstr->mb_cur_max, 1) > 1)
if (pstr->mb_cur_max > 1)
memmove (pstr->wcs, pstr->wcs + offset,
(pstr->valid_len - offset) * sizeof (wint_t));
#endif /* RE_ENABLE_I18N */
if (BE (pstr->mbs_allocated, 0))
if (pstr->mbs_allocated)
memmove (pstr->mbs, pstr->mbs + offset,
pstr->valid_len - offset);
pstr->valid_len -= offset;
@@ -715,7 +717,7 @@ re_string_reconstruct (pstr, idx, eflags)
? CONTEXT_NEWLINE : 0));
}
}
if (!BE (pstr->mbs_allocated, 0))
if (!pstr->mbs_allocated)
pstr->mbs += offset;
}
pstr->raw_mbs_idx = idx;
@@ -724,7 +726,7 @@ re_string_reconstruct (pstr, idx, eflags)
/* Then build the buffers. */
#ifdef RE_ENABLE_I18N
if (BE (pstr->mb_cur_max, 1) > 1)
if (pstr->mb_cur_max > 1)
{
if (pstr->icase)
{
@@ -737,17 +739,16 @@ re_string_reconstruct (pstr, idx, eflags)
}
else
#endif /* RE_ENABLE_I18N */
if (BE (pstr->mbs_allocated, 0))
{
if (pstr->icase)
build_upper_buffer (pstr);
else if (pstr->trans != NULL)
re_string_translate_buffer (pstr);
else
pstr->valid_len = pstr->len;
}
else
pstr->valid_len = pstr->len;
pstr->cur_idx = 0;
return REG_NOERROR;
}
@@ -845,17 +846,18 @@ re_string_context_at (input, idx, eflags)
int idx, eflags;
{
int c;
if (BE (idx < 0, 0))
/* In this case, we use the value stored in input->tip_context,
since we can't know the character in input->mbs[-1] here. */
return input->tip_context;
else if (BE (idx == input->len, 0))
return ((eflags & REG_NOTEOL) ? CONTEXT_ENDBUF
: CONTEXT_NEWLINE | CONTEXT_ENDBUF);
if (idx < 0 || idx == input->len)
{
if (idx < 0)
/* In this case, we use the value stored in input->tip_context,
since we can't know the character in input->mbs[-1] here. */
return input->tip_context;
else /* (idx == input->len) */
return ((eflags & REG_NOTEOL) ? CONTEXT_ENDBUF
: CONTEXT_NEWLINE | CONTEXT_ENDBUF);
}
#ifdef RE_ENABLE_I18N
else if (BE (input->mb_cur_max, 1) > 1)
if (input->mb_cur_max > 1)
{
wint_t wc;
int wc_idx = idx;
@@ -1648,6 +1650,5 @@ free_state (state)
}
re_node_set_free (&state->nodes);
re_free (state->trtable);
re_free (state->word_trtable);
re_free (state);
}
+12 -25
View File
@@ -96,10 +96,7 @@
# define __wctype wctype
# define __iswctype iswctype
# define __btowc btowc
/* This one is defined by string2.h */
# ifndef __mempcpy
# define __mempcpy mempcpy
# endif
# define __mempcpy mempcpy
# define __wcrtomb wcrtomb
# define attribute_hidden
#endif /* not _LIBC */
@@ -481,7 +478,6 @@ struct re_dfastate_t
re_node_set nodes;
re_node_set *entrance_nodes;
struct re_dfastate_t **trtable;
struct re_dfastate_t **word_trtable;
unsigned int context : 4;
unsigned int halt : 1;
/* If this state can accept `multi byte'.
@@ -491,6 +487,7 @@ struct re_dfastate_t
/* If this state has backreference node(s). */
unsigned int has_backref : 1;
unsigned int has_constraint : 1;
unsigned int word_trtable : 1;
};
typedef struct re_dfastate_t re_dfastate_t;
@@ -711,8 +708,7 @@ typedef struct
/* Inline functions for bitset operation. */
static inline void
bitset_not (set)
bitset set;
bitset_not (bitset set)
{
int bitset_i;
for (bitset_i = 0; bitset_i < BITSET_UINTS; ++bitset_i)
@@ -720,9 +716,7 @@ bitset_not (set)
}
static inline void
bitset_merge (dest, src)
bitset dest;
const bitset src;
bitset_merge (bitset dest, const bitset src)
{
int bitset_i;
for (bitset_i = 0; bitset_i < BITSET_UINTS; ++bitset_i)
@@ -730,9 +724,7 @@ bitset_merge (dest, src)
}
static inline void
bitset_not_merge (dest, src)
bitset dest;
const bitset src;
bitset_not_merge (bitset dest, const bitset src)
{
int i;
for (i = 0; i < BITSET_UINTS; ++i)
@@ -740,9 +732,7 @@ bitset_not_merge (dest, src)
}
static inline void
bitset_mask (dest, src)
bitset dest;
const bitset src;
bitset_mask (bitset dest, const bitset src)
{
int bitset_i;
for (bitset_i = 0; bitset_i < BITSET_UINTS; ++bitset_i)
@@ -752,9 +742,8 @@ bitset_mask (dest, src)
#if defined RE_ENABLE_I18N && !defined RE_NO_INTERNAL_PROTOTYPES
/* Inline functions for re_string. */
static inline int
re_string_char_size_at (pstr, idx)
const re_string_t *pstr;
int idx;
internal_function
re_string_char_size_at (const re_string_t *pstr, int idx)
{
int byte_idx;
if (pstr->mb_cur_max == 1)
@@ -766,9 +755,8 @@ re_string_char_size_at (pstr, idx)
}
static inline wint_t
re_string_wchar_at (pstr, idx)
const re_string_t *pstr;
int idx;
internal_function
re_string_wchar_at (const re_string_t *pstr, int idx)
{
if (pstr->mb_cur_max == 1)
return (wint_t) pstr->mbs[idx];
@@ -776,9 +764,8 @@ re_string_wchar_at (pstr, idx)
}
static int
re_string_elem_size_at (pstr, idx)
const re_string_t *pstr;
int idx;
internal_function
re_string_elem_size_at (const re_string_t *pstr, int idx)
{
#ifdef _LIBC
const unsigned char *p, *extra;
+242 -244
View File
@@ -22,6 +22,8 @@ static reg_errcode_t match_ctx_init (re_match_context_t *cache, int eflags,
int n) internal_function;
static void match_ctx_clean (re_match_context_t *mctx) internal_function;
static void match_ctx_free (re_match_context_t *cache) internal_function;
static void match_ctx_free_subtops (re_match_context_t *mctx)
internal_function;
static reg_errcode_t match_ctx_add_entry (re_match_context_t *cache, int node,
int str_idx, int from, int to)
internal_function;
@@ -55,7 +57,7 @@ static unsigned re_copy_regs (struct re_registers *regs, regmatch_t *pmatch,
int nregs, int regs_allocated) internal_function;
static inline re_dfastate_t *acquire_init_state_context
(reg_errcode_t *err, const re_match_context_t *mctx, int idx)
internal_function;
__attribute ((always_inline)) internal_function;
static reg_errcode_t prune_impossible_nodes (re_match_context_t *mctx)
internal_function;
static int check_matching (re_match_context_t *mctx, int fl_longest_match,
@@ -125,8 +127,7 @@ static re_dfastate_t *find_recover_state (reg_errcode_t *err,
re_match_context_t *mctx) internal_function;
static re_dfastate_t *transit_state (reg_errcode_t *err,
re_match_context_t *mctx,
re_dfastate_t *state)
internal_function;
re_dfastate_t *state) internal_function;
static re_dfastate_t *merge_state_with_log (reg_errcode_t *err,
re_match_context_t *mctx,
re_dfastate_t *next_state) internal_function;
@@ -171,8 +172,8 @@ static reg_errcode_t expand_bkref_cache (re_match_context_t *mctx,
re_node_set *cur_nodes, int cur_str,
int last_str, int subexp_num,
int type) internal_function;
static int build_trtable (re_dfa_t *dfa,
re_dfastate_t *state) internal_function;
static re_dfastate_t **build_trtable (re_dfa_t *dfa,
re_dfastate_t *state) internal_function;
#ifdef RE_ENABLE_I18N
static int check_node_accept_bytes (re_dfa_t *dfa, int node_idx,
const re_string_t *input, int idx) internal_function;
@@ -215,6 +216,10 @@ regexec (preg, string, nmatch, pmatch, eflags)
{
reg_errcode_t err;
int start, length;
if (eflags & ~(REG_NOTBOL | REG_NOTEOL | REG_STARTEND))
return REG_BADPAT;
if (eflags & REG_STARTEND)
{
start = pmatch[0].rm_so;
@@ -233,8 +238,25 @@ regexec (preg, string, nmatch, pmatch, eflags)
length, nmatch, pmatch, eflags);
return err != REG_NOERROR;
}
#ifdef _LIBC
weak_alias (__regexec, regexec)
# include <shlib-compat.h>
versioned_symbol (libc, __regexec, regexec, GLIBC_2_3_4);
# if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_3_4)
__typeof__ (__regexec) __compat_regexec;
int
attribute_compat_text_section
__compat_regexec (const regex_t *__restrict preg,
const char *__restrict string, size_t nmatch,
regmatch_t pmatch[], int eflags)
{
return regexec (preg, string, nmatch, pmatch,
eflags & (REG_NOTBOL | REG_NOTEOL));
}
compat_symbol (libc, __compat_regexec, regexec, GLIBC_2_0);
# endif
#endif
/* Entry points for GNU code. */
@@ -581,16 +603,15 @@ re_search_internal (preg, string, length, start, range, stop, nmatch, pmatch,
reg_errcode_t err;
re_dfa_t *dfa = (re_dfa_t *)preg->buffer;
int left_lim, right_lim, incr;
int fl_longest_match, match_first, match_kind, match_last = -1;
int fast_translate, sb, ch;
int fl_longest_match, match_first, match_last = -1;
int fast_translate, sb;
#if defined _LIBC || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L)
re_match_context_t mctx = { .dfa = dfa };
#else
re_match_context_t mctx;
#endif
char *fastmap = (preg->fastmap != NULL && preg->fastmap_accurate
&& range && !preg->can_be_null) ? preg->fastmap : NULL;
unsigned RE_TRANSLATE_TYPE t = (unsigned RE_TRANSLATE_TYPE) preg->translate;
char *fastmap = ((preg->fastmap != NULL && preg->fastmap_accurate
&& range && !preg->can_be_null) ? preg->fastmap : NULL);
#if !(defined _LIBC || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L))
memset (&mctx, '\0', sizeof (re_match_context_t));
@@ -663,100 +684,88 @@ re_search_internal (preg, string, length, start, range, stop, nmatch, pmatch,
left_lim = (range < 0) ? start + range : start;
right_lim = (range < 0) ? start : start + range;
sb = dfa->mb_cur_max == 1;
match_kind =
(fastmap ? 8 : 0)
| (sb || !(preg->syntax & RE_ICASE || t) ? 4 : 0)
| (range >= 0 ? 2 : 0)
| (t != NULL ? 1 : 0);
fast_translate = sb || !(preg->syntax & RE_ICASE || preg->translate);
for (;; match_first += incr)
for (;;)
{
err = REG_NOMATCH;
if (match_first < left_lim || right_lim < match_first)
goto free_return;
/* Advance as rapidly as possible through the string, until we
find a plausible place to start matching. This may be done
with varying efficiency, so there are various possibilities:
only the most common of them are specialized to save code.
We use a switch statement for speed. */
switch (match_kind)
/* At first get the current byte from input string. */
if (fastmap)
{
case 0: case 1: case 2: case 3:
case 4: case 5: case 6: case 7:
/* No fastmap. */
break;
case 15:
/* Fastmap with single-byte translation, match forward. */
while (BE (match_first < right_lim, 1)
&& !fastmap[t[(unsigned char) string[match_first]]])
++match_first;
goto forward_match_found_start_or_reached_end;
case 14:
/* Fastmap without translation, match forward. */
while (BE (match_first < right_lim, 1)
&& !fastmap[(unsigned char) string[match_first]])
++match_first;
forward_match_found_start_or_reached_end:
if (BE (match_first == right_lim, 0))
if (BE (fast_translate, 1))
{
ch = match_first >= length
? 0 : (unsigned char) string[match_first];
if (!fastmap[t ? t[ch] : ch])
goto free_return;
}
break;
case 12:
case 13:
/* Fastmap without multi-byte translation, match backwards. */
while (match_first >= left_lim)
{
ch = match_first >= length
? 0 : (unsigned char) string[match_first];
if (fastmap[t ? t[ch] : ch])
break;
--match_first;
}
if (match_first < left_lim)
goto free_return;
break;
default:
/* In this case, we can't determine easily the current byte,
since it might be a component byte of a multibyte
character. Then we use the constructed buffer instead. */
do
{
/* If MATCH_FIRST is out of the valid range, reconstruct the
buffers. */
if (mctx.input.raw_mbs_idx + mctx.input.valid_raw_len <= match_first
|| match_first < mctx.input.raw_mbs_idx)
unsigned RE_TRANSLATE_TYPE t
= (unsigned RE_TRANSLATE_TYPE) preg->translate;
if (BE (range >= 0, 1))
{
err = re_string_reconstruct (&mctx.input, match_first,
eflags);
if (BE (err != REG_NOERROR, 0))
goto free_return;
if (BE (t != NULL, 0))
{
while (BE (match_first < right_lim, 1)
&& !fastmap[t[(unsigned char) string[match_first]]])
++match_first;
}
else
{
while (BE (match_first < right_lim, 1)
&& !fastmap[(unsigned char) string[match_first]])
++match_first;
}
if (BE (match_first == right_lim, 0))
{
int ch = match_first >= length
? 0 : (unsigned char) string[match_first];
if (!fastmap[t ? t[ch] : ch])
break;
}
}
else
{
while (match_first >= left_lim)
{
int ch = match_first >= length
? 0 : (unsigned char) string[match_first];
if (fastmap[t ? t[ch] : ch])
break;
--match_first;
}
if (match_first < left_lim)
break;
}
/* If MATCH_FIRST is out of the buffer, leave it as '\0'.
Note that MATCH_FIRST must not be smaller than 0. */
ch = ((match_first >= length) ? 0
: re_string_byte_at (&mctx.input,
match_first - mctx.input.raw_mbs_idx));
if (fastmap[ch])
break;
match_first += incr;
}
while (match_first >= left_lim && match_first <= right_lim);
if (!fastmap[ch])
else
{
err = REG_NOMATCH;
goto free_return;
int ch;
do
{
/* In this case, we can't determine easily the current byte,
since it might be a component byte of a multibyte
character. Then we use the constructed buffer
instead. */
/* If MATCH_FIRST is out of the valid range, reconstruct the
buffers. */
if (mctx.input.raw_mbs_idx + mctx.input.valid_raw_len
<= match_first
|| match_first < mctx.input.raw_mbs_idx)
{
err = re_string_reconstruct (&mctx.input, match_first,
eflags);
if (BE (err != REG_NOERROR, 0))
goto free_return;
}
/* If MATCH_FIRST is out of the buffer, leave it as '\0'.
Note that MATCH_FIRST must not be smaller than 0. */
ch = ((match_first >= length) ? 0
: re_string_byte_at (&mctx.input,
match_first
- mctx.input.raw_mbs_idx));
if (fastmap[ch])
break;
match_first += incr;
}
while (match_first >= left_lim && match_first <= right_lim);
if (! fastmap[ch])
break;
}
break;
}
/* Reconstruct the buffers so that the matcher can assume that
@@ -764,60 +773,57 @@ re_search_internal (preg, string, length, start, range, stop, nmatch, pmatch,
err = re_string_reconstruct (&mctx.input, match_first, eflags);
if (BE (err != REG_NOERROR, 0))
goto free_return;
#ifdef RE_ENABLE_I18N
/* Don't consider this char as a possible match start if it part,
yet isn't the head, of a multibyte character. */
if (!sb && !re_string_first_byte (&mctx.input, 0))
continue;
/* Eliminate it when it is a component of a multibyte character
and isn't the head of a multibyte character. */
if (sb || re_string_first_byte (&mctx.input, 0))
#endif
/* It seems to be appropriate one, then use the matcher. */
/* We assume that the matching starts from 0. */
mctx.state_log_top = mctx.nbkref_ents = mctx.max_mb_elem_len = 0;
match_last = check_matching (&mctx, fl_longest_match,
range >= 0 ? &match_first : NULL);
if (match_last != -1)
{
if (BE (match_last == -2, 0))
/* It seems to be appropriate one, then use the matcher. */
/* We assume that the matching starts from 0. */
mctx.state_log_top = mctx.nbkref_ents = mctx.max_mb_elem_len = 0;
match_last = check_matching (&mctx, fl_longest_match,
range >= 0 ? &match_first : NULL);
if (match_last != -1)
{
err = REG_ESPACE;
goto free_return;
}
else
{
mctx.match_last = match_last;
if ((!preg->no_sub && nmatch > 1) || dfa->nbackref)
if (BE (match_last == -2, 0))
{
re_dfastate_t *pstate = mctx.state_log[match_last];
mctx.last_node = check_halt_state_context (&mctx, pstate,
match_last);
}
if ((!preg->no_sub && nmatch > 1 && dfa->has_plural_match)
|| dfa->nbackref)
{
err = prune_impossible_nodes (&mctx);
if (err == REG_NOERROR)
break;
if (BE (err != REG_NOMATCH, 0))
goto free_return;
match_last = -1;
err = REG_ESPACE;
goto free_return;
}
else
break; /* We found a match. */
{
mctx.match_last = match_last;
if ((!preg->no_sub && nmatch > 1) || dfa->nbackref)
{
re_dfastate_t *pstate = mctx.state_log[match_last];
mctx.last_node = check_halt_state_context (&mctx, pstate,
match_last);
}
if ((!preg->no_sub && nmatch > 1 && dfa->has_plural_match)
|| dfa->nbackref)
{
err = prune_impossible_nodes (&mctx);
if (err == REG_NOERROR)
break;
if (BE (err != REG_NOMATCH, 0))
goto free_return;
match_last = -1;
}
else
break; /* We found a match. */
}
}
match_ctx_clean (&mctx);
}
match_ctx_clean (&mctx);
/* Update counter. */
match_first += incr;
if (match_first < left_lim || right_lim < match_first)
break;
}
#ifdef DEBUG
assert (match_last != -1);
assert (err == REG_NOERROR);
#endif
/* Set pmatch[] if we need. */
if (nmatch > 0)
if (match_last != -1 && nmatch > 0)
{
int reg_idx;
@@ -862,7 +868,7 @@ re_search_internal (preg, string, length, start, range, stop, nmatch, pmatch,
pmatch[reg_idx].rm_eo += match_first;
}
}
err = (match_last == -1) ? REG_NOMATCH : REG_NOERROR;
free_return:
re_free (mctx.state_log);
if (dfa->nbackref)
@@ -1067,20 +1073,6 @@ check_matching (mctx, fl_longest_match, p_match_first)
while (!re_string_eoi (&mctx->input))
{
re_dfastate_t *old_state = cur_state;
int next_char_idx = re_string_cur_idx (&mctx->input) + 1;
if (BE (next_char_idx >= mctx->input.bufs_len, 0)
|| (BE (next_char_idx >= mctx->input.valid_len, 0)
&& mctx->input.valid_len < mctx->input.len))
{
err = extend_buffers (mctx);
if (BE (err != REG_NOERROR, 0))
{
assert (err == REG_ESPACE);
return -2;
}
}
cur_state = transit_state (&err, mctx, cur_state);
if (mctx->state_log != NULL)
cur_state = merge_state_with_log (&err, mctx, cur_state);
@@ -1099,10 +1091,10 @@ check_matching (mctx, fl_longest_match, p_match_first)
break;
}
if (BE (at_init_state, 0))
if (at_init_state)
{
if (old_state == cur_state)
next_start_idx = next_char_idx;
next_start_idx = re_string_cur_idx (&mctx->input);
else
at_init_state = 0;
}
@@ -1118,16 +1110,13 @@ check_matching (mctx, fl_longest_match, p_match_first)
/* We found an appropriate halt state. */
match_last = re_string_cur_idx (&mctx->input);
match = 1;
/* We found a match, do not modify match_first below. */
p_match_first = NULL;
if (!fl_longest_match)
break;
}
}
}
}
if (p_match_first)
if (match_last == -1 && p_match_first)
*p_match_first += next_start_idx;
return match_last;
@@ -2179,50 +2168,58 @@ transit_state (err, mctx, state)
re_match_context_t *mctx;
re_dfastate_t *state;
{
re_dfastate_t **trtable, *next_state;
re_dfa_t *const dfa = mctx->dfa;
re_dfastate_t **trtable;
unsigned char ch;
#ifdef RE_ENABLE_I18N
/* If the current state can accept multibyte. */
if (BE (state->accept_mb, 0))
if (re_string_cur_idx (&mctx->input) + 1 >= mctx->input.bufs_len
|| (re_string_cur_idx (&mctx->input) + 1 >= mctx->input.valid_len
&& mctx->input.valid_len < mctx->input.len))
{
*err = transit_state_mb (mctx, state);
*err = extend_buffers (mctx);
if (BE (*err != REG_NOERROR, 0))
return NULL;
return NULL;
}
#ifdef RE_ENABLE_I18N
/* If the current state can accept multibyte. */
if (state->accept_mb)
{
*err = transit_state_mb (mctx, state);
if (BE (*err != REG_NOERROR, 0))
return NULL;
}
#endif /* RE_ENABLE_I18N */
/* Then decide the next state with the single byte. */
if (1)
{
/* Use transition table. Sorry for the goto, but we really need
to squeeze every single instruction here. */
/* Use transition table */
ch = re_string_fetch_byte (&mctx->input);
retry:
trtable = state->trtable;
if (BE (trtable != NULL, 1))
return trtable[ch];
trtable = state->word_trtable;
if (BE (trtable != NULL, 1))
{
unsigned int context;
context = re_string_context_at (&mctx->input,
re_string_cur_idx (&mctx->input) - 1,
mctx->eflags);
if (IS_WORD_CONTEXT (context))
if (trtable == NULL)
{
trtable = build_trtable (dfa, state);
if (trtable == NULL)
{
*err = REG_ESPACE;
return NULL;
}
}
if (BE (state->word_trtable, 0))
{
unsigned int context;
context
= re_string_context_at (&mctx->input,
re_string_cur_idx (&mctx->input) - 1,
mctx->eflags);
if (IS_WORD_CONTEXT (context))
return trtable[ch + SBC_MAX];
else
else
return trtable[ch];
}
if (!build_trtable (mctx->dfa, state))
{
*err = REG_ESPACE;
return NULL;
}
goto retry;
else
return trtable[ch];
}
#if 0
else
@@ -2231,7 +2228,7 @@ transit_state (err, mctx, state)
#endif
}
/* Update the state_log if we need. */
/* Update the state_log if we need */
re_dfastate_t *
merge_state_with_log (err, mctx, next_state)
reg_errcode_t *err;
@@ -2240,6 +2237,7 @@ merge_state_with_log (err, mctx, next_state)
{
re_dfa_t *const dfa = mctx->dfa;
int cur_idx = re_string_cur_idx (&mctx->input);
if (cur_idx > mctx->state_log_top)
{
mctx->state_log[cur_idx] = next_state;
@@ -2255,36 +2253,34 @@ merge_state_with_log (err, mctx, next_state)
unsigned int context;
re_node_set next_nodes, *log_nodes, *table_nodes = NULL;
/* If (state_log[cur_idx] != 0), it implies that cur_idx is
the destination of a multibyte char/collating element/
back reference. Then the next state is the union set of
these destinations and the results of the transition table. */
the destination of a multibyte char/collating element/
back reference. Then the next state is the union set of
these destinations and the results of the transition table. */
pstate = mctx->state_log[cur_idx];
log_nodes = pstate->entrance_nodes;
if (next_state != NULL)
{
table_nodes = next_state->entrance_nodes;
*err = re_node_set_init_union (&next_nodes, table_nodes,
log_nodes);
if (BE (*err != REG_NOERROR, 0))
return;
}
table_nodes = next_state->entrance_nodes;
*err = re_node_set_init_union (&next_nodes, table_nodes,
log_nodes);
if (BE (*err != REG_NOERROR, 0))
return NULL;
}
else
next_nodes = *log_nodes;
next_nodes = *log_nodes;
/* Note: We already add the nodes of the initial state,
then we don't need to add them here. */
then we don't need to add them here. */
context = re_string_context_at (&mctx->input,
re_string_cur_idx (&mctx->input) - 1,
mctx->eflags);
next_state = mctx->state_log[cur_idx]
= re_acquire_state_context (err, dfa, &next_nodes, context);
= re_acquire_state_context (err, dfa, &next_nodes, context);
/* We don't need to check errors here, since the return value of
this function is next_state and ERR is already set. */
this function is next_state and ERR is already set. */
if (table_nodes != NULL)
re_node_set_free (&next_nodes);
re_node_set_free (&next_nodes);
}
if (BE (dfa->nbackref, 0) && next_state != NULL)
@@ -3232,7 +3228,7 @@ expand_bkref_cache (mctx, cur_nodes, cur_str, last_str, subexp_num,
/* Build transition table for the state.
Return the new table if succeeded, otherwise return NULL. */
static int
static re_dfastate_t **
build_trtable (dfa, state)
re_dfa_t *dfa;
re_dfastate_t *state;
@@ -3242,7 +3238,6 @@ build_trtable (dfa, state)
unsigned int elem, mask;
int dests_node_malloced = 0, dest_states_malloced = 0;
int ndests; /* Number of the destination states from `state'. */
int need_word_trtable = 0;
re_dfastate_t **trtable;
re_dfastate_t **dest_states = NULL, **dest_states_word, **dest_states_nl;
re_node_set follows, *dests_node;
@@ -3263,11 +3258,14 @@ build_trtable (dfa, state)
dests_node = (re_node_set *)
malloc ((sizeof (re_node_set) + sizeof (bitset)) * SBC_MAX);
if (BE (dests_node == NULL, 0))
return 0;
return NULL;
dests_node_malloced = 1;
}
dests_ch = (bitset *) (dests_node + SBC_MAX);
/* Initialize transiton table. */
state->word_trtable = 0;
/* At first, group all nodes belonging to `state' into several
destinations. */
ndests = group_nodes_into_DFAstates (dfa, state, dests_node, dests_ch);
@@ -3275,12 +3273,14 @@ build_trtable (dfa, state)
{
if (dests_node_malloced)
free (dests_node);
/* Return NULL in case of an error, trtable otherwise. */
if (ndests == 0)
state->trtable = (re_dfastate_t **)
calloc (sizeof (re_dfastate_t *), SBC_MAX);;
/* Return 0 in case of an error, 1 otherwise. */
return state->trtable != NULL;
{
state->trtable = (re_dfastate_t **)
calloc (sizeof (re_dfastate_t *), SBC_MAX);;
return state->trtable;
}
return NULL;
}
err = re_node_set_alloc (&follows, ndests + 1);
@@ -3307,7 +3307,7 @@ out_free:
re_node_set_free (dests_node + i);
if (dests_node_malloced)
free (dests_node);
return 0;
return NULL;
}
dest_states_malloced = 1;
}
@@ -3343,11 +3343,9 @@ out_free:
if (BE (dest_states_word[i] == NULL && err != REG_NOERROR, 0))
goto out_free;
#ifdef RE_ENABLE_I18N
if (dest_states[i] != dest_states_word[i]
&& dfa->mb_cur_max > 1)
need_word_trtable = 1;
#endif
state->word_trtable = 1;
dest_states_nl[i] = re_acquire_state_context (&err, dfa, &follows,
CONTEXT_NEWLINE);
@@ -3362,7 +3360,7 @@ out_free:
bitset_merge (acceptable, dests_ch[i]);
}
if (!BE (need_word_trtable, 0))
if (!BE (state->word_trtable, 0))
{
/* We don't care about whether the following character is a word
character, or we are in a single-byte character set so we can
@@ -3391,7 +3389,6 @@ out_free:
trtable[ch] = dest_states[j];
}
}
#ifdef RE_ENABLE_I18N
else
{
/* We care about whether the following character is a word
@@ -3421,7 +3418,6 @@ out_free:
trtable[ch + SBC_MAX] = dest_states_word[j];
}
}
#endif
/* new line */
if (bitset_contain (acceptable, NEWLINE_CHAR))
@@ -3432,7 +3428,7 @@ out_free:
{
/* k-th destination accepts newline character. */
trtable[NEWLINE_CHAR] = dest_states_nl[j];
if (need_word_trtable)
if (state->word_trtable)
trtable[NEWLINE_CHAR + SBC_MAX] = dest_states_nl[j];
/* There must be only one destination which accepts
newline. See group_nodes_into_DFAstates. */
@@ -3450,12 +3446,8 @@ out_free:
if (dests_node_malloced)
free (dests_node);
if (need_word_trtable)
state->word_trtable = trtable;
else
state->trtable = trtable;
return 1;
state->trtable = trtable;
return trtable;
}
/* Group all nodes belonging to STATE into several destinations.
@@ -4086,6 +4078,28 @@ match_ctx_init (mctx, eflags, n)
static void
match_ctx_clean (mctx)
re_match_context_t *mctx;
{
match_ctx_free_subtops (mctx);
mctx->nsub_tops = 0;
mctx->nbkref_ents = 0;
}
/* Free all the memory associated with MCTX. */
static void
match_ctx_free (mctx)
re_match_context_t *mctx;
{
match_ctx_free_subtops (mctx);
re_free (mctx->sub_tops);
re_free (mctx->bkref_ents);
}
/* Free all the memory associated with MCTX->SUB_TOPS. */
static void
match_ctx_free_subtops (mctx)
re_match_context_t *mctx;
{
int st_idx;
for (st_idx = 0; st_idx < mctx->nsub_tops; ++st_idx)
@@ -4106,24 +4120,8 @@ match_ctx_clean (mctx)
}
free (top);
}
mctx->nsub_tops = 0;
mctx->nbkref_ents = 0;
}
/* Free all the memory associated with MCTX. */
static void
match_ctx_free (mctx)
re_match_context_t *mctx;
{
/* First, free all the memory associated with MCTX->SUB_TOPS. */
match_ctx_clean (mctx);
re_free (mctx->sub_tops);
re_free (mctx->bkref_ents);
}
/* Add a new backreference entry to MCTX.
Note that we assume that caller never call this function with duplicate
entry, and call with STR_IDX which isn't smaller than any existing entry.