From: Peter Jones <pjo...@redhat.com>
[rharw...@redhat.com: rebase conflicts in regexec]
Signed-off-by: Robbie Harwood <rharw...@redhat.com>
---
lib/argp-fmtstream.c | 2 +-
lib/regcomp.c | 28 +++++++++++++++-------------
lib/regex_internal.c | 6 +++---
lib/regexec.c | 36 ++++++++++++++++++++----------------
lib/vasnprintf.c | 4 ++--
5 files changed, 41 insertions(+), 35 deletions(-)
diff --git a/lib/argp-fmtstream.c b/lib/argp-fmtstream.c
index f679751b9..4aa401e2d 100644
--- a/lib/argp-fmtstream.c
+++ b/lib/argp-fmtstream.c
@@ -234,7 +234,7 @@ __argp_fmtstream_update (argp_fmtstream_t fs)
else
{
size_t display_width = mbsnwidth (buf, nl - buf, MBSW_STOP_AT_NUL);
- if (display_width < (ssize_t) fs->rmargin)
+ if (display_width < fs->rmargin)
{
/* The buffer contains a full line that fits within the maximum
line width. Reset point and scan the next line. */
diff --git a/lib/regcomp.c b/lib/regcomp.c
index 4a106ff59..a33a74488 100644
--- a/lib/regcomp.c
+++ b/lib/regcomp.c
@@ -300,7 +300,7 @@ re_compile_fastmap_iter (regex_t *bufp, const re_dfastate_t
*init_state,
bool icase = (dfa->mb_cur_max == 1 && (bufp->syntax & RE_ICASE));
for (node_cnt = 0; node_cnt < init_state->nodes.nelem; ++node_cnt)
{
- Idx node = init_state->nodes.elems[node_cnt];
+ size_t node = init_state->nodes.elems[node_cnt];
re_token_type_t type = dfa->nodes[node].type;
if (type == CHARACTER)
@@ -321,7 +321,7 @@ re_compile_fastmap_iter (regex_t *bufp, const re_dfastate_t
*init_state,
&& dfa->nodes[node].mb_partial)
*p++ = dfa->nodes[node].opr.c;
memset (&state, '\0', sizeof (state));
- if (__mbrtowc (&wc, (const char *) buf, p - buf,
+ if ((ssize_t)__mbrtowc (&wc, (const char *) buf, p - buf,
&state) == p - buf
&& (__wcrtomb ((char *) buf, __towlower (wc), &state)
!= (size_t) -1))
@@ -582,7 +582,8 @@ static const bitset_t utf8_sb_map =
static void
free_dfa_content (re_dfa_t *dfa)
{
- Idx i, j;
+ size_t i;
+ Idx j;
if (dfa->nodes)
for (i = 0; i < dfa->nodes_len; ++i)
@@ -893,7 +894,8 @@ init_dfa (re_dfa_t *dfa, size_t pat_len)
dfa->sb_char = (re_bitset_ptr_t) utf8_sb_map;
else
{
- int i, j, ch;
+ int i, j;
+ wint_t ch;
dfa->sb_char = (re_bitset_ptr_t) calloc (sizeof (bitset_t), 1);
if (__glibc_unlikely (dfa->sb_char == NULL))
@@ -1082,7 +1084,7 @@ create_initial_state (re_dfa_t *dfa)
static void
optimize_utf8 (re_dfa_t *dfa)
{
- Idx node;
+ size_t node;
int i;
bool mb_chars = false;
bool has_period = false;
@@ -1177,12 +1179,12 @@ analyze (regex_t *preg)
dfa->subexp_map = re_malloc (Idx, preg->re_nsub);
if (dfa->subexp_map != NULL)
{
- Idx i;
+ size_t i;
for (i = 0; i < preg->re_nsub; i++)
dfa->subexp_map[i] = i;
preorder (dfa->str_tree, optimize_subexps, dfa);
for (i = 0; i < preg->re_nsub; i++)
- if (dfa->subexp_map[i] != i)
+ if (dfa->subexp_map[i] != (ssize_t)i)
break;
if (i == preg->re_nsub)
{
@@ -1627,7 +1629,7 @@ duplicate_node (re_dfa_t *dfa, Idx org_idx, unsigned int
constraint)
static reg_errcode_t
calc_inveclosure (re_dfa_t *dfa)
{
- Idx src, idx;
+ size_t src, idx;
bool ok;
for (idx = 0; idx < dfa->nodes_len; ++idx)
re_node_set_init_empty (dfa->inveclosures + idx);
@@ -1635,7 +1637,7 @@ calc_inveclosure (re_dfa_t *dfa)
for (src = 0; src < dfa->nodes_len; ++src)
{
Idx *elems = dfa->eclosures[src].elems;
- for (idx = 0; idx < dfa->eclosures[src].nelem; ++idx)
+ for (idx = 0; (ssize_t)idx < dfa->eclosures[src].nelem; ++idx)
{
ok = re_node_set_insert_last (dfa->inveclosures + elems[idx], src);
if (__glibc_unlikely (! ok))
@@ -1651,7 +1653,7 @@ calc_inveclosure (re_dfa_t *dfa)
static reg_errcode_t
calc_eclosure (re_dfa_t *dfa)
{
- Idx node_idx;
+ size_t node_idx;
bool incomplete;
DEBUG_ASSERT (dfa->nodes_len > 0);
incomplete = false;
@@ -2717,7 +2719,7 @@ build_range_exp (const reg_syntax_t syntax,
# ifdef RE_ENABLE_I18N
{
- wchar_t wc;
+ wint_t wc;
wint_t start_wc;
wint_t end_wc;
@@ -2728,9 +2730,9 @@ build_range_exp (const reg_syntax_t syntax,
: ((end_elem->type == COLL_SYM) ? end_elem->opr.name[0]
: 0));
start_wc = ((start_elem->type == SB_CHAR || start_elem->type == COLL_SYM)
- ? parse_byte (start_ch, mbcset) : start_elem->opr.wch);
+ ? parse_byte (start_ch, mbcset) : (wint_t)start_elem->opr.wch);
end_wc = ((end_elem->type == SB_CHAR || end_elem->type == COLL_SYM)
- ? parse_byte (end_ch, mbcset) : end_elem->opr.wch);
+ ? parse_byte (end_ch, mbcset) : (wint_t)end_elem->opr.wch);
if (start_wc == WEOF || end_wc == WEOF)
return REG_ECOLLATE;
else if (__glibc_unlikely ((syntax & RE_NO_EMPTY_RANGES)
diff --git a/lib/regex_internal.c b/lib/regex_internal.c
index aefcfa2f5..405a97267 100644
--- a/lib/regex_internal.c
+++ b/lib/regex_internal.c
@@ -146,7 +146,7 @@ re_string_realloc_buffers (re_string_t *pstr, Idx
new_buf_len)
/* Avoid overflow in realloc. */
const size_t max_object_size = MAX (sizeof (wint_t), sizeof (Idx));
- if (__glibc_unlikely (MIN (IDX_MAX, SIZE_MAX / max_object_size)
+ if (__glibc_unlikely ((ssize_t)MIN (IDX_MAX, SIZE_MAX / max_object_size)
< new_buf_len))
return REG_ESPACE;
@@ -403,7 +403,7 @@ build_wcs_upper_buffer (re_string_t *pstr)
{
size_t i;
- if (byte_idx + mbcdlen > pstr->bufs_len)
+ if ((ssize_t)(byte_idx + mbcdlen) > pstr->bufs_len)
{
pstr->cur_state = prev_st;
break;
@@ -753,7 +753,7 @@ re_string_reconstruct (re_string_t *pstr, Idx idx, int
eflags)
memset (&cur_state, 0, sizeof (cur_state));
mbclen = __mbrtowc (&wc2, (const char *) pp, mlen,
&cur_state);
- if (raw + offset - p <= mbclen
+ if (raw + offset - p <= (ssize_t)mbclen
&& mbclen < (size_t) -2)
{
memset (&pstr->cur_state, '\0',
diff --git a/lib/regexec.c b/lib/regexec.c
index 90330ef39..9ad488044 100644
--- a/lib/regexec.c
+++ b/lib/regexec.c
@@ -34,7 +34,7 @@ static void sift_ctx_init (re_sift_context_t *sctx,
re_dfastate_t **sifted_sts,
static reg_errcode_t re_search_internal (const regex_t *preg,
const char *string, Idx length,
Idx start, Idx last_start, Idx stop,
- size_t nmatch, regmatch_t pmatch[],
+ ssize_t nmatch, regmatch_t pmatch[],
int eflags);
static regoff_t re_search_2_stub (struct re_pattern_buffer *bufp,
const char *string1, Idx length1,
@@ -63,7 +63,7 @@ static reg_errcode_t push_fail_stack (struct re_fail_stack_t
*fs,
re_node_set *eps_via_nodes);
static reg_errcode_t set_regs (const regex_t *preg,
const re_match_context_t *mctx,
- size_t nmatch, regmatch_t *pmatch,
+ ssize_t nmatch, regmatch_t *pmatch,
bool fl_backtrack);
static reg_errcode_t free_fail_stack_return (struct re_fail_stack_t *fs);
@@ -484,7 +484,7 @@ re_copy_regs (struct re_registers *regs, regmatch_t
*pmatch, Idx nregs,
{ /* Yes. If we need more elements than were already
allocated, reallocate them. If we need fewer, just
leave it alone. */
- if (__glibc_unlikely (need_regs > regs->num_regs))
+ if (__glibc_unlikely (need_regs > (ssize_t)regs->num_regs))
{
regoff_t *new_start = re_realloc (regs->start, regoff_t, need_regs);
regoff_t *new_end;
@@ -505,7 +505,7 @@ re_copy_regs (struct re_registers *regs, regmatch_t
*pmatch, Idx nregs,
{
DEBUG_ASSERT (regs_allocated == REGS_FIXED);
/* This function may not be called with REGS_FIXED and nregs too big. */
- DEBUG_ASSERT (nregs <= regs->num_regs);
+ DEBUG_ASSERT ((ssize_t)nregs <= regs->num_regs);
rval = REGS_FIXED;
}
@@ -515,7 +515,7 @@ re_copy_regs (struct re_registers *regs, regmatch_t
*pmatch, Idx nregs,
regs->start[i] = pmatch[i].rm_so;
regs->end[i] = pmatch[i].rm_eo;
}
- for ( ; i < regs->num_regs; ++i)
+ for ( ; i < (ssize_t)regs->num_regs; ++i)
regs->start[i] = regs->end[i] = -1;
return rval;
@@ -584,7 +584,7 @@ re_exec (const char *s)
static reg_errcode_t
__attribute_warn_unused_result__
re_search_internal (const regex_t *preg, const char *string, Idx length,
- Idx start, Idx last_start, Idx stop, size_t nmatch,
+ Idx start, Idx last_start, Idx stop, ssize_t nmatch,
regmatch_t pmatch[], int eflags)
{
reg_errcode_t err;
@@ -604,7 +604,7 @@ re_search_internal (const regex_t *preg, const char
*string, Idx length,
? preg->fastmap : NULL);
RE_TRANSLATE_TYPE t = preg->translate;
- extra_nmatch = (nmatch > preg->re_nsub) ? nmatch - (preg->re_nsub + 1) : 0;
+ extra_nmatch = (nmatch > (ssize_t)preg->re_nsub) ? nmatch - (preg->re_nsub +
1) : 0;
nmatch -= extra_nmatch;
/* Check if the DFA haven't been compiled. */
@@ -653,9 +653,10 @@ re_search_internal (const regex_t *preg, const char
*string, Idx length,
if (nmatch > 1 || dfa->has_mb_node)
{
/* Avoid overflow. */
- if (__glibc_unlikely ((MIN (IDX_MAX, SIZE_MAX / sizeof (re_dfastate_t *))
- <= mctx.input.bufs_len)))
- {
+ if (__glibc_unlikely ((ssize_t)MIN (IDX_MAX,
+ SIZE_MAX / sizeof (re_dfastate_t *))
+ <= mctx.input.bufs_len))
+ {
err = REG_ESPACE;
goto free_return;
}
@@ -920,7 +921,8 @@ prune_impossible_nodes (re_match_context_t *mctx)
halt_node = mctx->last_node;
/* Avoid overflow. */
- if (__glibc_unlikely (MIN (IDX_MAX, SIZE_MAX / sizeof (re_dfastate_t *))
+ if (__glibc_unlikely ((ssize_t)MIN (IDX_MAX,
+ SIZE_MAX / sizeof (re_dfastate_t *))
<= match_last))
return REG_ESPACE;
@@ -1381,7 +1383,7 @@ pop_fail_stack (struct re_fail_stack_t *fs, Idx *pidx,
Idx nregs,
static reg_errcode_t
__attribute_warn_unused_result__
-set_regs (const regex_t *preg, const re_match_context_t *mctx, size_t nmatch,
+set_regs (const regex_t *preg, const re_match_context_t *mctx, ssize_t nmatch,
regmatch_t *pmatch, bool fl_backtrack)
{
const re_dfa_t *dfa = preg->buffer;
@@ -1416,7 +1418,7 @@ set_regs (const regex_t *preg, const re_match_context_t
*mctx, size_t nmatch,
regmatch_t *prev_idx_match = regmatch_list_begin (&prev_match);
memcpy (prev_idx_match, pmatch, sizeof (regmatch_t) * nmatch);
- for (idx = pmatch[0].rm_so; idx <= pmatch[0].rm_eo ;)
+ for (idx = pmatch[0].rm_so; (ssize_t)idx <= (long)pmatch[0].rm_eo ;)
{
update_regs (dfa, pmatch, prev_idx_match, cur_node, idx, nmatch);
@@ -2860,7 +2862,8 @@ check_arrival (re_match_context_t *mctx, state_array_t
*path, Idx top_node,
if (__glibc_unlikely (IDX_MAX - old_alloc < incr_alloc))
return REG_ESPACE;
new_alloc = old_alloc + incr_alloc;
- if (__glibc_unlikely (SIZE_MAX / sizeof (re_dfastate_t *) < new_alloc))
+ if (__glibc_unlikely ((ssize_t)(SIZE_MAX / sizeof (re_dfastate_t *))
+ < new_alloc))
return REG_ESPACE;
new_array = re_realloc (path->array, re_dfastate_t *, new_alloc);
if (__glibc_unlikely (new_array == NULL))
@@ -3996,7 +3999,8 @@ extend_buffers (re_match_context_t *mctx, int min_len)
re_string_t *pstr = &mctx->input;
/* Avoid overflow. */
- if (__glibc_unlikely (MIN (IDX_MAX, SIZE_MAX / sizeof (re_dfastate_t *)) / 2
+ if (__glibc_unlikely ((ssize_t)MIN (IDX_MAX,
+ SIZE_MAX / sizeof (re_dfastate_t *)) / 2
<= pstr->bufs_len))
return REG_ESPACE;
@@ -4066,7 +4070,7 @@ match_ctx_init (re_match_context_t *mctx, int eflags, Idx
n)
size_t max_object_size =
MAX (sizeof (struct re_backref_cache_entry),
sizeof (re_sub_match_top_t *));
- if (__glibc_unlikely (MIN (IDX_MAX, SIZE_MAX / max_object_size) < n))
+ if (__glibc_unlikely ((ssize_t)MIN (IDX_MAX, SIZE_MAX / max_object_size)
< n))
return REG_ESPACE;
mctx->bkref_ents = re_malloc (struct re_backref_cache_entry, n);
diff --git a/lib/vasnprintf.c b/lib/vasnprintf.c
index d9b669d15..360ca6948 100644
--- a/lib/vasnprintf.c
+++ b/lib/vasnprintf.c
@@ -5573,7 +5573,7 @@ VASNPRINTF (DCHAR_T *resultbuf, size_t *lengthp,
#endif
#if !USE_SNPRINTF
- if (count >= tmp_length)
+ if (count >= (ssize_t)tmp_length)
/* tmp_length was incorrectly calculated - fix the
code above! */
abort ();
@@ -5663,7 +5663,7 @@ VASNPRINTF (DCHAR_T *resultbuf, size_t *lengthp,
#if DCHAR_IS_TCHAR && !USE_SNPRINTF
/* Make room for the result. */
- if (count > allocated - length)
+ if (count > (ssize_t)(allocated - length))
{
/* Need at least count elements. But allocate
proportionally. */
--
2.33.0
