1 files changed, 118 insertions, 137 deletions

diff --git a/src/regex.c b/src/regex.c
index 9284be95ffb..a60ff0ce35c 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -340,7 +340,7 @@ enum syntaxcode { Swhitespace = 0, Sword = 1, Ssymbol = 2 };
                        || ((c) >= 'A' && (c) <= 'Z'))   \
                     : SYNTAX (c) == Sword)
 
-# define ISLOWER(c) (LOWERCASEP (c))
+# define ISLOWER(c) lowercasep (c)
 
 # define ISPUNCT(c) (IS_REAL_ASCII (c)                          \
                     ? ((c) > ' ' && (c) < 0177                  \
@@ -351,7 +351,7 @@ enum syntaxcode { Swhitespace = 0, Sword = 1, Ssymbol = 2 };
 
 # define ISSPACE(c) (SYNTAX (c) == Swhitespace)
 
-# define ISUPPER(c) (UPPERCASEP (c))
+# define ISUPPER(c) uppercasep (c)
 
 # define ISWORD(c) (SYNTAX (c) == Sword)
 
@@ -551,8 +551,6 @@ init_syntax_once (void)
 /* (Re)Allocate N items of type T using malloc, or fail.  */
 #define TALLOC(n, t) ((t *) malloc ((n) * sizeof (t)))
 #define RETALLOC(addr, n, t) ((addr) = (t *) realloc (addr, (n) * sizeof (t)))
-#define RETALLOC_IF(addr, n, t) \
-  if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t)
 #define REGEX_TALLOC(n, t) ((t *) REGEX_ALLOCATE ((n) * sizeof (t)))
 
 #define BYTEWIDTH 8 /* In bits.  */
@@ -843,11 +841,6 @@ extract_number_and_incr (destination, source)
   ((p)[2 + CHARSET_BITMAP_SIZE (p)]             \
    + (p)[3 + CHARSET_BITMAP_SIZE (p)] * 0x100)
 
-/* Test if C is listed in the bitmap of charset P.  */
-#define CHARSET_LOOKUP_BITMAP(p, c)                             \
-  ((c) < CHARSET_BITMAP_SIZE (p) * BYTEWIDTH                    \
-   && (p)[2 + (c) / BYTEWIDTH] & (1 << ((c) % BYTEWIDTH)))
-
 /* Return the address of end of RANGE_TABLE.  COUNT is number of
    ranges (which is a pair of (start, end)) in the RANGE_TABLE.  `* 2'
    is start of range and end of range.  `* 3' is size of each start
@@ -861,14 +854,14 @@ extract_number_and_incr (destination, source)
   do                                                                    \
     {                                                                   \
       re_wchar_t range_start, range_end;                                \
-      re_char *p;                                                       \
+      re_char *rtp;                                                     \
       re_char *range_table_end                                          \
         = CHARSET_RANGE_TABLE_END ((range_table), (count));             \
                                                                         \
-      for (p = (range_table); p < range_table_end; p += 2 * 3)          \
+      for (rtp = (range_table); rtp < range_table_end; rtp += 2 * 3)    \
         {                                                               \
-          EXTRACT_CHARACTER (range_start, p);                           \
-          EXTRACT_CHARACTER (range_end, p + 3);                         \
+          EXTRACT_CHARACTER (range_start, rtp);                         \
+          EXTRACT_CHARACTER (range_end, rtp + 3);                       \
                                                                         \
           if (range_start <= (c) && (c) <= range_end)                   \
             {                                                           \
@@ -1274,6 +1267,13 @@ print_double_string (where, string1, size1, string2, size2)
 
 #endif /* not DEBUG */
 
+/* Use this to suppress gcc's `...may be used before initialized' warnings. */
+#ifdef lint
+# define IF_LINT(Code) Code
+#else
+# define IF_LINT(Code) /* empty */
+#endif
+
 /* Set by `re_set_syntax' to the current regexp syntax to recognize.  Can
    also be assigned to arbitrarily: each pattern buffer stores its own
    syntax, so it can be changed between regex compilations.  */
