(DISCARD_FAILURE_REG_OR_COUNT): New macro.

(CHECK_INFINITE_LOOP): Use DISCARD_FAILURE_REG_OR_COUNT
when jumping to `fail' to avoid undoing reg changes in the
last iteration of the loop.
(GET_UNSIGNED_NUMBER): Skip spaces around the number.

diff --git a/src/ChangeLog b/src/ChangeLog
index 9d4dfa7dda0c1496b75aaf8aa37c2fd4383bbaae..d215a29bd70252ba86b7c1a28d5167d797939604 100644 (file)
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,5 +1,11 @@
 2002-03-21  Richard M. Stallman  <rms@gnu.org>
 
+       * regex.c (DISCARD_FAILURE_REG_OR_COUNT): New macro.
+       (CHECK_INFINITE_LOOP): Use DISCARD_FAILURE_REG_OR_COUNT
+       when jumping to `fail' to avoid undoing reg changes in the
+       last iteration of the loop.
+       (GET_UNSIGNED_NUMBER): Skip spaces around the number.
+
        * Makefile.in (dispnew.o, sysdep.o, xdisp.o, xselect.o, alloc.o):
        Depend on process.h.
 

diff --git a/src/regex.c b/src/regex.c
index 37436fffba0fe3e5feb0670114b101149ea619c7..cd05bf8860bd1c4dfc17301d86dec1ec6af4ee99 100644 (file)
--- a/src/regex.c
+++ b/src/regex.c
@@ -1518,19 +1518,43 @@ do {                                                                    \
     }                                                                  \
 } while (0)
 
+/* Discard a saved register off the stack.  */
+#define DISCARD_FAILURE_REG_OR_COUNT()                                 \
+do {                                                                   \
+  int reg = POP_FAILURE_INT ();                                                \
+  if (reg == -1)                                                       \
+    {                                                                  \
+      /* It's a counter.  */                                           \
+      POP_FAILURE_POINTER ();                                          \
+      reg = POP_FAILURE_INT ();                                                \
+      DEBUG_PRINT3 ("     Discard counter %p = %d\n", ptr, reg);       \
+    }                                                                  \
+  else                                                                 \
+    {                                                                  \
+      POP_FAILURE_POINTER ();                                          \
+      POP_FAILURE_POINTER ();                                          \
+      DEBUG_PRINT4 ("     Discard reg %d (spanning %p -> %p)\n",       \
+                   reg, regstart[reg], regend[reg]);                   \
+    }                                                                  \
+} while (0)
+
 /* Check that we are not stuck in an infinite loop.  */
 #define CHECK_INFINITE_LOOP(pat_cur, string_place)                     \
 do {                                                                   \
-  int failure = TOP_FAILURE_HANDLE();                                  \
+  int failure = TOP_FAILURE_HANDLE ();                                 \
   /* Check for infinite matching loops */                              \
-  while (failure > 0 &&                                                        \
-        (FAILURE_STR (failure) == string_place                         \
-         || FAILURE_STR (failure) == NULL))                            \
+  while (failure > 0                                                   \
+        && (FAILURE_STR (failure) == string_place                      \
+            || FAILURE_STR (failure) == NULL))                         \
     {                                                                  \
       assert (FAILURE_PAT (failure) >= bufp->buffer                    \
              && FAILURE_PAT (failure) <= bufp->buffer + bufp->used);   \
       if (FAILURE_PAT (failure) == pat_cur)                            \
-       goto fail;                                                      \
+       {                                                               \
+         while (fail_stack.frame < fail_stack.avail)                   \
+           DISCARD_FAILURE_REG_OR_COUNT ();                            \
+         goto fail;                                                    \
+       }                                                               \
       DEBUG_PRINT2 ("  Other pattern: %p\n", FAILURE_PAT (failure));   \
       failure = NEXT_FAILURE_HANDLE(failure);                          \
     }                                                                  \
@@ -1920,15 +1944,21 @@ struct range_table_work_area
  do { if (p != pend)                                                   \
      {                                                                 \
        PATFETCH (c);                                                   \
+       while (c == ' ') PATFETCH (c);                                  \
        while ('0' <= c && c <= '9')                                    \
         {                                                              \
+           int prev;                                                   \
           if (num < 0)                                                 \
-             num = 0;                                                  \
+            num = 0;                                                   \
+          prev = num;                                                  \
           num = num * 10 + c - '0';                                    \
+          if (num / 10 != prev)                                        \
+            FREE_STACK_RETURN (REG_BADBR);                             \
           if (p == pend)                                               \
-             break;                                                    \
+            break;                                                     \
           PATFETCH (c);                                                \
         }                                                              \
+       while (c == ' ') PATFETCH (c);                                  \
        }                                                               \
     } while (0)