Lines Matching defs:stack
297 /* Define how to allocate the failure stack. */
1414 failure stack, but we would still use it for the register vectors;
1423 /* Failure stack declarations and macros; both re_compile_fastmap and
1424 re_match_2 use a failure stack. These have to be macros because of
1435 /* Roughly the maximum number of failure points on the stack. Would be
1445 whose default stack limit is 2mb. */
1462 PREFIX(fail_stack_elt_t) *stack;
1472 whose default stack limit is 2mb. */
1489 PREFIX(fail_stack_elt_t) *stack;
1503 /* Define macros to initialize and free the failure stack.
1509 fail_stack.stack = (PREFIX(fail_stack_elt_t) *) \
1512 if (fail_stack.stack == NULL) \
1519 # define RESET_FAIL_STACK() REGEX_FREE_STACK (fail_stack.stack)
1540 : ((fail_stack).stack = (PREFIX(fail_stack_elt_t) *) \
1541 REGEX_REALLOCATE_STACK ((fail_stack).stack, \
1545 (fail_stack).stack == NULL \
1558 : ((FAIL_STACK).stack[(FAIL_STACK).avail++].pointer = POINTER, \
1561 /* Push a pointer value onto the failure stack.
1565 fail_stack.stack[fail_stack.avail++].pointer = (UCHAR_T *) (item)
1567 /* This pushes an integer-valued item onto the failure stack.
1571 fail_stack.stack[fail_stack.avail++].integer = (item)
1573 /* Push a fail_stack_elt_t value onto the failure stack.
1577 fail_stack.stack[fail_stack.avail++] = (item)
1581 # define POP_FAILURE_POINTER() fail_stack.stack[--fail_stack.avail].pointer
1582 # define POP_FAILURE_INT() fail_stack.stack[--fail_stack.avail].integer
1583 # define POP_FAILURE_ELT() fail_stack.stack[--fail_stack.avail]
1629 DEBUG_PRINT2 ("\n Doubled stack; size now: %d\n", \
1684 /* This is the number of items that are pushed and popped on the stack
1695 /* We push at most this many items on the stack. */
1698 to avoid stack overflow for a regexp with lots of parens. */
1708 /* How many items can still be added to the stack without overflowing it. */
1804 failure stack. */
2124 /* Macros for the compile stack. */
2143 compile_stack_elt_t *stack;
2155 # define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail])
2217 we make the fail stack and register vectors global.
2218 The fail stack, we grow to the maximum size when a regexp
2292 return (free(pattern), free(mbs_offset), free(is_binary), free (compile_stack.stack), value)
2295 return (free (compile_stack.stack), value)
2362 matching close-group on the compile stack, so the same register
2402 /* Initialize the compile stack. */
2403 compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t);
2404 if (compile_stack.stack == NULL)
3675 RETALLOC (compile_stack.stack, compile_stack.size << 1,
3677 if (compile_stack.stack == NULL) return REG_ESPACE;
3748 /* Since we just checked for an empty stack above, this
4175 free (compile_stack.stack);
4193 /* Initialize the failure stack to the largest possible stack. This
4200 is strictly greater than re_max_failures, the largest possible stack
4207 if (! fail_stack.stack)
4208 fail_stack.stack
4212 fail_stack.stack
4213 = (PREFIX(fail_stack_elt_t) *) xrealloc (fail_stack.stack,
4217 if (! fail_stack.stack)
4218 fail_stack.stack
4221 fail_stack.stack
4222 = realloc (fail_stack.stack,
4346 if (compile_stack.stack[this_element].regnum == regnum)
4575 /* This holds the pointer to the failure stack, when
4608 p = fail_stack.stack[--fail_stack.avail].pointer;
4778 /* If what's on the stack is where we are now, pop it. */
4780 && fail_stack.stack[fail_stack.avail - 1].pointer == p)
4852 stack), or quit if no more. The test at the top of the loop
4961 stack overflow). */
5346 REGEX_FREE_STACK (fail_stack.stack); \
5367 REGEX_FREE_STACK (fail_stack.stack); \
5467 failure stack overflowing). Otherwise, we return the length of the
5615 /* Failure point stack. Each place that can handle a failure further
5616 down the line pushes a failure point on this stack. It consists of
5633 /* This holds the pointer to the failure stack, when
6800 by forcing a failure after pushing on the stack the
6974 pushes NULL as the value for the string on the stack. Then
6984 sure the right things get saved on the stack. Hence we don't
6986 stack at all is that otherwise we would have to change
7235 register from the stack, since lowest will == highest in