diff src/regex.c @ 11656:a40849041718

(union fail_stack_elt): New union. (fail_stack_elt_t): Use that union. (PUSH_PATTERN_OP, PUSH_FAILURE_POINTER, PUSH_FAILURE_INT) (POP_FAILURE_POINTER, POP_FAILURE_INT): Corresponding changes. (re_compile_fastmap): Corresponding changes. (PUSH_FAILURE_ELT): New macro. (FAIL_STACK_TOP): Macro deleted. (WIDE_INT): Macro deleted. (PUSH_FAILURE_POINT): Use PUSH_FAILURE_ELT. (POP_FAILURE_ELT): New macro. (POP_FAILURE_POINT): Use POP_FAILURE_ELT.

--- a/src/regex.c	Tue May 02 04:50:07 1995 +0000
+++ b/src/regex.c	Tue May 02 16:27:24 1995 +0000
@@ -49,8 +49,6 @@
 #include "buffer.h"
 #include "syntax.h"
 
-#define WIDE_INT EMACS_INT
-
 #else  /* not emacs */
 
 #ifdef STDC_HEADERS
@@ -60,11 +58,6 @@
 char *realloc ();
 #endif
 
-/* This isn't right--it needs to check for machines with 64-bit pointers
-   and do something different.  But I don't know what, and I don't
-   need to deal with it right now.  -- rms.  */
-#define WIDE_INT int
-
 /* We used to test for `BSTRING' here, but only GCC and Emacs define
    `BSTRING', as far as I know, and neither of them use this code.  */
 #ifndef INHIBIT_STRING_HEADER
@@ -990,7 +983,13 @@
 int re_max_failures = 2000;
 #endif
 
-typedef unsigned char *fail_stack_elt_t;
+union fail_stack_elt
+{
+  unsigned char *pointer;
+  int integer;
+};
+
+typedef union fail_stack_elt fail_stack_elt_t;
 
 typedef struct
 {
@@ -1002,7 +1001,6 @@
 #define FAIL_STACK_EMPTY()     (fail_stack.avail == 0)
 #define FAIL_STACK_PTR_EMPTY() (fail_stack_ptr->avail == 0)
 #define FAIL_STACK_FULL()      (fail_stack.avail == fail_stack.size)
-#define FAIL_STACK_TOP()       (fail_stack.stack[fail_stack.avail])
 
 
 /* Initialize `fail_stack'.  Do `return -2' if the alloc fails.  */
@@ -1048,34 +1046,39 @@
          1)))
 
 
-/* Push PATTERN_OP on FAIL_STACK. 
-
+/* Push pointer POINTER on FAIL_STACK. 
    Return 1 if was able to do so and 0 if ran out of memory allocating
    space to do so.  */
-#define PUSH_PATTERN_OP(pattern_op, fail_stack)				\
+#define PUSH_PATTERN_OP(POINTER, FAIL_STACK)				\
   ((FAIL_STACK_FULL ()							\
-    && !DOUBLE_FAIL_STACK (fail_stack))					\
+    && !DOUBLE_FAIL_STACK (FAIL_STACK))					\
    ? 0									\
-   : ((fail_stack).stack[(fail_stack).avail++] = pattern_op,		\
+   : ((FAIL_STACK).stack[(FAIL_STACK).avail++].pointer = POINTER,	\
       1))
 
 /* Push a pointer value onto the failure stack.
    Assumes the variable `fail_stack'.  Probably should only
    be called from within `PUSH_FAILURE_POINT'.  */
 #define PUSH_FAILURE_POINTER(item)					\
-  fail_stack.stack[fail_stack.avail++] = (fail_stack_elt_t) (item)
+  fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (item)
 
 /* This pushes an integer-valued item onto the failure stack.
    Assumes the variable `fail_stack'.  Probably should only
    be called from within `PUSH_FAILURE_POINT'.  */
 #define PUSH_FAILURE_INT(item)					\
-  fail_stack.stack[fail_stack.avail++] = (fail_stack_elt_t) (WIDE_INT) (item)
-
-/* The complement operation.  Assumes `fail_stack' is nonempty.  */
-#define POP_FAILURE_POINTER() fail_stack.stack[--fail_stack.avail]
-
-/* The complement operation.  Assumes `fail_stack' is nonempty.  */
-#define POP_FAILURE_INT() (WIDE_INT) fail_stack.stack[--fail_stack.avail]
+  fail_stack.stack[fail_stack.avail++].integer = (item)
+
+/* Push a fail_stack_elt_t value onto the failure stack.
+   Assumes the variable `fail_stack'.  Probably should only
+   be called from within `PUSH_FAILURE_POINT'.  */
+#define PUSH_FAILURE_ELT(item)					\
+  fail_stack.stack[fail_stack.avail++] =  (item)
+
+/* These three POP... operations complement the three PUSH... operations.
+   All assume that `fail_stack' is nonempty.  */
+#define POP_FAILURE_POINTER() fail_stack.stack[--fail_stack.avail].pointer
+#define POP_FAILURE_INT() fail_stack.stack[--fail_stack.avail].integer
+#define POP_FAILURE_ELT() fail_stack.stack[--fail_stack.avail]
 
 /* Used to omit pushing failure point id's when we're not debugging.  */
 #ifdef DEBUG
@@ -1147,7 +1150,7 @@
         DEBUG_PRINT2 (" ever_matched=%d",				\
                       EVER_MATCHED_SOMETHING (reg_info[this_reg]));	\
 	DEBUG_PRINT1 ("\n");						\
-        PUSH_FAILURE_POINTER (reg_info[this_reg].word);			\
+        PUSH_FAILURE_ELT (reg_info[this_reg].word);			\
       }									\
 									\
     DEBUG_PRINT2 ("  Pushing  low active reg: %d\n", lowest_active_reg);\
@@ -1249,7 +1252,7 @@
     {									\
       DEBUG_PRINT2 ("    Popping reg: %d\n", this_reg);			\
 									\
-      reg_info[this_reg].word = POP_FAILURE_POINTER ();			\
+      reg_info[this_reg].word = POP_FAILURE_ELT ();			\
       DEBUG_PRINT2 ("      info: 0x%x\n", reg_info[this_reg]);		\
 									\
       regend[this_reg] = (const char *) POP_FAILURE_POINTER ();		\
@@ -1266,8 +1269,7 @@
 
 
 /* Structure for per-register (a.k.a. per-group) information.
-   This must not be longer than one word, because we push this value
-   onto the failure stack.  Other register information, such as the
+   Other register information, such as the
    starting and ending positions (which are addresses), and the list of
    inner groups (which is a bits list) are maintained in separate
    variables.  
@@ -1276,6 +1278,7 @@
    the compiler will pack our bit fields into something that fits into
    the type of `word', i.e., is something that fits into one item on the
    failure stack.  */
+
 typedef union
 {
   fail_stack_elt_t word;
@@ -2895,7 +2898,7 @@
 	      /* Reset for next path.  */
 	      path_can_be_null = true;
 
-	      p = fail_stack.stack[--fail_stack.avail];
+	      p = fail_stack.stack[--fail_stack.avail].pointer;
 
 	      continue;
 	    }
@@ -3047,7 +3050,7 @@
 	  
           /* If what's on the stack is where we are now, pop it.  */
           if (!FAIL_STACK_EMPTY () 
-	      && fail_stack.stack[fail_stack.avail - 1] == p)
+	      && fail_stack.stack[fail_stack.avail - 1].pointer == p)
             fail_stack.avail--;
 
           continue;