Push const through the regex engine. Fixes some of the warnings in PR6616.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@100438 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Support/regengine.inc b/lib/Support/regengine.inc
index 0f27cfd4b5b8f0d4ed2b01bf222de5a02c3ffd9f..bf55543dab8acd275eacf042215a2af749c030bc 100644 (file)
--- a/lib/Support/regengine.inc
+++ b/lib/Support/regengine.inc
@@ -72,11 +72,11 @@ struct match {
        struct re_guts *g;
        int eflags;
        llvm_regmatch_t *pmatch;        /* [nsub+1] (0 element unused) */
-       char *offp;             /* offsets work from here */
-       char *beginp;           /* start of string -- virtual NUL precedes */
-       char *endp;             /* end of string -- virtual NUL here */
-       char *coldp;            /* can be no match starting before here */
-       char **lastpos;         /* [nplus+1] */
+       const char *offp;               /* offsets work from here */
+       const char *beginp;             /* start of string -- virtual NUL precedes */
+       const char *endp;               /* end of string -- virtual NUL here */
+       const char *coldp;              /* can be no match starting before here */
+       const char **lastpos;           /* [nplus+1] */
        STATEVARS;
        states st;              /* current states */
        states fresh;           /* states for a fresh start */
@@ -84,11 +84,14 @@ struct match {
        states empty;           /* empty set of states */
 };
 
-static int matcher(struct re_guts *, char *, size_t, llvm_regmatch_t[], int);
-static char *dissect(struct match *, char *, char *, sopno, sopno);
-static char *backref(struct match *, char *, char *, sopno, sopno, sopno, int);
-static char *fast(struct match *, char *, char *, sopno, sopno);
-static char *slow(struct match *, char *, char *, sopno, sopno);
+static int matcher(struct re_guts *, const char *, size_t,
+                   llvm_regmatch_t[], int);
+static const char *dissect(struct match *, const char *, const char *, sopno,
+                           sopno);
+static const char *backref(struct match *, const char *, const char *, sopno,
+                           sopno, sopno, int);
+static const char *fast(struct match *, const char *, const char *, sopno, sopno);
+static const char *slow(struct match *, const char *, const char *, sopno, sopno);
 static states step(struct re_guts *, sopno, sopno, states, int, states);
 #define MAX_RECURSION  100
 #define        BOL     (OUT+1)
@@ -125,18 +128,19 @@ static int nope = 0;
  - matcher - the actual matching engine
  */
 static int                     /* 0 success, REG_NOMATCH failure */
-matcher(struct re_guts *g, char *string, size_t nmatch, llvm_regmatch_t pmatch[],
+matcher(struct re_guts *g, const char *string, size_t nmatch,
+        llvm_regmatch_t pmatch[],
     int eflags)
 {
-       char *endp;
+       const char *endp;
        size_t i;
        struct match mv;
        struct match *m = &mv;
-       char *dp;
+       const char *dp;
        const sopno gf = g->firststate+1;       /* +1 for OEND */
        const sopno gl = g->laststate;
-       char *start;
-       char *stop;
+       const char *start;
+       const char *stop;
 
        /* simplify the situation where possible */
        if (g->cflags&REG_NOSUB)
@@ -216,7 +220,7 @@ matcher(struct re_guts *g, char *string, size_t nmatch, llvm_regmatch_t pmatch[]
                        dp = dissect(m, m->coldp, endp, gf, gl);
                } else {
                        if (g->nplus > 0 && m->lastpos == NULL)
-                               m->lastpos = (char **)malloc((g->nplus+1) *
+                               m->lastpos = (const char **)malloc((g->nplus+1) *
                                                        sizeof(char *));
                        if (g->nplus > 0 && m->lastpos == NULL) {
                                free(m->pmatch);
@@ -287,21 +291,22 @@ matcher(struct re_guts *g, char *string, size_t nmatch, llvm_regmatch_t pmatch[]
 /*
  - dissect - figure out what matched what, no back references
  */
-static char *                  /* == stop (success) always */
-dissect(struct match *m, char *start, char *stop, sopno startst, sopno stopst)
+static const char *                    /* == stop (success) always */
+dissect(struct match *m, const char *start, const char *stop, sopno startst,
+        sopno stopst)
 {
        int i;
        sopno ss;       /* start sop of current subRE */
        sopno es;       /* end sop of current subRE */
-       char *sp;       /* start of string matched by it */
-       char *stp;      /* string matched by it cannot pass here */
-       char *rest;     /* start of rest of string */
-       char *tail;     /* string unmatched by rest of RE */
+       const char *sp; /* start of string matched by it */
+       const char *stp;        /* string matched by it cannot pass here */
+       const char *rest;       /* start of rest of string */
+       const char *tail;       /* string unmatched by rest of RE */
        sopno ssub;     /* start sop of subsubRE */
        sopno esub;     /* end sop of subsubRE */
-       char *ssp;      /* start of string matched by subsubRE */
-       char *sep;      /* end of string matched by subsubRE */
-       char *oldssp;   /* previous ssp */
+       const char *ssp;        /* start of string matched by subsubRE */
+       const char *sep;        /* end of string matched by subsubRE */
+       const char *oldssp;     /* previous ssp */
 
        AT("diss", start, stop, startst, stopst);
        sp = start;
@@ -360,7 +365,7 @@ dissect(struct match *m, char *start, char *stop, sopno startst, sopno stopst)
                        esub = es - 1;
                        /* did innards match? */
                        if (slow(m, sp, rest, ssub, esub) != NULL) {
-                               char *dp = dissect(m, sp, rest, ssub, esub);
+                               const char *dp = dissect(m, sp, rest, ssub, esub);
                                (void)dp; /* avoid warning if assertions off */
                                assert(dp == rest);
                        } else          /* no */
@@ -400,7 +405,7 @@ dissect(struct match *m, char *start, char *stop, sopno startst, sopno stopst)
                        assert(sep == rest);    /* must exhaust substring */
                        assert(slow(m, ssp, sep, ssub, esub) == rest);
                        {
-                               char *dp = dissect(m, ssp, sep, ssub, esub);
+                               const char *dp = dissect(m, ssp, sep, ssub, esub);
                                (void)dp; /* avoid warning if assertions off */
                                assert(dp == sep);
                        }
@@ -438,7 +443,7 @@ dissect(struct match *m, char *start, char *stop, sopno startst, sopno stopst)
                                        assert(OP(m->g->strip[esub]) == O_CH);
                        }
                        {
-                               char *dp = dissect(m, sp, rest, ssub, esub);
+                               const char *dp = dissect(m, sp, rest, ssub, esub);
                                (void)dp; /* avoid warning if assertions off */
                                assert(dp == rest);
                        }
@@ -474,17 +479,17 @@ dissect(struct match *m, char *start, char *stop, sopno startst, sopno stopst)
 /*
  - backref - figure out what matched what, figuring in back references
  */
-static char *                  /* == stop (success) or NULL (failure) */
-backref(struct match *m, char *start, char *stop, sopno startst, sopno stopst,
-    sopno lev, int rec)                        /* PLUS nesting level */
+static const char *                    /* == stop (success) or NULL (failure) */
+backref(struct match *m, const char *start, const char *stop, sopno startst,
+        sopno stopst, sopno lev, int rec)                      /* PLUS nesting level */
 {
        int i;
        sopno ss;       /* start sop of current subRE */
-       char *sp;       /* start of string matched by it */
+       const char *sp; /* start of string matched by it */
        sopno ssub;     /* start sop of subsubRE */
        sopno esub;     /* end sop of subsubRE */
-       char *ssp;      /* start of string matched by subsubRE */
-       char *dp;
+       const char *ssp;        /* start of string matched by subsubRE */
+       const char *dp;
        size_t len;
        int hard;
        sop s;
@@ -674,18 +679,19 @@ backref(struct match *m, char *start, char *stop, sopno startst, sopno stopst,
 /*
  - fast - step through the string at top speed
  */
-static char *                  /* where tentative match ended, or NULL */
-fast(struct match *m, char *start, char *stop, sopno startst, sopno stopst)
+static const char *                    /* where tentative match ended, or NULL */
+fast(struct match *m, const char *start, const char *stop, sopno startst,
+     sopno stopst)
 {
        states st = m->st;
        states fresh = m->fresh;
        states tmp = m->tmp;
-       char *p = start;
+       const char *p = start;
        int c = (start == m->beginp) ? OUT : *(start-1);
        int lastc;      /* previous c */
        int flagch;
        int i;
-       char *coldp;    /* last p after which no match was underway */
+       const char *coldp;      /* last p after which no match was underway */
 
        CLEAR(st);
        SET1(st, startst);
@@ -758,18 +764,19 @@ fast(struct match *m, char *start, char *stop, sopno startst, sopno stopst)
 /*
  - slow - step through the string more deliberately
  */
-static char *                  /* where it ended */
-slow(struct match *m, char *start, char *stop, sopno startst, sopno stopst)
+static const char *                    /* where it ended */
+slow(struct match *m, const char *start, const char *stop, sopno startst,
+     sopno stopst)
 {
        states st = m->st;
        states empty = m->empty;
        states tmp = m->tmp;
-       char *p = start;
+       const char *p = start;
        int c = (start == m->beginp) ? OUT : *(start-1);
        int lastc;      /* previous c */
        int flagch;
        int i;
-       char *matchp;   /* last p at which a match ended */
+       const char *matchp;     /* last p at which a match ended */
 
        AT("slow", start, stop, startst, stopst);
        CLEAR(st);

diff --git a/lib/Support/regexec.c b/lib/Support/regexec.c
index 7d70f6e16c78ec58150d1c2712009b0587c8b9d6..41fb2ea46c9ab31b0a0f4b110b2d2e1d7f79b0d9 100644 (file)
--- a/lib/Support/regexec.c
+++ b/lib/Support/regexec.c
@@ -155,7 +155,7 @@ llvm_regexec(const llvm_regex_t *preg, const char *string, size_t nmatch,
        eflags = GOODFLAGS(eflags);
 
        if (g->nstates <= (long)(CHAR_BIT*sizeof(states1)) && !(eflags&REG_LARGE))
-               return(smatcher(g, (char *)string, nmatch, pmatch, eflags));
+               return(smatcher(g, string, nmatch, pmatch, eflags));
        else
-               return(lmatcher(g, (char *)string, nmatch, pmatch, eflags));
+               return(lmatcher(g, string, nmatch, pmatch, eflags));
 }