regex_internal.c File Reference

Go to the source code of this file.

Functions
static void re_string_construct_common	_RE_ARGS ((const char *str, int len, re_string_t *pstr, RE_TRANSLATE_TYPE trans, int icase))
static reg_errcode_t	re_string_allocate (re_string_t *pstr, const char *str, int len, int init_len, RE_TRANSLATE_TYPE trans, int icase)
static reg_errcode_t	re_string_construct (re_string_t *pstr, const char *str, int len, RE_TRANSLATE_TYPE trans, int icase)
static reg_errcode_t	re_string_realloc_buffers (re_string_t *pstr, int new_buf_len)
static void	re_string_construct_common (char *str, int len, re_string_t *pstr, RE_TRANSLATE_TYPE trans, int icase) const
static void	build_upper_buffer (re_string_t *pstr)
static void	re_string_translate_buffer (re_string_t *pstr)
static reg_errcode_t	re_string_reconstruct (re_string_t *pstr, int idx, int eflags, int newline)
static void	re_string_destruct (re_string_t *pstr)
static unsigned int	re_string_context_at (re_string_t *input, int idx, int eflags, int newline_anchor) const
static reg_errcode_t	re_node_set_alloc (re_node_set *set, int size)
static reg_errcode_t	re_node_set_init_1 (re_node_set *set, int elem)
static reg_errcode_t	re_node_set_init_2 (re_node_set *set, int elem1, int elem2)
static reg_errcode_t	re_node_set_init_copy (re_node_set *dest, const re_node_set *src)
static reg_errcode_t	re_node_set_add_intersect (re_node_set *dest, const re_node_set *src1, const re_node_set *src2)
static reg_errcode_t	re_node_set_init_union (re_node_set *dest, const re_node_set *src1, const re_node_set *src2)
static reg_errcode_t	re_node_set_merge (re_node_set *dest, const re_node_set *src)
static int	re_node_set_insert (re_node_set *set, int elem)
static int	re_node_set_compare (re_node_set *set1, re_node_set *set2) const
static int	re_node_set_contains (re_node_set *set, int elem) const
static void	re_node_set_remove_at (re_node_set *set, int idx)
static int	re_dfa_add_node (re_dfa_t *dfa, re_token_t token, int mode)
static unsigned int	calc_state_hash (re_node_set *nodes, unsigned int context) const
static re_dfastate_t *	re_acquire_state (reg_errcode_t *err, re_dfa_t *dfa, const re_node_set *nodes)
static re_dfastate_t *	re_acquire_state_context (reg_errcode_t *err, re_dfa_t *dfa, const re_node_set *nodes, unsigned int context)
static re_dfastate_t *	create_newstate_common (re_dfa_t *dfa, const re_node_set *nodes, unsigned int hash)
static reg_errcode_t	register_state (re_dfa_t *dfa, re_dfastate_t *newstate, unsigned int hash)
static re_dfastate_t *	create_ci_newstate (re_dfa_t *dfa, const re_node_set *nodes, unsigned int hash)
static re_dfastate_t *	create_cd_newstate (re_dfa_t *dfa, const re_node_set *nodes, unsigned int context, unsigned int hash)
static void	free_state (re_dfastate_t *state)

---

Function Documentation

static void re_string_construct_common _RE_ARGS (  (const char *str, int len, re_string_t *pstr, RE_TRANSLATE_TYPE trans, int icase)   )  [static]

static void build_upper_buffer (  re_string_t *  pstr  )  [static]

Definition at line 337 of file regex_internal.c. References NULL. Referenced by extend_buffers(), re_string_construct(), and re_string_reconstruct(). { int char_idx, end_idx; end_idx = (pstr->bufs_len > pstr->len) ? pstr->len : pstr->bufs_len; for (char_idx = pstr->valid_len; char_idx < end_idx; ++char_idx) { int ch = pstr->raw_mbs[pstr->raw_mbs_idx + char_idx]; if (pstr->trans != NULL) { ch = pstr->trans[ch]; pstr->mbs_case[char_idx] = ch; } if (islower (ch)) pstr->mbs[char_idx] = toupper (ch); else pstr->mbs[char_idx] = ch; } pstr->valid_len = char_idx; }

