* config/srclist.txt: Add glibc bugs 1220, 1221, 1222.

* lib/regcomp.c:
(re_compile_pattern, re_set_syntax, re_compile_fastmap):
(re_compile_fastmap_iter, regcomp, regerror, regfree):
(re_compile_internal, init_dfa, init_word_char, free_workarea_compile):
(create_initial_state, optimize_utf8, analyze, postorder, preorder):
(optimize_subexps, lower_subexps, lower_subexp, calc_first, calc_next):
(link_nfa_nodes, duplicate_node_closure, search_duplicated_node):
(duplicate_node, calc_inveclosure, calc_eclosure, calc_eclosure_iter):
(fetch_token, peek_token, peek_token_bracket, parse, parse_reg_exp):
(parse_branch, parse_expression, parse_sub_exp, parse_dup_op):
(build_range_exp, build_collating_symbol, parse_bracket_exp):
(parse_bracket_element, parse_bracket_symbol, build_equiv_class):
(build_charclass, build_charclass_op, fetch_number, create_tree):
(create_token_tree, mark_opt_subexp, duplicate_tree):
Use prototypes rather than old-style definitions.
* lib/regex_internal.c:
(re_string_allocate, re_string_construct, re_string_realloc_buffers):
(re_string_construct_common, build_wcs_buffer, build_wcs_upper_buffer):
(re_string_skip_chars, build_upper_buffer, re_string_translate_buffer):
(re_string_reconstruct, re_string_peek_byte_case):
(re_string_fetch_byte_case, re_string_destruct, re_string_context_at):
(re_node_set_alloc, re_node_set_init_1, re_node_set_init_2):
(re_node_set_init_copy, re_node_set_add_intersect):
(re_node_set_init_union, re_node_set_merge, re_node_set_insert):
(re_node_set_insert_last, re_node_set_compare, re_node_set_contains):
(re_node_set_remove_at, re_dfa_add_node, calc_state_hash):
(re_acquire_state, re_acquire_state_context, register_state):
(create_ci_newstate, create_cd_newstate, free_state):
Likewise.
* lib/regexec.c (regexec, re_match, re_search, re_match_2, re_search_2):
(re_search_2_stub, re_search_stub, re_copy_regs, re_set_registers):
(re_search_internal, prune_impossible_nodes):
(acquire_init_state_context, check_matching, static):
(check_halt_node_context, check_halt_state_context, proceed_next_node):
(push_fail_stack, pop_fail_stack, set_regs, free_fail_stack_return):
(update_regs, sift_states_backward, build_sifted_states):
(clean_state_log_if_needed, merge_state_array):
(update_cur_sifted_state, add_epsilon_src_nodes):
(sub_epsilon_src_nodes, check_dst_limits, check_dst_limits_calc_pos_1):
(check_dst_limits_calc_pos, check_subexp_limits, sift_states_bkref):
(sift_states_iter_mb, transit_state, merge_state_with_log, static):
(find_recover_state, check_subexp_matching_top, transit_state_mb):
(transit_state_bkref, get_subexp, get_subexp_sub, find_subexp_node):
(check_arrival, check_arrival_add_next_nodes):
(check_arrival_expand_ecl, check_arrival_expand_ecl_sub):
(expand_bkref_cache, build_trtable, group_nodes_into_DFAstates):
(check_node_accept_bytes, check_node_accept, extend_buffers):
(match_ctx_init, match_ctx_clean, match_ctx_free, match_ctx_add_entry):
(search_cur_bkref_entry, match_ctx_add_subtop, match_ctx_add_sublast):
(sift_ctx_init):
Likewise.

* lib/regex_internal.h:
(re_string_allocate, re_string_construct, re_string_reconstruct):
(re_string_realloc_buffers, build_wcs_buffer, build_wcs_upper_buffer):
(build_upper_buffer, re_string_translate_buffer, re_string_destruct):
(re_string_elem_size_at, re_string_char_size_at, re_string_wchar_at):
(re_string_context_at, re_string_peek_byte_case):
(re_string_fetch_byte_case): Declare even if RE_NO_INTERNAL_PROTOTYPES
is defined, since we now use prototypes always.

