build/libgnuregex/regex.c

979 /* Macros for the compile stack.  */
997   compile_stack_elt_t *stack;
1009 #define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail])
1116      matching close-group on the compile stack, so the same register
1132   /* Initialize the compile stack.  */
1133   compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t);
1134   if (compile_stack.stack == NULL)
1587                   RETALLOC (compile_stack.stack, compile_stack.size << 1,
1589                   if (compile_stack.stack == NULL) return REG_ESPACE;
1655               /* Since we just checked for an empty stack above, this
2045   free (compile_stack.stack);
2185     if (compile_stack.stack[this_element].regnum == regnum)
2249 /* Failure stack declarations and macros; both re_compile_fastmap and
2250    re_match_2 use a failure stack.  These have to be macros because of
2261 /* Roughly the maximum number of failure points on the stack.  Would be
2271   fail_stack_elt_t *stack;
2279 #define FAIL_STACK_TOP()       (fail_stack.stack[fail_stack.avail])
2286     fail_stack.stack = (fail_stack_elt_t *)				\
2289     if (fail_stack.stack == NULL)					\
2307    : ((fail_stack).stack = (fail_stack_elt_t *)				\
2308         REGEX_REALLOCATE ((fail_stack).stack, 				\
2312       (fail_stack).stack == NULL					\
2326     : ((fail_stack).stack[(fail_stack).avail++] = pattern_op,		\
2329 /* This pushes an item onto the failure stack.  Must be a four-byte
2333   fail_stack.stack[fail_stack.avail++] = (fail_stack_elt_t) item
2336 #define POP_FAILURE_ITEM() fail_stack.stack[--fail_stack.avail]
2379         DEBUG_PRINT2 ("\n  Doubled stack; size now: %d\n",		\
2431 /* This is the number of items that are pushed and popped on the stack
2442 /* We push at most this many items on the stack.  */
2450 /* How many items can still be added to the stack without overflowing it.  */
2546   /* We don't push any register information onto the failure stack.  */
2580           p = fail_stack.stack[--fail_stack.avail];
2726           /* If what's on the stack is where we are now, pop it.  */
2728 	      && fail_stack.stack[fail_stack.avail - 1] == p)
2797          stack), or quit if no more.  The test at the top of the loop
2882    stack overflow).  */
3010    onto the failure stack.  Other register information, such as the
3018    failure stack.  */
3112     FREE_VAR (fail_stack.stack);					\
3167    failure stack overflowing).  Otherwise, we return the length of the
3200   /* Failure point stack.  Each place that can handle a failure further
3201      down the line pushes a failure point on this stack.  It consists of
3748                  by forcing a failure after pushing on the stack the
3907            pushes NULL as the value for the string on the stack.  Then
3917            sure the right things get saved on the stack.  Hence we don't
3919            stack at all is that otherwise we would have to change
4080                register from the stack, since lowest will == highest in