Lines Matching refs:stack
355 /* Define how to allocate the failure stack. */
1412 failure stack, but we would still use it for the register vectors;
1421 /* Failure stack declarations and macros; both re_compile_fastmap and
1422 re_match_2 use a failure stack. These have to be macros because of
1433 /* Roughly the maximum number of failure points on the stack. Would be
1443 whose default stack limit is 2mb. */
1460 PREFIX(fail_stack_elt_t) *stack;
1470 whose default stack limit is 2mb. */
1487 PREFIX(fail_stack_elt_t) *stack;
1501 /* Define macros to initialize and free the failure stack.
1507 fail_stack.stack = (PREFIX(fail_stack_elt_t) *) \
1510 if (fail_stack.stack == NULL) \
1517 # define RESET_FAIL_STACK() REGEX_FREE_STACK (fail_stack.stack)
1538 : ((fail_stack).stack = (PREFIX(fail_stack_elt_t) *) \
1539 REGEX_REALLOCATE_STACK ((fail_stack).stack, \
1543 (fail_stack).stack == NULL \
1556 : ((FAIL_STACK).stack[(FAIL_STACK).avail++].pointer = POINTER, \
1559 /* Push a pointer value onto the failure stack.
1563 fail_stack.stack[fail_stack.avail++].pointer = (UCHAR_T *) (item)
1565 /* This pushes an integer-valued item onto the failure stack.
1569 fail_stack.stack[fail_stack.avail++].integer = (item)
1571 /* Push a fail_stack_elt_t value onto the failure stack.
1575 fail_stack.stack[fail_stack.avail++] = (item)
1579 # define POP_FAILURE_POINTER() fail_stack.stack[--fail_stack.avail].pointer
1580 # define POP_FAILURE_INT() fail_stack.stack[--fail_stack.avail].integer
1581 # define POP_FAILURE_ELT() fail_stack.stack[--fail_stack.avail]
1627 DEBUG_PRINT2 ("\n Doubled stack; size now: %d\n", \
1682 /* This is the number of items that are pushed and popped on the stack
1693 /* We push at most this many items on the stack. */
1696 to avoid stack overflow for a regexp with lots of parens. */
1706 /* How many items can still be added to the stack without overflowing it. */
1802 failure stack. */
2123 /* Macros for the compile stack. */
2142 compile_stack_elt_t *stack;
2154 # define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail])
2216 we make the fail stack and register vectors global.
2217 The fail stack, we grow to the maximum size when a regexp
2290 return (free(pattern), free(mbs_offset), free(is_binary), free (compile_stack.stack), value)
2293 return (free (compile_stack.stack), value)
2359 matching close-group on the compile stack, so the same register
2399 /* Initialize the compile stack. */
2400 compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t);
2401 if (compile_stack.stack == NULL)
3677 RETALLOC (compile_stack.stack, compile_stack.size << 1,
3679 if (compile_stack.stack == NULL) return REG_ESPACE;
3750 /* Since we just checked for an empty stack above, this
4177 free (compile_stack.stack);
4195 /* Initialize the failure stack to the largest possible stack. This
4202 is strictly greater than re_max_failures, the largest possible stack
4209 if (! fail_stack.stack)
4210 fail_stack.stack
4214 fail_stack.stack
4215 = (PREFIX(fail_stack_elt_t) *) xrealloc (fail_stack.stack,
4219 if (! fail_stack.stack)
4220 fail_stack.stack
4224 fail_stack.stack
4225 = (PREFIX(fail_stack_elt_t) *) realloc (fail_stack.stack,
4349 if (compile_stack.stack[this_element].regnum == regnum)
4581 /* This holds the pointer to the failure stack, when
4614 p = fail_stack.stack[--fail_stack.avail].pointer;
4784 /* If what's on the stack is where we are now, pop it. */
4786 && fail_stack.stack[fail_stack.avail - 1].pointer == p)
4858 stack), or quit if no more. The test at the top of the loop
4964 stack overflow). */
5344 REGEX_FREE_STACK (fail_stack.stack); \
5365 REGEX_FREE_STACK (fail_stack.stack); \
5463 failure stack overflowing). Otherwise, we return the length of the
5605 /* Failure point stack. Each place that can handle a failure further
5606 down the line pushes a failure point on this stack. It consists of
5623 /* This holds the pointer to the failure stack, when
6734 by forcing a failure after pushing on the stack the
6898 pushes NULL as the value for the string on the stack. Then
6908 sure the right things get saved on the stack. Hence we don't
6910 stack at all is that otherwise we would have to change
7159 register from the stack, since lowest will == highest in