* lib/regex.h (_RE_ARGS): Remove.  No longer needed, since we assume
C89 or better.  All uses removed.

1 files changed, 76 insertions, 111 deletions

diff --git a/lib/regex_internal.c b/lib/regex_internal.c
index 6e46199a5a..80e8406136 100644
--- a/lib/regex_internal.c
+++ b/lib/regex_internal.c
@@ -43,12 +43,9 @@ static unsigned int inline calc_state_hash (const re_node_set *nodes,
    re_string_reconstruct before using the object.  */
 
 static reg_errcode_t
-re_string_allocate (pstr, str, len, init_len, trans, icase, dfa)
-     re_string_t *pstr;
-     const char *str;
-     int len, init_len, icase;
-     RE_TRANSLATE_TYPE trans;
-     const re_dfa_t *dfa;
+internal_function
+re_string_allocate (re_string_t *pstr, const char *str, int len, int init_len,
+		    RE_TRANSLATE_TYPE trans, int icase, const re_dfa_t *dfa)
 {
   reg_errcode_t ret;
   int init_buf_len;
@@ -74,12 +71,9 @@ re_string_allocate (pstr, str, len, init_len, trans, icase, dfa)
 /* This function allocate the buffers, and initialize them.  */
 
 static reg_errcode_t
-re_string_construct (pstr, str, len, trans, icase, dfa)
-     re_string_t *pstr;
-     const char *str;
-     int len, icase;
-     RE_TRANSLATE_TYPE trans;
-     const re_dfa_t *dfa;
+internal_function
+re_string_construct (re_string_t *pstr, const char *str, int len,
+		     RE_TRANSLATE_TYPE trans, int icase, const re_dfa_t *dfa)
 {
   reg_errcode_t ret;
   memset (pstr, '\0', sizeof (re_string_t));
@@ -140,9 +134,8 @@ re_string_construct (pstr, str, len, trans, icase, dfa)
 /* Helper functions for re_string_allocate, and re_string_construct.  */
 
 static reg_errcode_t
-re_string_realloc_buffers (pstr, new_buf_len)
-     re_string_t *pstr;
-     int new_buf_len;
+internal_function
+re_string_realloc_buffers (re_string_t *pstr, int new_buf_len)
 {
 #ifdef RE_ENABLE_I18N
   if (pstr->mb_cur_max > 1)
@@ -174,13 +167,10 @@ re_string_realloc_buffers (pstr, new_buf_len)
 
 
 static void
-re_string_construct_common (str, len, pstr, trans, icase, dfa)
-     const char *str;
-     int len;
-     re_string_t *pstr;
-     RE_TRANSLATE_TYPE trans;
-     int icase;
-     const re_dfa_t *dfa;
+internal_function
+re_string_construct_common (const char *str, int len, re_string_t *pstr,
+			    RE_TRANSLATE_TYPE trans, int icase,
+			    const re_dfa_t *dfa)
 {
   pstr->raw_mbs = (const unsigned char *) str;
   pstr->len = len;
@@ -209,8 +199,8 @@ re_string_construct_common (str, len, pstr, trans, icase, dfa)
    built and starts from PSTR->VALID_LEN.  */
 
 static void
-build_wcs_buffer (pstr)
-     re_string_t *pstr;
+internal_function
+build_wcs_buffer (re_string_t *pstr)
 {
 #ifdef _LIBC
   unsigned char buf[MB_LEN_MAX];
@@ -277,8 +267,8 @@ build_wcs_buffer (pstr)
    but for REG_ICASE.  */
 
 static int
-build_wcs_upper_buffer (pstr)
-     re_string_t *pstr;
+internal_function
+build_wcs_upper_buffer (re_string_t *pstr)
 {
   mbstate_t prev_st;
   int src_idx, byte_idx, end_idx, remain_len;
@@ -493,10 +483,8 @@ build_wcs_upper_buffer (pstr)
    Return the index.  */
 
 static int
-re_string_skip_chars (pstr, new_raw_idx, last_wc)
-     re_string_t *pstr;
-     int new_raw_idx;
-     wint_t *last_wc;
+internal_function
+re_string_skip_chars (re_string_t *pstr, int new_raw_idx, wint_t *last_wc)
 {
   mbstate_t prev_st;
   int rawbuf_idx;
@@ -530,8 +518,8 @@ re_string_skip_chars (pstr, new_raw_idx, last_wc)
    This function is used in case of REG_ICASE.  */
 
 static void
-build_upper_buffer (pstr)
-     re_string_t *pstr;
+internal_function
+build_upper_buffer (re_string_t *pstr)
 {
   int char_idx, end_idx;
   end_idx = (pstr->bufs_len > pstr->len) ? pstr->len : pstr->bufs_len;
@@ -553,8 +541,8 @@ build_upper_buffer (pstr)
 /* Apply TRANS to the buffer in PSTR.  */
 
 static void
-re_string_translate_buffer (pstr)
-     re_string_t *pstr;
+internal_function
+re_string_translate_buffer (re_string_t *pstr)
 {
   int buf_idx, end_idx;
   end_idx = (pstr->bufs_len > pstr->len) ? pstr->len : pstr->bufs_len;
@@ -574,9 +562,8 @@ re_string_translate_buffer (pstr)
    convert to upper case in case of REG_ICASE, apply translation.  */
 
 static reg_errcode_t
-re_string_reconstruct (pstr, idx, eflags)
-     re_string_t *pstr;
-     int idx, eflags;
+internal_function
+re_string_reconstruct (re_string_t *pstr, int idx, int eflags)
 {
   int offset = idx - pstr->raw_mbs_idx;
   if (BE (offset < 0, 0))
@@ -752,9 +739,8 @@ re_string_reconstruct (pstr, idx, eflags)
 }
 
 static unsigned char
-re_string_peek_byte_case (pstr, idx)
-     const re_string_t *pstr;
-     int idx;
+internal_function
+re_string_peek_byte_case (const re_string_t *pstr, int idx)
 {
   int ch, off;
 
@@ -789,8 +775,8 @@ re_string_peek_byte_case (pstr, idx)
 }
 
 static unsigned char
-re_string_fetch_byte_case (pstr)
-     re_string_t *pstr;
+internal_function
+re_string_fetch_byte_case (re_string_t *pstr)
 {
   if (BE (!pstr->mbs_allocated, 1))
     return re_string_fetch_byte (pstr);
@@ -826,8 +812,8 @@ re_string_fetch_byte_case (pstr)
 }
 
 static void
-re_string_destruct (pstr)
-     re_string_t *pstr;
+internal_function
+re_string_destruct (re_string_t *pstr)
 {
 #ifdef RE_ENABLE_I18N
   re_free (pstr->wcs);
@@ -840,9 +826,8 @@ re_string_destruct (pstr)
 /* Return the context at IDX in INPUT.  */
 
 static unsigned int
-re_string_context_at (input, idx, eflags)
-     const re_string_t *input;
-     int idx, eflags;
+internal_function
+re_string_context_at (const re_string_t *input, int idx, int eflags)
 {
   int c;
   if (BE (idx < 0, 0))
@@ -886,9 +871,8 @@ re_string_context_at (input, idx, eflags)
 /* Functions for set operation.  */
 
 static reg_errcode_t
-re_node_set_alloc (set, size)
-     re_node_set *set;
-     int size;
+internal_function
+re_node_set_alloc (re_node_set *set, int size)
 {
   set->alloc = size;
   set->nelem = 0;
@@ -899,9 +883,8 @@ re_node_set_alloc (set, size)
 }
 
 static reg_errcode_t
-re_node_set_init_1 (set, elem)
-     re_node_set *set;
-     int elem;
+internal_function
+re_node_set_init_1 (re_node_set *set, int elem)
 {
   set->alloc = 1;
   set->nelem = 1;
@@ -916,9 +899,8 @@ re_node_set_init_1 (set, elem)
 }
 
 static reg_errcode_t
-re_node_set_init_2 (set, elem1, elem2)
-     re_node_set *set;
-     int elem1, elem2;
+internal_function
+re_node_set_init_2 (re_node_set *set, int elem1, int elem2)
 {
   set->alloc = 2;
   set->elems = re_malloc (int, 2);
@@ -947,9 +929,8 @@ re_node_set_init_2 (set, elem1, elem2)
 }
 
 static reg_errcode_t
-re_node_set_init_copy (dest, src)
-     re_node_set *dest;
-     const re_node_set *src;
+internal_function
+re_node_set_init_copy (re_node_set *dest, const re_node_set *src)
 {
   dest->nelem = src->nelem;
   if (src->nelem > 0)
@@ -973,9 +954,9 @@ re_node_set_init_copy (dest, src)
    Note: We assume dest->elems is NULL, when dest->alloc is 0.  */
 
 static reg_errcode_t
-re_node_set_add_intersect (dest, src1, src2)
-     re_node_set *dest;
-     const re_node_set *src1, *src2;
+internal_function
+re_node_set_add_intersect (re_node_set *dest, const re_node_set *src1,
+			   const re_node_set *src2)
 {
   int i1, i2, is, id, delta, sbase;
   if (src1->nelem == 0 || src2->nelem == 0)
@@ -1064,9 +1045,9 @@ re_node_set_add_intersect (dest, src1, src2)
    DEST. Return value indicate the error code or REG_NOERROR if succeeded.  */
 
 static reg_errcode_t
-re_node_set_init_union (dest, src1, src2)
-     re_node_set *dest;
-     const re_node_set *src1, *src2;
+internal_function
+re_node_set_init_union (re_node_set *dest, const re_node_set *src1,
+			const re_node_set *src2)
 {
   int i1, i2, id;
   if (src1 != NULL && src1->nelem > 0 && src2 != NULL && src2->nelem > 0)
@@ -1117,9 +1098,8 @@ re_node_set_init_union (dest, src1, src2)
    DEST. Return value indicate the error code or REG_NOERROR if succeeded.  */
 
 static reg_errcode_t
-re_node_set_merge (dest, src)
-     re_node_set *dest;
-     const re_node_set *src;
+internal_function
+re_node_set_merge (re_node_set *dest, const re_node_set *src)
 {
   int is, id, sbase, delta;
   if (src == NULL || src->nelem == 0)
@@ -1201,9 +1181,8 @@ re_node_set_merge (dest, src)
    return -1 if an error is occured, return 1 otherwise.  */
 
 static int
-re_node_set_insert (set, elem)
-     re_node_set *set;
-     int elem;
+internal_function
+re_node_set_insert (re_node_set *set, int elem)
 {
   int idx;
   /* In case the set is empty.  */
@@ -1259,9 +1238,8 @@ re_node_set_insert (set, elem)
    Return -1 if an error is occured, return 1 otherwise.  */
 
 static int
-re_node_set_insert_last (set, elem)
-     re_node_set *set;
-     int elem;
+internal_function
+re_node_set_insert_last (re_node_set *set, int elem)
 {
   /* Realloc if we need.  */
   if (set->alloc == set->nelem)
@@ -1283,8 +1261,8 @@ re_node_set_insert_last (set, elem)
    return 1 if SET1 and SET2 are equivalent, return 0 otherwise.  */
 
 static int
-re_node_set_compare (set1, set2)
-     const re_node_set *set1, *set2;
+internal_function
+re_node_set_compare (const re_node_set *set1, const re_node_set *set2)
 {
   int i;
   if (set1 == NULL || set2 == NULL || set1->nelem != set2->nelem)
@@ -1298,9 +1276,8 @@ re_node_set_compare (set1, set2)
 /* Return (idx + 1) if SET contains the element ELEM, return 0 otherwise.  */
 
 static int
-re_node_set_contains (set, elem)
-     const re_node_set *set;
-     int elem;
+internal_function
+re_node_set_contains (const re_node_set *set, int elem)
 {
   unsigned int idx, right, mid;
   if (set->nelem <= 0)
@@ -1321,9 +1298,8 @@ re_node_set_contains (set, elem)
 }
 
 static void
-re_node_set_remove_at (set, idx)
-     re_node_set *set;
-     int idx;
+internal_function
+re_node_set_remove_at (re_node_set *set, int idx)
 {
   if (idx < 0 || idx >= set->nelem)
     return;
@@ -1337,9 +1313,8 @@ re_node_set_remove_at (set, idx)
    Or return -1, if an error will be occured.  */
 
 static int
-re_dfa_add_node (dfa, token)
-     re_dfa_t *dfa;
-     re_token_t token;
+internal_function
+re_dfa_add_node (re_dfa_t *dfa, re_token_t token)
 {
   int type = token.type;
   if (BE (dfa->nodes_len >= dfa->nodes_alloc, 0))
@@ -1379,9 +1354,8 @@ re_dfa_add_node (dfa, token)
 }
 
 static unsigned int inline
-calc_state_hash (nodes, context)
-     const re_node_set *nodes;
-     unsigned int context;
+internal_function
+calc_state_hash (const re_node_set *nodes, unsigned int context)
 {
   unsigned int hash = nodes->nelem + context;
   int i;
@@ -1400,10 +1374,8 @@ calc_state_hash (nodes, context)
 	   optimization.  */
 
 static re_dfastate_t*
-re_acquire_state (err, dfa, nodes)
-     reg_errcode_t *err;
-     re_dfa_t *dfa;
-     const re_node_set *nodes;
+internal_function
+re_acquire_state (reg_errcode_t *err, re_dfa_t *dfa, const re_node_set *nodes)
 {
   unsigned int hash;
   re_dfastate_t *new_state;
@@ -1452,11 +1424,9 @@ re_acquire_state (err, dfa, nodes)
 	   optimization.  */
 
 static re_dfastate_t*
-re_acquire_state_context (err, dfa, nodes, context)
-     reg_errcode_t *err;
-     re_dfa_t *dfa;
-     const re_node_set *nodes;
-     unsigned int context;
+internal_function
+re_acquire_state_context (reg_errcode_t *err, re_dfa_t *dfa,
+			  const re_node_set *nodes, unsigned int context)
 {
   unsigned int hash;
   re_dfastate_t *new_state;
@@ -1498,10 +1468,8 @@ re_acquire_state_context (err, dfa, nodes, context)
    indicates the error code if failed.  */
 
 static reg_errcode_t
-register_state (dfa, newstate, hash)
-     re_dfa_t *dfa;
-     re_dfastate_t *newstate;
-     unsigned int hash;
+internal_function
+register_state (re_dfa_t *dfa, re_dfastate_t *newstate, unsigned int hash)
 {
   struct re_state_table_entry *spot;
   reg_errcode_t err;
@@ -1537,10 +1505,8 @@ register_state (dfa, newstate, hash)
    Return the new state if succeeded, otherwise return NULL.  */
 
 static re_dfastate_t *
-create_ci_newstate (dfa, nodes, hash)
-     re_dfa_t *dfa;
-     const re_node_set *nodes;
-     unsigned int hash;
+internal_function
+create_ci_newstate (re_dfa_t *dfa, const re_node_set *nodes, unsigned int hash)
 {
   int i;
   reg_errcode_t err;
@@ -1588,10 +1554,9 @@ create_ci_newstate (dfa, nodes, hash)
    Return the new state if succeeded, otherwise return NULL.  */
 
 static re_dfastate_t *
-create_cd_newstate (dfa, nodes, context, hash)
-     re_dfa_t *dfa;
-     const re_node_set *nodes;
-     unsigned int context, hash;
+internal_function
+create_cd_newstate (re_dfa_t *dfa, const re_node_set *nodes,
+		    unsigned int context, unsigned int hash)
 {
   int i, nctx_nodes = 0;
   reg_errcode_t err;
@@ -1664,8 +1629,8 @@ create_cd_newstate (dfa, nodes, context, hash)
 }
 
 static void
-free_state (state)
-     re_dfastate_t *state;
+internal_function
+free_state (re_dfastate_t *state)
 {
   re_node_set_free (&state->non_eps_nodes);
   re_node_set_free (&state->inveclosure);