Tweak re_registers allocation

* src/regex-emacs.c (re_match_2_internal):
No need to allocate one extra trailing search register;
Emacs does not use it.  Avoid quadratic behavior on
reallocation.

2 files changed, 10 insertions, 18 deletions

diff --git a/src/regex-emacs.c b/src/regex-emacs.c
index 7629492bcf8..8dc69805024 100644
--- a/src/regex-emacs.c
+++ b/src/regex-emacs.c
@@ -3940,8 +3940,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp,
     }
 
   /* Initialize subexpression text positions to -1 to mark ones that no
-     start_memory/stop_memory has been seen for. Also initialize the
-     register information struct.  */
+     start_memory/stop_memory has been seen for.  */
   for (ptrdiff_t reg = 1; reg < num_regs; reg++)
     regstart[reg] = regend[reg] = NULL;
 
@@ -4091,10 +4090,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp,
             {
               /* Have the register data arrays been allocated?  */
               if (bufp->regs_allocated == REGS_UNALLOCATED)
-                { /* No.  So allocate them with malloc.  We need one
-                     extra element beyond 'num_regs' for the '-1' marker
-                     GNU code uses.  */
-                  ptrdiff_t n = max (RE_NREGS, num_regs + 1);
+                { /* No.  So allocate them with malloc.  */
+                  ptrdiff_t n = max (RE_NREGS, num_regs);
                   regs->start = xnmalloc (n, sizeof *regs->start);
                   regs->end = xnmalloc (n, sizeof *regs->end);
                   regs->num_regs = n;
@@ -4104,9 +4101,10 @@ re_match_2_internal (struct re_pattern_buffer *bufp,
                 { /* Yes.  If we need more elements than were already
                      allocated, reallocate them.  If we need fewer, just
                      leave it alone.  */
-                  if (regs->num_regs < num_regs + 1)
+                  ptrdiff_t n = regs->num_regs;
+                  if (n < num_regs)
                     {
-                      ptrdiff_t n = num_regs + 1;
+                      n = max (n + (n >> 1), num_regs);
                       regs->start
                         = xnrealloc (regs->start, n, sizeof *regs->start);
                       regs->end = xnrealloc (regs->end, n, sizeof *regs->end);
@@ -4137,10 +4135,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp,
                 }
 
               /* If the regs structure we return has more elements than
-                 were in the pattern, set the extra elements to -1.  If
-                 we (re)allocated the registers, this is the case,
-                 because we always allocate enough to have at least one
-                 -1 at the end.  */
+                 were in the pattern, set the extra elements to -1.  */
               for (ptrdiff_t reg = num_regs; reg < regs->num_regs; reg++)
                 regs->start[reg] = regs->end[reg] = -1;
             }
@@ -5053,13 +5048,10 @@ re_compile_pattern (const char *pattern, ptrdiff_t length,
                     bool posix_backtracking, const char *whitespace_regexp,
                     struct re_pattern_buffer *bufp)
 {
-  reg_errcode_t ret;
-
-  /* GNU code is written to assume at least RE_NREGS registers will be set
-     (and at least one extra will be -1).  */
   bufp->regs_allocated = REGS_UNALLOCATED;
 
-  ret = regex_compile ((re_char *) pattern, length,
+  reg_errcode_t ret
+      = regex_compile ((re_char *) pattern, length,
                        posix_backtracking,
                        whitespace_regexp,
                        bufp);
diff --git a/src/regex-emacs.h b/src/regex-emacs.h
index 95f743dc2fb..ddf14e0d9e1 100644
--- a/src/regex-emacs.h
+++ b/src/regex-emacs.h
@@ -98,7 +98,7 @@ struct re_pattern_buffer
   bool_bf can_be_null : 1;
 
         /* If REGS_UNALLOCATED, allocate space in the 'regs' structure
-             for 'max (RE_NREGS, re_nsub + 1)' groups.
+             for at least (re_nsub + 1) groups.
            If REGS_REALLOCATE, reallocate space if necessary.
            If REGS_FIXED, use what's there.  */
   unsigned regs_allocated : 2;