@@ -1413,7 +1413,6 @@ typedef struct
 } fail_stack_type;
 
 #define FAIL_STACK_EMPTY()     (fail_stack.frame == 0)
-#define FAIL_STACK_FULL()      (fail_stack.avail == fail_stack.size)
 
 
 /* Define macros to initialize and free the failure stack.
@@ -1433,8 +1432,6 @@ typedef struct
     fail_stack.avail = 0;                                               \
     fail_stack.frame = 0;                                               \
   } while (0)
-
-# define RESET_FAIL_STACK()  REGEX_FREE_STACK (fail_stack.stack)
 #else
 # define INIT_FAIL_STACK()                                              \
   do {                                                                  \
@@ -1442,7 +1439,8 @@ typedef struct
     fail_stack.frame = 0;                                               \
   } while (0)
 
-# define RESET_FAIL_STACK() ((void)0)
+# define RETALLOC_IF(addr, n, t) \
+  if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t)
 #endif
 
 
@@ -1495,17 +1493,10 @@ typedef struct
 #define PUSH_FAILURE_INT(item)                                  \
   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.
+/* These POP... operations complement the 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]
 
 /* Individual items aside from the registers.  */
 #define NUM_NONREG_ITEMS 3
@@ -1555,22 +1546,22 @@ do {									\
 /* Pop a saved register off the stack.  */
 #define POP_FAILURE_REG_OR_COUNT()                                      \
 do {                                                                    \
-  int reg = POP_FAILURE_INT ();                                         \
-  if (reg == -1)                                                        \
+  int pfreg = POP_FAILURE_INT ();                                       \
+  if (pfreg == -1)                                                      \
     {                                                                   \
       /* It's a counter.  */                                            \
       /* Here, we discard `const', making re_match non-reentrant.  */   \
       unsigned char *ptr = (unsigned char*) POP_FAILURE_POINTER ();     \
-      reg = POP_FAILURE_INT ();                                         \
-      STORE_NUMBER (ptr, reg);                                          \
-      DEBUG_PRINT3 ("     Pop counter %p = %d\n", ptr, reg);            \
+      pfreg = POP_FAILURE_INT ();                                       \
+      STORE_NUMBER (ptr, pfreg);                                        \
+      DEBUG_PRINT3 ("     Pop counter %p = %d\n", ptr, pfreg);          \
     }                                                                   \
   else                                                                  \
     {                                                                   \
-      regend[reg] = POP_FAILURE_POINTER ();                             \
-      regstart[reg] = POP_FAILURE_POINTER ();                           \
+      regend[pfreg] = POP_FAILURE_POINTER ();                           \
+      regstart[pfreg] = POP_FAILURE_POINTER ();                         \
       DEBUG_PRINT4 ("     Pop reg %d (spanning %p -> %p)\n",            \
-                    reg, regstart[reg], regend[reg]);                   \
+                    pfreg, regstart[pfreg], regend[pfreg]);             \
     }                                                                   \
 } while (0)
 
