Lines Matching defs:stack
325 /* Define how to allocate the failure stack. */
1130 failure stack, but we would still use it for the register vectors;
1138 /* Failure stack declarations and macros; both re_compile_fastmap and
1139 re_match_2 use a failure stack. These have to be macros because of
1150 /* Roughly the maximum number of failure points on the stack. Would be
1159 whose default stack limit is 2mb. */
1175 fail_stack_elt_t *stack;
1184 whose default stack limit is 2mb. */
1200 fail_stack_elt_t *stack;
1212 /* Define macros to initialize and free the failure stack.
1218 fail_stack.stack = (fail_stack_elt_t *) \
1221 if (fail_stack.stack == NULL) \
1228 # define RESET_FAIL_STACK() REGEX_FREE_STACK (fail_stack.stack)
1249 : ((fail_stack).stack = (fail_stack_elt_t *) \
1250 REGEX_REALLOCATE_STACK ((fail_stack).stack, \
1254 (fail_stack).stack == NULL \
1267 : ((FAIL_STACK).stack[(FAIL_STACK).avail++].pointer = POINTER, \
1270 /* Push a pointer value onto the failure stack.
1274 fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (item)
1276 /* This pushes an integer-valued item onto the failure stack.
1280 fail_stack.stack[fail_stack.avail++].integer = (item)
1282 /* Push a fail_stack_elt_t value onto the failure stack.
1286 fail_stack.stack[fail_stack.avail++] = (item)
1290 #define POP_FAILURE_POINTER() fail_stack.stack[--fail_stack.avail].pointer
1291 #define POP_FAILURE_INT() fail_stack.stack[--fail_stack.avail].integer
1292 #define POP_FAILURE_ELT() fail_stack.stack[--fail_stack.avail]
1338 DEBUG_PRINT2 ("\n Doubled stack; size now: %d\n", \
1392 /* This is the number of items that are pushed and popped on the stack
1403 /* We push at most this many items on the stack. */
1406 to avoid stack overflow for a regexp with lots of parens. */
1416 /* How many items can still be added to the stack without overflowing it. */
1514 failure stack. */
1735 /* Macros for the compile stack. */
1754 compile_stack_elt_t *stack;
1766 #define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail])
1824 we make the fail stack and register vectors global.
1825 The fail stack, we grow to the maximum size when a regexp
1894 return (free (compile_stack.stack), value)
1948 matching close-group on the compile stack, so the same register
1964 /* Initialize the compile stack. */
1965 compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t);
1966 if (compile_stack.stack == NULL)
2464 RETALLOC (compile_stack.stack, compile_stack.size << 1,
2466 if (compile_stack.stack == NULL) return REG_ESPACE;
2536 /* Since we just checked for an empty stack above, this
2947 free (compile_stack.stack);
2961 /* Initialize the failure stack to the largest possible stack. This
2968 is strictly greater than re_max_failures, the largest possible stack
2975 if (! fail_stack.stack)
2976 fail_stack.stack
2980 fail_stack.stack
2981 = (fail_stack_elt_t *) xrealloc (fail_stack.stack,
2985 if (! fail_stack.stack)
2986 fail_stack.stack
2990 fail_stack.stack
2991 = (fail_stack_elt_t *) realloc (fail_stack.stack,
3128 if (compile_stack.stack[this_element].regnum == regnum)
3224 /* This holds the pointer to the failure stack, when
3257 p = fail_stack.stack[--fail_stack.avail].pointer;
3407 /* If what's on the stack is where we are now, pop it. */
3409 && fail_stack.stack[fail_stack.avail - 1].pointer == p)
3481 stack), or quit if no more. The test at the top of the loop
3578 stack overflow). */
3776 REGEX_FREE_STACK (fail_stack.stack); \
3850 failure stack overflowing). Otherwise, we return the length of the
3911 /* Failure point stack. Each place that can handle a failure further
3912 down the line pushes a failure point on this stack. It consists of
3929 /* This holds the pointer to the failure stack, when
4519 by forcing a failure after pushing on the stack the
4682 pushes NULL as the value for the string on the stack. Then
4692 sure the right things get saved on the stack. Hence we don't
4694 stack at all is that otherwise we would have to change
4934 register from the stack, since lowest will == highest in