mirror of
https://sourceware.org/git/glibc.git
synced 2025-07-29 11:41:21 +03:00
Fix a few more cases of ignored return values in regex.
This commit is contained in:
Ulrich Drepper
156
posix/regexec.c
156
posix/regexec.c
@ -1,5 +1,5 @@
|
||||
/* Extended regular expression matching and search library.
|
||||
Copyright (C) 2002, 2003, 2004, 2005, 2007, 2009 Free Software Foundation, Inc.
|
||||
Copyright (C) 2002-2005, 2007, 2009, 2010 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>.
|
||||
|
||||
@ -617,6 +617,7 @@ re_exec (s)
|
||||
(START + RANGE >= 0 && START + RANGE <= LENGTH) */
|
||||
|
||||
static reg_errcode_t
|
||||
__attribute_warn_unused_result__
|
||||
re_search_internal (preg, string, length, start, range, stop, nmatch, pmatch,
|
||||
eflags)
|
||||
const regex_t *preg;
|
||||
@ -668,7 +669,7 @@ re_search_internal (preg, string, length, start, range, stop, nmatch, pmatch,
|
||||
|| !preg->newline_anchor))
|
||||
{
|
||||
if (start != 0 && start + range != 0)
|
||||
return REG_NOMATCH;
|
||||
return REG_NOMATCH;
|
||||
start = range = 0;
|
||||
}
|
||||
|
||||
@ -800,10 +801,10 @@ re_search_internal (preg, string, length, start, range, stop, nmatch, pmatch,
|
||||
break;
|
||||
match_first += incr;
|
||||
if (match_first < left_lim || match_first > right_lim)
|
||||
{
|
||||
err = REG_NOMATCH;
|
||||
goto free_return;
|
||||
}
|
||||
{
|
||||
err = REG_NOMATCH;
|
||||
goto free_return;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
@ -917,14 +918,14 @@ re_search_internal (preg, string, length, start, range, stop, nmatch, pmatch,
|
||||
}
|
||||
|
||||
if (dfa->subexp_map)
|
||||
for (reg_idx = 0; reg_idx + 1 < nmatch; reg_idx++)
|
||||
if (dfa->subexp_map[reg_idx] != reg_idx)
|
||||
{
|
||||
pmatch[reg_idx + 1].rm_so
|
||||
= pmatch[dfa->subexp_map[reg_idx] + 1].rm_so;
|
||||
pmatch[reg_idx + 1].rm_eo
|
||||
= pmatch[dfa->subexp_map[reg_idx] + 1].rm_eo;
|
||||
}
|
||||
for (reg_idx = 0; reg_idx + 1 < nmatch; reg_idx++)
|
||||
if (dfa->subexp_map[reg_idx] != reg_idx)
|
||||
{
|
||||
pmatch[reg_idx + 1].rm_so
|
||||
= pmatch[dfa->subexp_map[reg_idx] + 1].rm_so;
|
||||
pmatch[reg_idx + 1].rm_eo
|
||||
= pmatch[dfa->subexp_map[reg_idx] + 1].rm_eo;
|
||||
}
|
||||
}
|
||||
|
||||
free_return:
|
||||
@ -936,6 +937,7 @@ re_search_internal (preg, string, length, start, range, stop, nmatch, pmatch,
|
||||
}
|
||||
|
||||
static reg_errcode_t
|
||||
__attribute_warn_unused_result__
|
||||
prune_impossible_nodes (mctx)
|
||||
re_match_context_t *mctx;
|
||||
{
|
||||
@ -1069,7 +1071,7 @@ acquire_init_state_context (reg_errcode_t *err, const re_match_context_t *mctx,
|
||||
index of the buffer. */
|
||||
|
||||
static int
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
check_matching (re_match_context_t *mctx, int fl_longest_match,
|
||||
int *p_match_first)
|
||||
{
|
||||
@ -1108,7 +1110,7 @@ check_matching (re_match_context_t *mctx, int fl_longest_match,
|
||||
{
|
||||
err = transit_state_bkref (mctx, &cur_state->nodes);
|
||||
if (BE (err != REG_NOERROR, 0))
|
||||
return err;
|
||||
return err;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1135,16 +1137,16 @@ check_matching (re_match_context_t *mctx, int fl_longest_match,
|
||||
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))
|
||||
|| (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)
|
||||
@ -1263,20 +1265,20 @@ proceed_next_node (const re_match_context_t *mctx, int nregs, regmatch_t *regs,
|
||||
int candidate = edests->elems[i];
|
||||
if (!re_node_set_contains (cur_nodes, candidate))
|
||||
continue;
|
||||
if (dest_node == -1)
|
||||
if (dest_node == -1)
|
||||
dest_node = candidate;
|
||||
|
||||
else
|
||||
else
|
||||
{
|
||||
/* In order to avoid infinite loop like "(a*)*", return the second
|
||||
epsilon-transition if the first was already considered. */
|
||||
epsilon-transition if the first was already considered. */
|
||||
if (re_node_set_contains (eps_via_nodes, dest_node))
|
||||
return candidate;
|
||||
return candidate;
|
||||
|
||||
/* Otherwise, push the second epsilon-transition on the fail stack. */
|
||||
else if (fs != NULL
|
||||
&& push_fail_stack (fs, *pidx, candidate, nregs, regs,
|
||||
eps_via_nodes))
|
||||
eps_via_nodes))
|
||||
return -2;
|
||||
|
||||
/* We know we are going to exit. */
|
||||
@ -1342,7 +1344,7 @@ proceed_next_node (const re_match_context_t *mctx, int nregs, regmatch_t *regs,
|
||||
}
|
||||
|
||||
static reg_errcode_t
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
push_fail_stack (struct re_fail_stack_t *fs, int str_idx, int dest_node,
|
||||
int nregs, regmatch_t *regs, re_node_set *eps_via_nodes)
|
||||
{
|
||||
@ -1389,7 +1391,7 @@ pop_fail_stack (struct re_fail_stack_t *fs, int *pidx, int nregs,
|
||||
pmatch[i].rm_so == pmatch[i].rm_eo == -1 for 0 < i < nmatch. */
|
||||
|
||||
static reg_errcode_t
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
set_regs (const regex_t *preg, const re_match_context_t *mctx, size_t nmatch,
|
||||
regmatch_t *pmatch, int fl_backtrack)
|
||||
{
|
||||
@ -1624,7 +1626,7 @@ sift_states_backward (const re_match_context_t *mctx, re_sift_context_t *sctx)
|
||||
if (mctx->state_log[str_idx])
|
||||
{
|
||||
err = build_sifted_states (mctx, sctx, str_idx, &cur_dest);
|
||||
if (BE (err != REG_NOERROR, 0))
|
||||
if (BE (err != REG_NOERROR, 0))
|
||||
goto free_return;
|
||||
}
|
||||
|
||||
@ -1643,7 +1645,7 @@ sift_states_backward (const re_match_context_t *mctx, re_sift_context_t *sctx)
|
||||
}
|
||||
|
||||
static reg_errcode_t
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
build_sifted_states (const re_match_context_t *mctx, re_sift_context_t *sctx,
|
||||
int str_idx, re_node_set *cur_dest)
|
||||
{
|
||||
@ -1805,7 +1807,7 @@ update_cur_sifted_state (const re_match_context_t *mctx,
|
||||
}
|
||||
|
||||
static reg_errcode_t
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
add_epsilon_src_nodes (const re_dfa_t *dfa, re_node_set *dest_nodes,
|
||||
const re_node_set *candidates)
|
||||
{
|
||||
@ -1820,10 +1822,14 @@ add_epsilon_src_nodes (const re_dfa_t *dfa, re_node_set *dest_nodes,
|
||||
{
|
||||
err = re_node_set_alloc (&state->inveclosure, dest_nodes->nelem);
|
||||
if (BE (err != REG_NOERROR, 0))
|
||||
return REG_ESPACE;
|
||||
return REG_ESPACE;
|
||||
for (i = 0; i < dest_nodes->nelem; i++)
|
||||
re_node_set_merge (&state->inveclosure,
|
||||
dfa->inveclosures + dest_nodes->elems[i]);
|
||||
{
|
||||
err = re_node_set_merge (&state->inveclosure,
|
||||
dfa->inveclosures + dest_nodes->elems[i]);
|
||||
if (BE (err != REG_NOERROR, 0))
|
||||
return REG_ESPACE;
|
||||
}
|
||||
}
|
||||
return re_node_set_add_intersect (dest_nodes, candidates,
|
||||
&state->inveclosure);
|
||||
@ -1935,7 +1941,7 @@ check_dst_limits_calc_pos_1 (const re_match_context_t *mctx, int boundaries,
|
||||
{
|
||||
struct re_backref_cache_entry *ent = mctx->bkref_ents + bkref_idx;
|
||||
do
|
||||
{
|
||||
{
|
||||
int dst, cpos;
|
||||
|
||||
if (ent->node != node)
|
||||
@ -1956,9 +1962,9 @@ check_dst_limits_calc_pos_1 (const re_match_context_t *mctx, int boundaries,
|
||||
if (dst == from_node)
|
||||
{
|
||||
if (boundaries & 1)
|
||||
return -1;
|
||||
return -1;
|
||||
else /* if (boundaries & 2) */
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
cpos =
|
||||
@ -1972,7 +1978,7 @@ check_dst_limits_calc_pos_1 (const re_match_context_t *mctx, int boundaries,
|
||||
if (subexp_idx < BITSET_WORD_BITS)
|
||||
ent->eps_reachable_subexps_map
|
||||
&= ~((bitset_word_t) 1 << subexp_idx);
|
||||
}
|
||||
}
|
||||
while (ent++->more);
|
||||
}
|
||||
break;
|
||||
@ -2114,7 +2120,7 @@ check_subexp_limits (const re_dfa_t *dfa, re_node_set *dest_nodes,
|
||||
}
|
||||
|
||||
static reg_errcode_t
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
sift_states_bkref (const re_match_context_t *mctx, re_sift_context_t *sctx,
|
||||
int str_idx, const re_node_set *candidates)
|
||||
{
|
||||
@ -2197,7 +2203,7 @@ sift_states_bkref (const re_match_context_t *mctx, re_sift_context_t *sctx,
|
||||
re_node_set_remove (&local_sctx.limits, enabled_idx);
|
||||
|
||||
/* mctx->bkref_ents may have changed, reload the pointer. */
|
||||
entry = mctx->bkref_ents + enabled_idx;
|
||||
entry = mctx->bkref_ents + enabled_idx;
|
||||
}
|
||||
while (enabled_idx++, entry++->more);
|
||||
}
|
||||
@ -2244,7 +2250,7 @@ sift_states_iter_mb (const re_match_context_t *mctx, re_sift_context_t *sctx,
|
||||
update the destination of STATE_LOG. */
|
||||
|
||||
static re_dfastate_t *
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
transit_state (reg_errcode_t *err, re_match_context_t *mctx,
|
||||
re_dfastate_t *state)
|
||||
{
|
||||
@ -2278,7 +2284,7 @@ transit_state (reg_errcode_t *err, re_match_context_t *mctx,
|
||||
|
||||
trtable = state->word_trtable;
|
||||
if (BE (trtable != NULL, 1))
|
||||
{
|
||||
{
|
||||
unsigned int context;
|
||||
context
|
||||
= re_string_context_at (&mctx->input,
|
||||
@ -2324,21 +2330,21 @@ merge_state_with_log (reg_errcode_t *err, re_match_context_t *mctx,
|
||||
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,
|
||||
{
|
||||
table_nodes = next_state->entrance_nodes;
|
||||
*err = re_node_set_init_union (&next_nodes, table_nodes,
|
||||
log_nodes);
|
||||
if (BE (*err != REG_NOERROR, 0))
|
||||
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. */
|
||||
|
||||
@ -2346,12 +2352,12 @@ merge_state_with_log (reg_errcode_t *err, re_match_context_t *mctx,
|
||||
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)
|
||||
@ -2392,9 +2398,9 @@ find_recover_state (reg_errcode_t *err, re_match_context_t *mctx)
|
||||
|
||||
do
|
||||
{
|
||||
if (++cur_str_idx > max)
|
||||
return NULL;
|
||||
re_string_skip_bytes (&mctx->input, 1);
|
||||
if (++cur_str_idx > max)
|
||||
return NULL;
|
||||
re_string_skip_bytes (&mctx->input, 1);
|
||||
}
|
||||
while (mctx->state_log[cur_str_idx] == NULL);
|
||||
|
||||
@ -2501,7 +2507,7 @@ transit_state_mb (re_match_context_t *mctx, re_dfastate_t *pstate)
|
||||
re_dfastate_t *dest_state;
|
||||
|
||||
if (!dfa->nodes[cur_node_idx].accept_mb)
|
||||
continue;
|
||||
continue;
|
||||
|
||||
if (dfa->nodes[cur_node_idx].constraint)
|
||||
{
|
||||
@ -2669,7 +2675,7 @@ transit_state_bkref (re_match_context_t *mctx, const re_node_set *nodes)
|
||||
delay these checking for prune_impossible_nodes(). */
|
||||
|
||||
static reg_errcode_t
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
get_subexp (re_match_context_t *mctx, int bkref_node, int bkref_str_idx)
|
||||
{
|
||||
const re_dfa_t *const dfa = mctx->dfa;
|
||||
@ -2682,7 +2688,7 @@ get_subexp (re_match_context_t *mctx, int bkref_node, int bkref_str_idx)
|
||||
const struct re_backref_cache_entry *entry
|
||||
= mctx->bkref_ents + cache_idx;
|
||||
do
|
||||
if (entry->node == bkref_node)
|
||||
if (entry->node == bkref_node)
|
||||
return REG_NOERROR; /* We already checked it. */
|
||||
while (entry++->more);
|
||||
}
|
||||
@ -2869,7 +2875,7 @@ find_subexp_node (const re_dfa_t *dfa, const re_node_set *nodes,
|
||||
Return REG_NOERROR if it can arrive, or REG_NOMATCH otherwise. */
|
||||
|
||||
static reg_errcode_t
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
check_arrival (re_match_context_t *mctx, state_array_t *path, int top_node,
|
||||
int top_str, int last_node, int last_str, int type)
|
||||
{
|
||||
@ -3030,7 +3036,7 @@ check_arrival (re_match_context_t *mctx, state_array_t *path, int top_node,
|
||||
Can't we unify them? */
|
||||
|
||||
static reg_errcode_t
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
check_arrival_add_next_nodes (re_match_context_t *mctx, int str_idx,
|
||||
re_node_set *cur_nodes, re_node_set *next_nodes)
|
||||
{
|
||||
@ -3162,7 +3168,7 @@ check_arrival_expand_ecl (const re_dfa_t *dfa, re_node_set *cur_nodes,
|
||||
problematic append it to DST_NODES. */
|
||||
|
||||
static reg_errcode_t
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
check_arrival_expand_ecl_sub (const re_dfa_t *dfa, re_node_set *dst_nodes,
|
||||
int target, int ex_subexp, int type)
|
||||
{
|
||||
@ -3206,7 +3212,7 @@ check_arrival_expand_ecl_sub (const re_dfa_t *dfa, re_node_set *dst_nodes,
|
||||
in MCTX->BKREF_ENTS. */
|
||||
|
||||
static reg_errcode_t
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
expand_bkref_cache (re_match_context_t *mctx, re_node_set *cur_nodes,
|
||||
int cur_str, int subexp_num, int type)
|
||||
{
|
||||
@ -3564,13 +3570,13 @@ group_nodes_into_DFAstates (const re_dfa_t *dfa, const re_dfastate_t *state,
|
||||
}
|
||||
#ifdef RE_ENABLE_I18N
|
||||
else if (type == OP_UTF8_PERIOD)
|
||||
{
|
||||
{
|
||||
memset (accepts, '\xff', sizeof (bitset_t) / 2);
|
||||
if (!(dfa->syntax & RE_DOT_NEWLINE))
|
||||
bitset_clear (accepts, '\n');
|
||||
if (dfa->syntax & RE_DOT_NOT_NULL)
|
||||
bitset_clear (accepts, '\0');
|
||||
}
|
||||
}
|
||||
#endif
|
||||
else
|
||||
continue;
|
||||
@ -3775,7 +3781,7 @@ check_node_accept_bytes (const re_dfa_t *dfa, int node_idx,
|
||||
if (node->type == OP_PERIOD)
|
||||
{
|
||||
if (char_len <= 1)
|
||||
return 0;
|
||||
return 0;
|
||||
/* FIXME: I don't think this if is needed, as both '\n'
|
||||
and '\0' are char_len == 1. */
|
||||
/* '.' accepts any one character except the following two cases. */
|
||||
@ -4025,18 +4031,18 @@ check_node_accept (const re_match_context_t *mctx, const re_token_t *node,
|
||||
{
|
||||
case CHARACTER:
|
||||
if (node->opr.c != ch)
|
||||
return 0;
|
||||
return 0;
|
||||
break;
|
||||
|
||||
case SIMPLE_BRACKET:
|
||||
if (!bitset_contain (node->opr.sbcset, ch))
|
||||
return 0;
|
||||
return 0;
|
||||
break;
|
||||
|
||||
#ifdef RE_ENABLE_I18N
|
||||
case OP_UTF8_PERIOD:
|
||||
if (ch >= 0x80)
|
||||
return 0;
|
||||
return 0;
|
||||
/* FALLTHROUGH */
|
||||
#endif
|
||||
case OP_PERIOD:
|
||||
@ -4065,7 +4071,7 @@ check_node_accept (const re_match_context_t *mctx, const re_token_t *node,
|
||||
/* Extend the buffers, if the buffers have run out. */
|
||||
|
||||
static reg_errcode_t
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
extend_buffers (re_match_context_t *mctx)
|
||||
{
|
||||
reg_errcode_t ret;
|
||||
@ -4124,7 +4130,7 @@ extend_buffers (re_match_context_t *mctx)
|
||||
/* Initialize MCTX. */
|
||||
|
||||
static reg_errcode_t
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
match_ctx_init (re_match_context_t *mctx, int eflags, int n)
|
||||
{
|
||||
mctx->eflags = eflags;
|
||||
@ -4197,7 +4203,7 @@ match_ctx_free (re_match_context_t *mctx)
|
||||
*/
|
||||
|
||||
static reg_errcode_t
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
match_ctx_add_entry (re_match_context_t *mctx, int node, int str_idx, int from,
|
||||
int to)
|
||||
{
|
||||
@ -4269,7 +4275,7 @@ search_cur_bkref_entry (const re_match_context_t *mctx, int str_idx)
|
||||
at STR_IDX. */
|
||||
|
||||
static reg_errcode_t
|
||||
internal_function
|
||||
internal_function __attribute_warn_unused_result__
|
||||
match_ctx_add_subtop (re_match_context_t *mctx, int node, int str_idx)
|
||||
{
|
||||
#ifdef DEBUG
|
||||
|
||||
Reference in New Issue
Block a user