@@ -1765,16 +1756,6 @@ static int analyse_first _RE_ARGS ((re_char *p, re_char *pend,
   } while (0)
 
 
-/* As with BUF_PUSH_2, except for three bytes.  */
-#define BUF_PUSH_3(c1, c2, c3)                                          \
-  do {                                                                  \
-    GET_BUFFER_SPACE (3);                                               \
-    *b++ = (unsigned char) (c1);                                        \
-    *b++ = (unsigned char) (c2);                                        \
-    *b++ = (unsigned char) (c3);                                        \
-  } while (0)
-
-
 /* Store a jump with opcode OP at LOC to location TO.  We store a
    relative address offset by the three bytes the jump itself occupies.  */
 #define STORE_JUMP(op, loc, to) \
@@ -2524,9 +2505,6 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
   /* We fetch characters from PATTERN here.  */
   register re_wchar_t c, c1;
 
-  /* A random temporary spot in PATTERN.  */
-  re_char *p1;
-
   /* Points to the end of the buffer, where we should append.  */
   register unsigned char *b;
 
@@ -2574,17 +2552,14 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
   /* If the object matched can contain multibyte characters.  */
   const boolean multibyte = RE_MULTIBYTE_P (bufp);
 
-  /* If a target of matching can contain multibyte characters.  */
-  const boolean target_multibyte = RE_TARGET_MULTIBYTE_P (bufp);
-
   /* Nonzero if we have pushed down into a subpattern.  */
   int in_subpattern = 0;
 
   /* These hold the values of p, pattern, and pend from the main
      pattern when we have pushed into a subpattern.  */
-  re_char *main_p;
-  re_char *main_pattern;
-  re_char *main_pend;
+  re_char *main_p IF_LINT (= NULL);
+  re_char *main_pattern IF_LINT (= NULL);
+  re_char *main_pend IF_LINT (= NULL);
 
 #ifdef DEBUG
   debug++;
@@ -2894,6 +2869,8 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
 
         case '[':
           {
+            re_char *p1;
+
             CLEAR_RANGE_TABLE_WORK_USED (range_table_work);
 
             if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
@@ -2929,7 +2906,7 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
               {
                 boolean escaped_char = false;
                 const unsigned char *p2 = p;
-                re_wchar_t ch, c2;
+                re_wchar_t ch;
 
                 if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
 
@@ -2992,10 +2969,7 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
                        them).  */
                     if (c == ':' && *p == ']')
                       {
-                        re_wctype_t cc;
-                        int limit;
-
-                        cc = re_wctype (str);
+                        re_wctype_t cc = re_wctype (str);
 
                         if (cc == 0)
                           FREE_STACK_RETURN (REG_ECTYPE);
@@ -4329,10 +4303,6 @@ WEAK_ALIAS (__re_search, re_search)
 #define HEAD_ADDR_VSTRING(P)            \
   (((P) >= size1 ? string2 : string1))
 
-/* End address of virtual concatenation of string.  */
-#define STOP_ADDR_VSTRING(P)                            \
-  (((P) >= size1 ? string2 + size2 : string1 + size1))
-
 /* Address of POS in the concatenation of virtual string. */
 #define POS_ADDR_VSTRING(POS)                                   \
   (((POS) >= size1 ? string2 - size1 : string1) + (POS))
@@ -4559,7 +4529,6 @@ re_search_2 (struct re_pattern_buffer *bufp, const char *str1, int size1, const
           if (multibyte)
             {
               re_char *p = POS_ADDR_VSTRING (startpos);
-              re_char *pend = STOP_ADDR_VSTRING (startpos);
               int len = BYTES_BY_CHAR_HEAD (*p);
 
               range -= len;
@@ -4644,16 +4613,6 @@ static int bcmp_translate _RE_ARGS((re_char *s1, re_char *s2,
 #define AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) || !size2)
 #define AT_STRINGS_END(d) ((d) == end2)
 
-
-/* Test if D points to a character which is word-constituent.  We have
-   two special cases to check for: if past the end of string1, look at
-   the first character in string2; and if before the beginning of
-   string2, look at the last character in string1.  */
-#define WORDCHAR_P(d)                                                   \
-  (SYNTAX ((d) == end1 ? *string2                                       \
-           : (d) == string2 - 1 ? *(end1 - 1) : *(d))                   \
-   == Sword)
-
 /* Disabled due to a compiler bug -- see comment at case wordbound */
 
 /* The comment at case wordbound is following one, but we don't use
@@ -4665,6 +4624,15 @@ static int bcmp_translate _RE_ARGS((re_char *s1, re_char *s2,
    macro and introducing temporary variables works around the bug.  */
 
 #if 0
+/* Test if D points to a character which is word-constituent.  We have
+   two special cases to check for: if past the end of string1, look at
+   the first character in string2; and if before the beginning of
+   string2, look at the last character in string1.  */
+#define WORDCHAR_P(d)                                                   \
+  (SYNTAX ((d) == end1 ? *string2                                       \
+           : (d) == string2 - 1 ? *(end1 - 1) : *(d))                   \
+   == Sword)
+
 /* Test if the character before D and the one at D differ with respect
    to being word-constituent.  */
 #define AT_WORD_BOUNDARY(d)                                             \
@@ -4674,7 +4642,14 @@ static int bcmp_translate _RE_ARGS((re_char *s1, re_char *s2,
 
 /* Free everything we malloc.  */
 #ifdef MATCH_MAY_ALLOCATE
-# define FREE_VAR(var) if (var) { REGEX_FREE (var); var = NULL; } else
+# define FREE_VAR(var)                                                  \
+  do {                                                                  \
+    if (var)                                                            \
+      {                                                                 \
+        REGEX_FREE (var);                                               \
+        var = NULL;                                                     \
+      }                                                                 \
+  } while (0)
 # define FREE_VARIABLES()                                               \
   do {                                                                  \
     REGEX_FREE_STACK (fail_stack.stack);                                \
@@ -5024,7 +4999,6 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int
   /* General temporaries.  */
   int mcnt;
   size_t reg;
-  boolean not;
 
   /* Just past the end of the corresponding string.  */
   re_char *end1, *end2;
@@ -5464,7 +5438,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int
           else
             do
               {
-                int pat_charlen, buf_charlen;
+                int pat_charlen;
                 int pat_ch, buf_ch;
 
                 PREFETCH ();
@@ -5535,7 +5509,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int
 
             /* Start of actual range_table, or end of bitmap if there is no
                range table.  */
-            re_char *range_table;
+            re_char *range_table IF_LINT (= NULL);
 
             /* Nonzero if there is a range table.  */
             int range_table_exists;
@@ -5622,8 +5596,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int
             if (!not) goto fail;
 
             d += len;
-            break;
           }
+          break;
 
 
         /* The beginning of a group is represented by start_memory.
@@ -6005,46 +5979,48 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int
 
         case wordbound:
         case notwordbound:
-          not = (re_opcode_t) *(p - 1) == notwordbound;
-          DEBUG_PRINT2 ("EXECUTING %swordbound.\n", not?"not":"");
+          {
+            boolean not = (re_opcode_t) *(p - 1) == notwordbound;
+            DEBUG_PRINT2 ("EXECUTING %swordbound.\n", not?"not":"");
 
-          /* We SUCCEED (or FAIL) in one of the following cases: */
+            /* We SUCCEED (or FAIL) in one of the following cases: */
 
-          /* Case 1: D is at the beginning or the end of string.  */
-          if (AT_STRINGS_BEG (d) || AT_STRINGS_END (d))
-            not = !not;
-          else
-            {
-              /* C1 is the character before D, S1 is the syntax of C1, C2
-                 is the character at D, and S2 is the syntax of C2.  */
-              re_wchar_t c1, c2;
-              int s1, s2;
-              int dummy;
+            /* Case 1: D is at the beginning or the end of string.  */
+            if (AT_STRINGS_BEG (d) || AT_STRINGS_END (d))
+              not = !not;
+            else
+              {
+                /* C1 is the character before D, S1 is the syntax of C1, C2
+                   is the character at D, and S2 is the syntax of C2.  */
+                re_wchar_t c1, c2;
+                int s1, s2;
+                int dummy;
 #ifdef emacs
-              int offset = PTR_TO_OFFSET (d - 1);
-              int charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
-              UPDATE_SYNTAX_TABLE (charpos);
+                int offset = PTR_TO_OFFSET (d - 1);
+                int charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
+                UPDATE_SYNTAX_TABLE (charpos);
 #endif
-              GET_CHAR_BEFORE_2 (c1, d, string1, end1, string2, end2);
-              s1 = SYNTAX (c1);
+                GET_CHAR_BEFORE_2 (c1, d, string1, end1, string2, end2);
+                s1 = SYNTAX (c1);
 #ifdef emacs
-              UPDATE_SYNTAX_TABLE_FORWARD (charpos + 1);
+                UPDATE_SYNTAX_TABLE_FORWARD (charpos + 1);
 #endif
-              PREFETCH_NOLIMIT ();
-              GET_CHAR_AFTER (c2, d, dummy);
-              s2 = SYNTAX (c2);
-
-              if (/* Case 2: Only one of S1 and S2 is Sword.  */
-                  ((s1 == Sword) != (s2 == Sword))
-                  /* Case 3: Both of S1 and S2 are Sword, and macro
-                     WORD_BOUNDARY_P (C1, C2) returns nonzero.  */
-                  || ((s1 == Sword) && WORD_BOUNDARY_P (c1, c2)))
-                not = !not;
-            }
-          if (not)
-            break;
-          else
-            goto fail;
+                PREFETCH_NOLIMIT ();
+                GET_CHAR_AFTER (c2, d, dummy);
+                s2 = SYNTAX (c2);
+
+                if (/* Case 2: Only one of S1 and S2 is Sword.  */
+                    ((s1 == Sword) != (s2 == Sword))
+                    /* Case 3: Both of S1 and S2 are Sword, and macro
+                       WORD_BOUNDARY_P (C1, C2) returns nonzero.  */
+                    || ((s1 == Sword) && WORD_BOUNDARY_P (c1, c2)))
+                  not = !not;
+              }
+            if (not)
+              break;
+            else
+              goto fail;
+          }
 
         case wordbeg:
           DEBUG_PRINT1 ("EXECUTING wordbeg.\n");
@@ -6224,25 +6200,27 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int
 
         case syntaxspec:
         case notsyntaxspec:
-          not = (re_opcode_t) *(p - 1) == notsyntaxspec;
-          mcnt = *p++;
-          DEBUG_PRINT3 ("EXECUTING %ssyntaxspec %d.\n", not?"not":"", mcnt);
-          PREFETCH ();
-#ifdef emacs
           {
-            int offset = PTR_TO_OFFSET (d);
-            int pos1 = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
-            UPDATE_SYNTAX_TABLE (pos1);
-          }
+            boolean not = (re_opcode_t) *(p - 1) == notsyntaxspec;
+            mcnt = *p++;
+            DEBUG_PRINT3 ("EXECUTING %ssyntaxspec %d.\n", not?"not":"", mcnt);
+            PREFETCH ();
+#ifdef emacs
+            {
+              int offset = PTR_TO_OFFSET (d);
+              int pos1 = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
+              UPDATE_SYNTAX_TABLE (pos1);
+            }
 #endif
-          {
-            int len;
-            re_wchar_t c;
+            {
+              int len;
+              re_wchar_t c;
 
-            GET_CHAR_AFTER (c, d, len);
-            if ((SYNTAX (c) != (enum syntaxcode) mcnt) ^ not)
-              goto fail;
-            d += len;
+              GET_CHAR_AFTER (c, d, len);
+              if ((SYNTAX (c) != (enum syntaxcode) mcnt) ^ not)
+                goto fail;
+              d += len;
+            }
           }
           break;
 
@@ -6267,18 +6245,21 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int
 
         case categoryspec:
         case notcategoryspec:
-          not = (re_opcode_t) *(p - 1) == notcategoryspec;
-          mcnt = *p++;
-          DEBUG_PRINT3 ("EXECUTING %scategoryspec %d.\n", not?"not":"", mcnt);
-          PREFETCH ();
           {
-            int len;
-            re_wchar_t c;
+            boolean not = (re_opcode_t) *(p - 1) == notcategoryspec;
+            mcnt = *p++;
+            DEBUG_PRINT3 ("EXECUTING %scategoryspec %d.\n",
+                          not?"not":"", mcnt);
+            PREFETCH ();
 
-            GET_CHAR_AFTER (c, d, len);
-            if ((!CHAR_HAS_CATEGORY (c, mcnt)) ^ not)
-              goto fail;
-            d += len;
+            {
+              int len;
+              re_wchar_t c;
+              GET_CHAR_AFTER (c, d, len);
+              if ((!CHAR_HAS_CATEGORY (c, mcnt)) ^ not)
+                goto fail;
+              d += len;
+            }
           }
           break;