Imported Upstream version 2.5.1

[debian/amanda] / regex-src / regexec.c

diff --git a/regex-src/regexec.c b/regex-src/regexec.c
index 0e86b37312c6c779ae8bdb6bbe2ed839096b984f..4213cdd312ee2b886e0f0f0713c97186aad8bd81 100644 (file)
--- a/regex-src/regexec.c
+++ b/regex-src/regexec.c
@@ -5,43 +5,35 @@
  * macros that code uses.  This lets the same code operate on two different
  * representations for state sets.
  */
-#include <sys/types.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-#include <ctype.h>
+#include "amanda.h"
 #include <regex.h>
-
 #include "utils.h"
 #include "regex2.h"
 
-#ifndef NDEBUG
-static int nope = 0;           /* for use in asserts; shuts lint up */
-#endif
+#undef ISSET
 
 /* macros for manipulating states, small version */
-#define        states  long
+#define        states  unsigned long
 #define        states1 states          /* for later use in regexec() decision */
-#define        CLEAR(v)        ((v) = 0)
+#define        CLEAR(v)        (((v) = 0), (void)(v))
 #define        SET0(v, n)      ((v) &= ~(MAKE_UNSIGNED_LONG(1) << (n)))
 #define        SET1(v, n)      ((v) |= (MAKE_UNSIGNED_LONG(1)) << (n))
 #define        ISSET(v, n)     ((v) & ((MAKE_UNSIGNED_LONG(1)) << (n)))
-#define        ASSIGN(d, s)    ((d) = (s))
+#define        ASSIGN(d, s)    ((d) = (s), (void)(d))
 #define        EQ(a, b)        ((a) == (b))
 #define        STATEVARS       int dummy       /* dummy version */
 #define        STATESETUP(m, n)        /* nothing */
 #define        STATETEARDOWN(m)        /* nothing */
 #define        SETUP(v)        ((v) = 0)
-#define        onestate        long
-#define        INIT(o, n)      ((o) = (unsigned long)1 << (n))
+#define        onestate        sopno
+#define        INIT(o, n)      ((o) = (sopno)1 << (n))
 #define        INC(o)  ((o) <<= 1)
 #define        ISSTATEIN(v, o) ((v) & (o))
 /* some abbreviations; note that some of these know variable names! */
 /* do "if I'm here, I can also be there" etc without branches */
 #define        FWD(dst, src, n)        ((dst) |= ((unsigned long)(src)&(here)) << (n))
 #define        BACK(dst, src, n)       ((dst) |= ((unsigned long)(src)&(here)) >> (n))
-#define        ISSETBACK(v, n) ((v) & ((unsigned long)here >> (n)))
+#define        ISSETBACK(v, n) ((v) & ((long)here >> (n)))
 /* function names */
 #define SNAMES                 /* engine.c looks after details */
 
@@ -70,16 +62,20 @@ static int nope = 0;                /* for use in asserts; shuts lint up */
 
 /* macros for manipulating states, large version */
 #define        states  char *
-#define        CLEAR(v)        memset(v, 0, m->g->nstates)
+#define        CLEAR(v)        memset((v), 0, (size_t)m->g->nstates)
 #define        SET0(v, n)      ((v)[n] = 0)
 #define        SET1(v, n)      ((v)[n] = 1)
 #define        ISSET(v, n)     ((v)[n])
-#define        ASSIGN(d, s)    memcpy(d, s, m->g->nstates)
-#define        EQ(a, b)        (memcmp(a, b, m->g->nstates) == 0)
+#define        ASSIGN(d, s)    memcpy((d), (s), (size_t)m->g->nstates)
+#define        EQ(a, b)        (memcmp((a), (b), (size_t)m->g->nstates) == 0)
 #define        STATEVARS       int vn; char *space
-#define        STATESETUP(m, nv)       { (m)->space = malloc((nv)*(m)->g->nstates); \
-                               if ((m)->space == NULL) return(REG_ESPACE); \
-                               (m)->vn = 0; }
+#define        STATESETUP(m, nv) do {                                          \
+           (m)->space = malloc((size_t)(nv)*(size_t)(m)->g->nstates);  \
+           if ((m)->space == NULL)                                     \
+               return(REG_ESPACE);                                     \
+           (m)->vn = 0;                                                \
+} while (0);
+
 #define        STATETEARDOWN(m)        { free((m)->space); }
 #define        SETUP(v)        ((v) = &m->space[m->vn++ * m->g->nstates])
 #define        onestate        int
@@ -98,8 +94,7 @@ static int nope = 0;          /* for use in asserts; shuts lint up */
 
 /*
  - regexec - interface for matching
- = extern int regexec(const regex_t *, const char *, size_t, \
- =                                     regmatch_t [], int);
+ = int regexec(regex_t *preg, const char *string, size_t nmatch, regmatch_t pmatch[], int eflags);
  = #define     REG_NOTBOL      00001
  = #define     REG_NOTEOL      00002
  = #define     REG_STARTEND    00004
@@ -112,13 +107,14 @@ static int nope = 0;              /* for use in asserts; shuts lint up */
  * have been prototyped.
  */
 int                            /* 0 success, REG_NOMATCH failure */
-regexec(preg, string, nmatch, pmatch, eflags)
-const regex_t *preg;
-const char *string;
-size_t nmatch;
-regmatch_t pmatch[];
-int eflags;
+regexec(
+    regex_t *preg,
+    const char *string,
+    size_t nmatch,
+    regmatch_t pmatch[],
+    int eflags)
 {
+       /*@ignore@*/
        register struct re_guts *g = preg->re_g;
 #ifdef REDEBUG
 #      define  GOODFLAGS(f)    (f)
@@ -128,13 +124,14 @@ int eflags;
 
        if (preg->re_magic != MAGIC1 || g->magic != MAGIC2)
                return(REG_BADPAT);
+       /*@end@*/
        assert(!(g->iflags&BAD));
        if (g->iflags&BAD)              /* backstop for no-debug case */
                return(REG_BADPAT);
        eflags = GOODFLAGS(eflags);
 
-       if (g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags&REG_LARGE))
+       if ((g->nstates <= ((sopno)(CHAR_BIT * SIZEOF(states1))) &&
+           !(eflags & REG_LARGE)))
                return(smatcher(g, string, nmatch, pmatch, eflags));
-       else
-               return(lmatcher(g, string, nmatch, pmatch, eflags));
+       return(lmatcher(g, string, nmatch, pmatch, eflags));
 }