static unsigned int calc_state_hash (  re_node_set *  nodes, unsigned int  context )  const [inline, static]

Definition at line 976 of file regex_internal.c. References i. Referenced by re_acquire_state(), and re_acquire_state_context(). { unsigned int hash = nodes->nelem + context; int i; for (i = 0 ; i < nodes->nelem ; i++) hash += nodes->elems[i]; return hash; }

static re_dfastate_t* create_cd_newstate (  re_dfa_t *  dfa, const re_node_set *  nodes, unsigned int  context, unsigned int  hash )  [static]

Definition at line 1184 of file regex_internal.c. References re_dfastate_t::accept_mb, ANCHOR, BE, CHARACTER, re_token_t::constraint, re_dfastate_t::context, create_newstate_common(), re_node_set::elems, END_OF_RE, re_dfastate_t::entrance_nodes, err(), free_state(), re_dfastate_t::halt, re_dfastate_t::has_backref, re_dfastate_t::has_constraint, i, node(), re_dfastate_t::nodes, NOT_SATISFY_PREV_CONSTRAINT, NULL, OP_BACK_REF, OP_PERIOD, re_token_t::opr, re_malloc, re_node_set_init_copy(), re_node_set_remove_at(), REG_NOERROR, register_state(), and re_token_t::type. Referenced by re_acquire_state_context(). { int i, nctx_nodes = 0; reg_errcode_t err; re_dfastate_t *newstate; newstate = create_newstate_common (dfa, nodes, hash); if (BE (newstate == NULL, 0)) return NULL; newstate->context = context; newstate->entrance_nodes = &newstate->nodes; for (i = 0 ; i < nodes->nelem ; i++) { unsigned int constraint = 0; re_token_t *node = dfa->nodes + nodes->elems[i]; re_token_type_t type = node->type; if (node->constraint) constraint = node->constraint; if (type == CHARACTER && !constraint) continue; /* If the state has the halt node, the state is a halt state. */ else if (type == END_OF_RE) newstate->halt = 1; #ifdef RE_ENABLE_I18N else if (type == COMPLEX_BRACKET || (type == OP_PERIOD && re_mb_cur_max > 1)) newstate->accept_mb = 1; #endif /* RE_ENABLE_I18N */ else if (type == OP_BACK_REF) newstate->has_backref = 1; else if (type == ANCHOR) constraint = node->opr.ctx_type; if (constraint) { if (newstate->entrance_nodes == &newstate->nodes) { newstate->entrance_nodes = re_malloc (re_node_set, 1); if (BE (newstate->entrance_nodes == NULL, 0)) { free_state (newstate); return NULL; } re_node_set_init_copy (newstate->entrance_nodes, nodes); nctx_nodes = 0; newstate->has_constraint = 1; } if (NOT_SATISFY_PREV_CONSTRAINT (constraint,context)) { re_node_set_remove_at (&newstate->nodes, i - nctx_nodes); ++nctx_nodes; } } } err = register_state (dfa, newstate, hash); if (BE (err != REG_NOERROR, 0)) { free_state (newstate); newstate = NULL; } return newstate; }

static re_dfastate_t* create_ci_newstate (  re_dfa_t *  dfa, const re_node_set *  nodes, unsigned int  hash )  [static]

Definition at line 1138 of file regex_internal.c. References re_dfastate_t::accept_mb, ANCHOR, BE, CHARACTER, re_token_t::constraint, create_newstate_common(), re_node_set::elems, END_OF_RE, re_dfastate_t::entrance_nodes, err(), free_state(), re_dfastate_t::halt, re_dfastate_t::has_backref, re_dfastate_t::has_constraint, i, node(), re_dfastate_t::nodes, NULL, OP_BACK_REF, OP_PERIOD, REG_NOERROR, register_state(), and re_token_t::type. Referenced by re_acquire_state(). { int i; reg_errcode_t err; re_dfastate_t *newstate; newstate = create_newstate_common (dfa, nodes, hash); if (BE (newstate == NULL, 0)) return NULL; newstate->entrance_nodes = &newstate->nodes; for (i = 0 ; i < nodes->nelem ; i++) { re_token_t *node = dfa->nodes + nodes->elems[i]; re_token_type_t type = node->type; if (type == CHARACTER && !node->constraint) continue; /* If the state has the halt node, the state is a halt state. */ else if (type == END_OF_RE) newstate->halt = 1; #ifdef RE_ENABLE_I18N else if (type == COMPLEX_BRACKET || (type == OP_PERIOD && re_mb_cur_max > 1)) newstate->accept_mb = 1; #endif /* RE_ENABLE_I18N */ else if (type == OP_BACK_REF) newstate->has_backref = 1; else if (type == ANCHOR || node->constraint) newstate->has_constraint = 1; } err = register_state (dfa, newstate, hash); if (BE (err != REG_NOERROR, 0)) { free_state (newstate); newstate = NULL; } return newstate; }

static re_dfastate_t* create_newstate_common (  re_dfa_t *  dfa, const re_node_set *  nodes, unsigned int  hash )  [static]

Definition at line 1087 of file regex_internal.c. References BE, err(), re_dfastate_t::hash, re_dfastate_t::nodes, NULL, re_free, re_node_set_init_copy(), REG_NOERROR, re_dfastate_t::trtable, and re_dfastate_t::trtable_search. Referenced by create_cd_newstate(), and create_ci_newstate(). { re_dfastate_t *newstate; reg_errcode_t err; newstate = (re_dfastate_t *) calloc (sizeof (re_dfastate_t), 1); if (BE (newstate == NULL, 0)) return NULL; err = re_node_set_init_copy (&newstate->nodes, nodes); if (BE (err != REG_NOERROR, 0)) { re_free (newstate); return NULL; } newstate->trtable = NULL; newstate->trtable_search = NULL; newstate->hash = hash; return newstate; }

static void free_state (  re_dfastate_t *  state  )  [static]

Definition at line 1254 of file regex_internal.c. References re_free, and re_node_set_free. Referenced by create_cd_newstate(), create_ci_newstate(), and free_dfa_content(). { if (state->entrance_nodes != &state->nodes) { re_node_set_free (state->entrance_nodes); re_free (state->entrance_nodes); } re_node_set_free (&state->nodes); re_free (state->trtable); re_free (state->trtable_search); re_free (state); }

static re_dfastate_t* re_acquire_state (  reg_errcode_t *  err, re_dfa_t *  dfa, const re_node_set *  nodes )  [static]

Definition at line 997 of file regex_internal.c. References re_state_table_entry::array, BE, calc_state_hash(), create_ci_newstate(), re_dfastate_t::hash, i, re_node_set::nelem, re_dfastate_t::nodes, NULL, re_state_table_entry::num, re_node_set_compare(), REG_ESPACE, REG_NOERROR, state, re_dfa_t::state_hash_mask, and re_dfa_t::state_table. Referenced by check_arrival_add_next_nodes(), expand_bkref_cache(), merge_state_array(), and update_cur_sifted_state(). { unsigned int hash; re_dfastate_t *new_state; struct re_state_table_entry *spot; int i; if (BE (nodes->nelem == 0, 0)) { *err = REG_NOERROR; return NULL; } hash = calc_state_hash (nodes, 0); spot = dfa->state_table + (hash & dfa->state_hash_mask); for (i = 0 ; i < spot->num ; i++) { re_dfastate_t *state = spot->array[i]; if (hash != state->hash) continue; if (re_node_set_compare (&state->nodes, nodes)) return state; } /* There are no appropriate state in the dfa, create the new one. */ new_state = create_ci_newstate (dfa, nodes, hash); if (BE (new_state != NULL, 1)) return new_state; else { *err = REG_ESPACE; return NULL; } }

static re_dfastate_t* re_acquire_state_context (  reg_errcode_t *  err, re_dfa_t *  dfa, const re_node_set *  nodes, unsigned int  context )  [static]

Definition at line 1045 of file regex_internal.c. References re_state_table_entry::array, BE, calc_state_hash(), re_dfastate_t::context, create_cd_newstate(), re_dfastate_t::entrance_nodes, re_dfastate_t::hash, i, re_node_set::nelem, NULL, re_state_table_entry::num, re_node_set_compare(), REG_ESPACE, REG_NOERROR, state, re_dfa_t::state_hash_mask, and re_dfa_t::state_table. Referenced by acquire_init_state_context(), build_trtable(), check_arrival(), create_initial_state(), transit_state(), transit_state_bkref(), and transit_state_sb(). { unsigned int hash; re_dfastate_t *new_state; struct re_state_table_entry *spot; int i; if (nodes->nelem == 0) { *err = REG_NOERROR; return NULL; } hash = calc_state_hash (nodes, context); spot = dfa->state_table + (hash & dfa->state_hash_mask); for (i = 0 ; i < spot->num ; i++) { re_dfastate_t *state = spot->array[i]; if (hash != state->hash) continue; if (re_node_set_compare (state->entrance_nodes, nodes) && state->context == context) return state; } /* There are no appropriate state in `dfa', create the new one. */ new_state = create_cd_newstate (dfa, nodes, context, hash); if (BE (new_state != NULL, 1)) return new_state; else { *err = REG_ESPACE; return NULL; } }

static int re_dfa_add_node (  re_dfa_t *  dfa, re_token_t  token, int  mode )  [static]

Definition at line 932 of file regex_internal.c. References BE, re_token_t::duplicated, NULL, and re_realloc. Referenced by build_word_op(), duplicate_node(), duplicate_tree(), parse(), parse_bracket_exp(), parse_dup_op(), parse_expression(), parse_reg_exp(), and parse_sub_exp(). { if (dfa->nodes_len >= dfa->nodes_alloc) { re_token_t *new_array; dfa->nodes_alloc *= 2; new_array = re_realloc (dfa->nodes, re_token_t, dfa->nodes_alloc); if (BE (new_array == NULL, 0)) return -1; else dfa->nodes = new_array; if (mode) { int *new_nexts, *new_indices; re_node_set *new_edests, *new_eclosures, *new_inveclosures; new_nexts = re_realloc (dfa->nexts, int, dfa->nodes_alloc); new_indices = re_realloc (dfa->org_indices, int, dfa->nodes_alloc); new_edests = re_realloc (dfa->edests, re_node_set, dfa->nodes_alloc); new_eclosures = re_realloc (dfa->eclosures, re_node_set, dfa->nodes_alloc); new_inveclosures = re_realloc (dfa->inveclosures, re_node_set, dfa->nodes_alloc); if (BE (new_nexts == NULL || new_indices == NULL || new_edests == NULL || new_eclosures == NULL || new_inveclosures == NULL, 0)) return -1; dfa->nexts = new_nexts; dfa->org_indices = new_indices; dfa->edests = new_edests; dfa->eclosures = new_eclosures; dfa->inveclosures = new_inveclosures; } } dfa->nodes[dfa->nodes_len] = token; dfa->nodes[dfa->nodes_len].duplicated = 0; dfa->nodes[dfa->nodes_len].constraint = 0; return dfa->nodes_len++; }

static reg_errcode_t re_node_set_add_intersect (  re_node_set *  dest, const re_node_set *  src1, const re_node_set *  src2 )  [static]

Definition at line 644 of file regex_internal.c. References BE, re_node_set::elems, re_node_set::nelem, NULL, re_realloc, REG_ESPACE, and REG_NOERROR. Referenced by add_epsilon_src_nodes(), and sub_epsilon_src_nodes(). { int i1, i2, id; if (src1->nelem > 0 && src2->nelem > 0) { if (src1->nelem + src2->nelem + dest->nelem > dest->alloc) { dest->alloc = src1->nelem + src2->nelem + dest->nelem; dest->elems = re_realloc (dest->elems, int, dest->alloc); if (BE (dest->elems == NULL, 0)) return REG_ESPACE; } } else return REG_NOERROR; for (i1 = i2 = id = 0 ; i1 < src1->nelem && i2 < src2->nelem ;) { if (src1->elems[i1] > src2->elems[i2]) { ++i2; continue; } if (src1->elems[i1] == src2->elems[i2]) { while (id < dest->nelem && dest->elems[id] < src2->elems[i2]) ++id; if (id < dest->nelem && dest->elems[id] == src2->elems[i2]) ++id; else { memmove (dest->elems + id + 1, dest->elems + id, sizeof (int) * (dest->nelem - id)); dest->elems[id++] = src2->elems[i2++]; ++dest->nelem; } } ++i1; } return REG_NOERROR; }

static reg_errcode_t re_node_set_alloc (  re_node_set *  set, int  size )  [static]

Definition at line 557 of file regex_internal.c. References BE, NULL, re_malloc, REG_ESPACE, and REG_NOERROR. Referenced by build_trtable(), calc_eclosure_iter(), check_arrival_expand_ecl(), and transit_state_sb(). { set->alloc = size; set->nelem = 0; set->elems = re_malloc (int, size); if (BE (set->elems == NULL, 0)) return REG_ESPACE; return REG_NOERROR; }

static int re_node_set_compare (  re_node_set *  set1, re_node_set *  set2 )  const [static]

Definition at line 877 of file regex_internal.c. References i, and NULL. Referenced by re_acquire_state(), and re_acquire_state_context(). { int i; if (set1 == NULL || set2 == NULL || set1->nelem != set2->nelem) return 0; for (i = 0 ; i < set1->nelem ; i++) if (set1->elems[i] != set2->elems[i]) return 0; return 1; }

static int re_node_set_contains (  re_node_set *  set, int  elem )  const [static]

Definition at line 892 of file regex_internal.c. Referenced by check_arrival(), check_arrival_expand_ecl_sub(), check_subexp_limits(), create_initial_state(), expand_bkref_cache(), proceed_next_node(), and sub_epsilon_src_nodes(). { int idx, right, mid; if (set->nelem <= 0) return 0; /* Binary search the element. */ idx = 0; right = set->nelem - 1; while (idx < right) { mid = (idx + right) / 2; if (set->elems[mid] < elem) idx = mid + 1; else right = mid; } return set->elems[idx] == elem ? idx + 1 : 0; }

static reg_errcode_t re_node_set_init_1 (  re_node_set *  set, int  elem )  [static]

Definition at line 570 of file regex_internal.c. References BE, NULL, re_malloc, REG_ESPACE, and REG_NOERROR. Referenced by calc_epsdest(), check_arrival(), expand_bkref_cache(), group_nodes_into_DFAstates(), re_node_set_insert(), and sift_states_backward(). { set->alloc = 1; set->nelem = 1; set->elems = re_malloc (int, 1); if (BE (set->elems == NULL, 0)) { set->alloc = set->nelem = 0; return REG_ESPACE; } set->elems[0] = elem; return REG_NOERROR; }

static reg_errcode_t re_node_set_init_2 (  re_node_set *  set, int  elem1, int  elem2 )  [static]

Definition at line 587 of file regex_internal.c. References BE, NULL, re_malloc, REG_ESPACE, and REG_NOERROR. Referenced by calc_epsdest(). { set->alloc = 2; set->elems = re_malloc (int, 2); if (BE (set->elems == NULL, 0)) return REG_ESPACE; if (elem1 == elem2) { set->nelem = 1; set->elems[0] = elem1; } else { set->nelem = 2; if (elem1 < elem2) { set->elems[0] = elem1; set->elems[1] = elem2; } else { set->elems[0] = elem2; set->elems[1] = elem1; } } return REG_NOERROR; }

static reg_errcode_t re_node_set_init_copy (  re_node_set *  dest, const re_node_set *  src )  [static]

Definition at line 618 of file regex_internal.c. References BE, re_node_set::elems, memcpy, re_node_set::nelem, NULL, re_malloc, re_node_set_init_empty, REG_ESPACE, and REG_NOERROR. Referenced by add_epsilon_src_nodes(), check_arrival(), create_cd_newstate(), create_initial_state(), create_newstate_common(), expand_bkref_cache(), group_nodes_into_DFAstates(), push_fail_stack(), re_node_set_init_union(), and sift_states_bkref(). { dest->nelem = src->nelem; if (src->nelem > 0) { dest->alloc = dest->nelem; dest->elems = re_malloc (int, dest->alloc); if (BE (dest->elems == NULL, 0)) { dest->alloc = dest->nelem = 0; return REG_ESPACE; } memcpy (dest->elems, src->elems, src->nelem * sizeof (int)); } else re_node_set_init_empty (dest); return REG_NOERROR; }

static reg_errcode_t re_node_set_init_union (  re_node_set *  dest, const re_node_set *  src1, const re_node_set *  src2 )  [static]

Definition at line 692 of file regex_internal.c. References BE, re_node_set::elems, memcpy, re_node_set::nelem, NULL, re_malloc, re_node_set_init_copy(), re_node_set_init_empty, REG_ESPACE, and REG_NOERROR. Referenced by merge_state_array(), transit_state(), and transit_state_bkref(). { int i1, i2, id; if (src1 != NULL && src1->nelem > 0 && src2 != NULL && src2->nelem > 0) { dest->alloc = src1->nelem + src2->nelem; dest->elems = re_malloc (int, dest->alloc); if (BE (dest->elems == NULL, 0)) return REG_ESPACE; } else { if (src1 != NULL && src1->nelem > 0) return re_node_set_init_copy (dest, src1); else if (src2 != NULL && src2->nelem > 0) return re_node_set_init_copy (dest, src2); else re_node_set_init_empty (dest); return REG_NOERROR; } for (i1 = i2 = id = 0 ; i1 < src1->nelem && i2 < src2->nelem ;) { if (src1->elems[i1] > src2->elems[i2]) { dest->elems[id++] = src2->elems[i2++]; continue; } if (src1->elems[i1] == src2->elems[i2]) ++i2; dest->elems[id++] = src1->elems[i1++]; } if (i1 < src1->nelem) { memcpy (dest->elems + id, src1->elems + i1, (src1->nelem - i1) * sizeof (int)); id += src1->nelem - i1; } else if (i2 < src2->nelem) { memcpy (dest->elems + id, src2->elems + i2, (src2->nelem - i2) * sizeof (int)); id += src2->nelem - i2; } dest->nelem = id; return REG_NOERROR; }

static int re_node_set_insert (  re_node_set *  set, int  elem )  [static]

Definition at line 816 of file regex_internal.c. References BE, memcpy, NULL, re_free, re_malloc, re_node_set_init_1(), and REG_NOERROR. Referenced by calc_eclosure_iter(), calc_inveclosure(), check_arrival_add_next_nodes(), check_arrival_expand_ecl_sub(), duplicate_node_closure(), expand_bkref_cache(), group_nodes_into_DFAstates(), proceed_next_node(), sift_states_backward(), and sift_states_bkref(). { int idx, right, mid; /* In case of the set is empty. */ if (set->elems == NULL || set->alloc == 0) { if (BE (re_node_set_init_1 (set, elem) == REG_NOERROR, 1)) return 1; else return -1; } /* Binary search the spot we will add the new element. */ idx = 0; right = set->nelem; while (idx < right) { mid = (idx + right) / 2; if (set->elems[mid] < elem) idx = mid + 1; else right = mid; } /* Realloc if we need. */ if (set->alloc < set->nelem + 1) { int *new_array; set->alloc = set->alloc * 2; new_array = re_malloc (int, set->alloc); if (BE (new_array == NULL, 0)) return -1; /* Copy the elements they are followed by the new element. */ if (idx > 0) memcpy (new_array, set->elems, sizeof (int) * (idx)); /* Copy the elements which follows the new element. */ if (set->nelem - idx > 0) memcpy (new_array + idx + 1, set->elems + idx, sizeof (int) * (set->nelem - idx)); re_free (set->elems); set->elems = new_array; } else { /* Move the elements which follows the new element. */ if (set->nelem - idx > 0) memmove (set->elems + idx + 1, set->elems + idx, sizeof (int) * (set->nelem - idx)); } /* Insert the new element. */ set->elems[idx] = elem; ++set->nelem; return 1; }

static reg_errcode_t re_node_set_merge (  re_node_set *  dest, const re_node_set *  src )  [static]

Definition at line 745 of file regex_internal.c. References BE, re_node_set::elems, memcpy, re_node_set::nelem, NULL, re_realloc, REG_ESPACE, and REG_NOERROR. Referenced by build_trtable(), calc_eclosure_iter(), check_arrival(), check_arrival_add_next_nodes(), check_arrival_expand_ecl(), create_initial_state(), expand_bkref_cache(), and transit_state_sb(). { int si, di; if (src == NULL || src->nelem == 0) return REG_NOERROR; if (dest->alloc < src->nelem + dest->nelem) { int *new_buffer; dest->alloc = 2 * (src->nelem + dest->alloc); new_buffer = re_realloc (dest->elems, int, dest->alloc); if (BE (new_buffer == NULL, 0)) return REG_ESPACE; dest->elems = new_buffer; } for (si = 0, di = 0 ; si < src->nelem && di < dest->nelem ;) { int cp_from, ncp, mid, right, src_elem = src->elems[si]; /* Binary search the spot we will add the new element. */ right = dest->nelem; while (di < right) { mid = (di + right) / 2; if (dest->elems[mid] < src_elem) di = mid + 1; else right = mid; } if (di >= dest->nelem) break; if (dest->elems[di] == src_elem) { /* Skip since, DEST already has the element. */ ++di; ++si; continue; } /* Skip the src elements which are less than dest->elems[di]. */ cp_from = si; while (si < src->nelem && src->elems[si] < dest->elems[di]) ++si; /* Copy these src elements. */ ncp = si - cp_from; memmove (dest->elems + di + ncp, dest->elems + di, sizeof (int) * (dest->nelem - di)); memcpy (dest->elems + di, src->elems + cp_from, sizeof (int) * ncp); /* Update counters. */ di += ncp; dest->nelem += ncp; } /* Copy remaining src elements. */ if (si < src->nelem) { memcpy (dest->elems + di, src->elems + si, sizeof (int) * (src->nelem - si)); dest->nelem += src->nelem - si; } return REG_NOERROR; }

static void re_node_set_remove_at (  re_node_set *  set, int  idx )  [static]

Definition at line 915 of file regex_internal.c. Referenced by create_cd_newstate(), and sub_epsilon_src_nodes(). { if (idx < 0 || idx >= set->nelem) return; if (idx < set->nelem - 1) memmove (set->elems + idx, set->elems + idx + 1, sizeof (int) * (set->nelem - idx - 1)); --set->nelem; }