*** empty log message ***

diff --git a/regex.c b/regex.c
index 4513cb1..8cabea7 100644 (file)
--- a/regex.c
+++ b/regex.c
@@ -888,7 +888,7 @@ static const char *re_error_msg[] =
 \f
 /* Avoiding alloca during matching, to placate r_alloc.  */
 
-/* Define MATCH_MAY_ALLOCATE if we need to make sure that the
+/* Define MATCH_MAY_ALLOCATE unless we need to make sure that the
    searching and matching functions should not call alloca.  On some
    systems, alloca is implemented in terms of malloc, and if we're
    using the relocating allocator routines, then malloc could cause a
@@ -1256,6 +1256,7 @@ typedef union
    We make the fail stack a global thing, and then grow it to
    re_max_failures when we compile.  */
 #ifndef MATCH_MAY_ALLOCATE
+static int fail_stack_allocated;
 static fail_stack_type fail_stack;
 
 static const char **     regstart, **     regend;
@@ -2493,10 +2494,19 @@ regex_compile (pattern, size, syntax, bufp)
        is strictly greater than re_max_failures, the largest possible stack
        is 2 * re_max_failures failure points.  */
     fail_stack.size = (2 * re_max_failures * MAX_FAILURE_ITEMS);
-    if (! fail_stack.stack)
-      fail_stack.stack =
-       (fail_stack_elt_t *) malloc (fail_stack.size 
-                                    * sizeof (fail_stack_elt_t));
+    if (fail_stack.size > fail_stack_allocated)
+      {
+       if (! fail_stack.stack)
+         fail_stack.stack =
+           (fail_stack_elt_t *) malloc (fail_stack.size 
+                                        * sizeof (fail_stack_elt_t));
+       else
+         fail_stack.stack =
+           (fail_stack_elt_t *) realloc (fail_stack.stack,
+                                         (fail_stack.size
+                                          * sizeof (fail_stack_elt_t)));
+       fail_stack_allocated = fail_stack.size;
+      }
 
     /* Initialize some other variables the matcher uses.  */
     RETALLOC_IF (regstart,      num_regs, const char *);