Merge from vendor branch OPENSSL:
[dragonfly.git] / lib / libc / regex / regcomp.c
index c539d6e..54c3134 100644 (file)
@@ -37,7 +37,7 @@
  *     @(#)regcomp.c   8.5 (Berkeley) 3/20/94
  *
  * $FreeBSD: src/lib/libc/regex/regcomp.c,v 1.13.2.2 2002/03/20 13:13:15 dcs Exp $
- * $DragonFly: src/lib/libc/regex/regcomp.c,v 1.4 2004/02/06 22:36:50 joerg Exp $
+ * $DragonFly: src/lib/libc/regex/regcomp.c,v 1.7 2005/11/20 09:18:37 swildner Exp $
  *
  * @(#)regcomp.c       8.5 (Berkeley) 3/20/94
  */
@@ -250,7 +250,7 @@ regcomp(regex_t *preg, const char *pattern, int cflags)
        g->nsub = 0;
        g->ncategories = 1;     /* category 0 is "everything else" */
        g->categories = &g->catspace[-(CHAR_MIN)];
-       (void) memset((char *)g->catspace, 0, NC*sizeof(cat_t));
+       memset((char *)g->catspace, 0, NC*sizeof(cat_t));
        g->backrefs = 0;
 
        /* do it */
@@ -299,7 +299,7 @@ regcomp(regex_t *preg, const char *pattern, int cflags)
 
 /*
  - p_ere - ERE parser top level, concatenation and alternation
- == static void p_ere(register struct parse *p, int stop);
+ == static void p_ere(struct parse *p, int stop);
  */
 static void
 p_ere(struct parse *p,
@@ -311,12 +311,15 @@ p_ere(struct parse *p,
        sopno conc;
        int first = 1;          /* is this the first alternative? */
 
+       prevback = 0;
+       prevfwd = 0;
+
        for (;;) {
                /* do a bunch of concatenated expressions */
                conc = HERE();
                while (MORE() && (c = PEEK()) != '|' && c != stop)
                        p_ere_exp(p);
-               (void)REQUIRE(HERE() != conc, REG_EMPTY);       /* require nonempty */
+               REQUIRE(HERE() != conc, REG_EMPTY);     /* require nonempty */
 
                if (!EAT('|'))
                        break;          /* NOTE BREAK OUT */
@@ -344,7 +347,7 @@ p_ere(struct parse *p,
 
 /*
  - p_ere_exp - parse one subERE, an atom possibly followed by a repetition op
- == static void p_ere_exp(register struct parse *p);
+ == static void p_ere_exp(struct parse *p);
  */
 static void
 p_ere_exp(struct parse *p)
@@ -362,7 +365,7 @@ p_ere_exp(struct parse *p)
        pos = HERE();
        switch (c) {
        case '(':
-               (void)REQUIRE(MORE(), REG_EPAREN);
+               REQUIRE(MORE(), REG_EPAREN);
                p->g->nsub++;
                subno = p->g->nsub;
                if (subno < NPAREN)
@@ -375,7 +378,7 @@ p_ere_exp(struct parse *p)
                        assert(p->pend[subno] != 0);
                }
                EMIT(ORPAREN, subno);
-               (void)MUSTEAT(')', REG_EPAREN);
+               MUSTEAT(')', REG_EPAREN);
                break;
 #ifndef POSIX_MISTAKE
        case ')':               /* happens only if no current unmatched ( */
@@ -418,12 +421,12 @@ p_ere_exp(struct parse *p)
                p_bracket(p);
                break;
        case '\\':
-               (void)REQUIRE(MORE(), REG_EESCAPE);
+               REQUIRE(MORE(), REG_EESCAPE);
                c = GETNEXT();
                ordinary(p, c);
                break;
        case '{':               /* okay as ordinary except if digit follows */
-               (void)REQUIRE(!MORE() || !isdigit((uch)PEEK()), REG_BADRPT);
+               REQUIRE(!MORE() || !isdigit((uch)PEEK()), REG_BADRPT);
                /* FALLTHROUGH */
        default:
                ordinary(p, c);
@@ -439,7 +442,7 @@ p_ere_exp(struct parse *p)
                return;         /* no repetition, we're done */
        NEXT();
 
-       (void)REQUIRE(!wascaret, REG_BADRPT);
+       REQUIRE(!wascaret, REG_BADRPT);
        switch (c) {
        case '*':       /* implemented as +? */
                /* this case does not require the (y|) trick, noKLUDGE */
@@ -466,7 +469,7 @@ p_ere_exp(struct parse *p)
                if (EAT(',')) {
                        if (isdigit((uch)PEEK())) {
                                count2 = p_count(p);
-                               (void)REQUIRE(count <= count2, REG_BADBR);
+                               REQUIRE(count <= count2, REG_BADBR);
                        } else          /* single number with comma */
                                count2 = INFINITY;
                } else          /* just a single number */
@@ -475,7 +478,7 @@ p_ere_exp(struct parse *p)
                if (!EAT('}')) {        /* error heuristics */
                        while (MORE() && PEEK() != '}')
                                NEXT();
-                       (void)REQUIRE(MORE(), REG_EBRACE);
+                       REQUIRE(MORE(), REG_EBRACE);
                        SETERROR(REG_BADBR);
                }
                break;
@@ -492,20 +495,20 @@ p_ere_exp(struct parse *p)
 
 /*
  - p_str - string (no metacharacters) "parser"
- == static void p_str(register struct parse *p);
+ == static void p_str(struct parse *p);
  */
 static void
 p_str(struct parse *p)
 {
-       (void)REQUIRE(MORE(), REG_EMPTY);
+       REQUIRE(MORE(), REG_EMPTY);
        while (MORE())
                ordinary(p, GETNEXT());
 }
 
 /*
  - p_bre - BRE parser top level, anchoring and concatenation
- == static void p_bre(register struct parse *p, register int end1, \
- ==    register int end2);
+ == static void p_bre(struct parse *p, int end1, \
+ ==    int end2);
  * Giving end1 as OUT essentially eliminates the end1/end2 check.
  *
  * This implementation is a bit of a kludge, in that a trailing $ is first
@@ -539,12 +542,12 @@ p_bre(struct parse *p,
                p->g->neol++;
        }
 
-       (void)REQUIRE(HERE() != start, REG_EMPTY);      /* require nonempty */
+       REQUIRE(HERE() != start, REG_EMPTY);    /* require nonempty */
 }
 
 /*
  - p_simp_re - parse a simple RE, an atom possibly followed by a repetition
- == static int p_simp_re(register struct parse *p, int starordinary);
+ == static int p_simp_re(struct parse *p, int starordinary);
  */
 static int                     /* was the simple RE an unbackslashed $? */
 p_simp_re(struct parse *p,
@@ -563,7 +566,7 @@ p_simp_re(struct parse *p,
        assert(MORE());         /* caller should have ensured this */
        c = GETNEXT();
        if (c == '\\') {
-               (void)REQUIRE(MORE(), REG_EESCAPE);
+               REQUIRE(MORE(), REG_EESCAPE);
                c = BACKSL | GETNEXT();
        }
        switch (c) {
@@ -593,7 +596,7 @@ p_simp_re(struct parse *p,
                        assert(p->pend[subno] != 0);
                }
                EMIT(ORPAREN, subno);
-               (void)REQUIRE(EATTWO('\\', ')'), REG_EPAREN);
+               REQUIRE(EATTWO('\\', ')'), REG_EPAREN);
                break;
        case BACKSL|')':        /* should not get here -- must be user */
        case BACKSL|'}':
@@ -616,14 +619,14 @@ p_simp_re(struct parse *p,
                        assert(p->pbegin[i] != 0);
                        assert(OP(p->strip[p->pbegin[i]]) == OLPAREN);
                        assert(OP(p->strip[p->pend[i]]) == ORPAREN);
-                       (void) dupl(p, p->pbegin[i]+1, p->pend[i]);
+                       dupl(p, p->pbegin[i]+1, p->pend[i]);
                        EMIT(O_BACK, i);
                } else
                        SETERROR(REG_ESUBREG);
                p->g->backrefs = 1;
                break;
        case '*':
-               (void)REQUIRE(starordinary, REG_BADRPT);
+               REQUIRE(starordinary, REG_BADRPT);
                /* FALLTHROUGH */
        default:
                ordinary(p, (char)c);
@@ -641,7 +644,7 @@ p_simp_re(struct parse *p,
                if (EAT(',')) {
                        if (MORE() && isdigit((uch)PEEK())) {
                                count2 = p_count(p);
-                               (void)REQUIRE(count <= count2, REG_BADBR);
+                               REQUIRE(count <= count2, REG_BADBR);
                        } else          /* single number with comma */
                                count2 = INFINITY;
                } else          /* just a single number */
@@ -650,7 +653,7 @@ p_simp_re(struct parse *p,
                if (!EATTWO('\\', '}')) {       /* error heuristics */
                        while (MORE() && !SEETWO('\\', '}'))
                                NEXT();
-                       (void)REQUIRE(MORE(), REG_EBRACE);
+                       REQUIRE(MORE(), REG_EBRACE);
                        SETERROR(REG_BADBR);
                }
        } else if (c == '$')     /* $ (but not \$) ends it */
@@ -661,7 +664,7 @@ p_simp_re(struct parse *p,
 
 /*
  - p_count - parse a repetition count
- == static int p_count(register struct parse *p);
+ == static int p_count(struct parse *p);
  */
 static int                     /* the value */
 p_count(struct parse *p)
@@ -674,13 +677,13 @@ p_count(struct parse *p)
                ndigits++;
        }
 
-       (void)REQUIRE(ndigits > 0 && count <= DUPMAX, REG_BADBR);
+       REQUIRE(ndigits > 0 && count <= DUPMAX, REG_BADBR);
        return(count);
 }
 
 /*
  - p_bracket - parse a bracketed character list
- == static void p_bracket(register struct parse *p);
+ == static void p_bracket(struct parse *p);
  *
  * Note a significant property of this code:  if the allocset() did SETERROR,
  * no set operations are done.
@@ -713,14 +716,14 @@ p_bracket(struct parse *p)
                p_b_term(p, cs);
        if (EAT('-'))
                CHadd(cs, '-');
-       (void)MUSTEAT(']', REG_EBRACK);
+       MUSTEAT(']', REG_EBRACK);
 
        if (p->error != 0)      /* don't mess things up further */
                return;
 
        if (p->g->cflags&REG_ICASE) {
-               register int i;
-               register int ci;
+               int i;
+               int ci;
 
                for (i = p->g->csetsize - 1; i >= 0; i--)
                        if (CHIN(cs, i) && isalpha(i)) {
@@ -732,7 +735,7 @@ p_bracket(struct parse *p)
                        mccase(p, cs);
        }
        if (invert) {
-               register int i;
+               int i;
 
                for (i = p->g->csetsize - 1; i >= 0; i--)
                        if (CHIN(cs, i))
@@ -756,7 +759,7 @@ p_bracket(struct parse *p)
 
 /*
  - p_b_term - parse one term of a bracketed character list
- == static void p_b_term(register struct parse *p, register cset *cs);
+ == static void p_b_term(struct parse *p, cset *cs);
  */
 static void
 p_b_term(struct parse *p, cset *cs)
@@ -782,21 +785,21 @@ p_b_term(struct parse *p, cset *cs)
        switch (c) {
        case ':':               /* character class */
                NEXT2();
-               (void)REQUIRE(MORE(), REG_EBRACK);
+               REQUIRE(MORE(), REG_EBRACK);
                c = PEEK();
-               (void)REQUIRE(c != '-' && c != ']', REG_ECTYPE);
+               REQUIRE(c != '-' && c != ']', REG_ECTYPE);
                p_b_cclass(p, cs);
-               (void)REQUIRE(MORE(), REG_EBRACK);
-               (void)REQUIRE(EATTWO(':', ']'), REG_ECTYPE);
+               REQUIRE(MORE(), REG_EBRACK);
+               REQUIRE(EATTWO(':', ']'), REG_ECTYPE);
                break;
        case '=':               /* equivalence class */
                NEXT2();
-               (void)REQUIRE(MORE(), REG_EBRACK);
+               REQUIRE(MORE(), REG_EBRACK);
                c = PEEK();
-               (void)REQUIRE(c != '-' && c != ']', REG_ECOLLATE);
+               REQUIRE(c != '-' && c != ']', REG_ECOLLATE);
                p_b_eclass(p, cs);
-               (void)REQUIRE(MORE(), REG_EBRACK);
-               (void)REQUIRE(EATTWO('=', ']'), REG_ECOLLATE);
+               REQUIRE(MORE(), REG_EBRACK);
+               REQUIRE(EATTWO('=', ']'), REG_ECOLLATE);
                break;
        default:                /* symbol, ordinary character, or range */
 /* xxx revision needed for multichar stuff */
@@ -814,11 +817,11 @@ p_b_term(struct parse *p, cset *cs)
                        CHadd(cs, start);
                else {
                        if (__collate_load_error) {
-                               (void)REQUIRE((uch)start <= (uch)finish, REG_ERANGE);
+                               REQUIRE((uch)start <= (uch)finish, REG_ERANGE);
                                for (i = (uch)start; i <= (uch)finish; i++)
                                        CHadd(cs, i);
                        } else {
-                               (void)REQUIRE(__collate_range_cmp(start, finish) <= 0, REG_ERANGE);
+                               REQUIRE(__collate_range_cmp(start, finish) <= 0, REG_ERANGE);
                                for (i = CHAR_MIN; i <= CHAR_MAX; i++) {
                                        if (   __collate_range_cmp(start, i) <= 0
                                            && __collate_range_cmp(i, finish) <= 0
@@ -833,7 +836,7 @@ p_b_term(struct parse *p, cset *cs)
 
 /*
  - p_b_cclass - parse a character-class name and deal with it
- == static void p_b_cclass(register struct parse *p, register cset *cs);
+ == static void p_b_cclass(struct parse *p, cset *cs);
  */
 static void
 p_b_cclass(struct parse *p, cset *cs)
@@ -925,7 +928,7 @@ p_b_cclass(struct parse *p, cset *cs)
 
 /*
  - p_b_eclass - parse an equivalence-class name and deal with it
- == static void p_b_eclass(register struct parse *p, register cset *cs);
+ == static void p_b_eclass(struct parse *p, cset *cs);
  *
  * This implementation is incomplete. xxx
  */
@@ -940,26 +943,26 @@ p_b_eclass(struct parse *p, cset *cs)
 
 /*
  - p_b_symbol - parse a character or [..]ed multicharacter collating symbol
- == static char p_b_symbol(register struct parse *p);
+ == static char p_b_symbol(struct parse *p);
  */
 static char                    /* value of symbol */
 p_b_symbol(struct parse *p)
 {
        char value;
 
-       (void)REQUIRE(MORE(), REG_EBRACK);
+       REQUIRE(MORE(), REG_EBRACK);
        if (!EATTWO('[', '.'))
                return(GETNEXT());
 
        /* collating symbol */
        value = p_b_coll_elem(p, '.');
-       (void)REQUIRE(EATTWO('.', ']'), REG_ECOLLATE);
+       REQUIRE(EATTWO('.', ']'), REG_ECOLLATE);
        return(value);
 }
 
 /*
  - p_b_coll_elem - parse a collating-element name and look it up
- == static char p_b_coll_elem(register struct parse *p, int endc);
+ == static char p_b_coll_elem(struct parse *p, int endc);
  */
 static char                    /* value of collating element */
 p_b_coll_elem(struct parse *p,
@@ -1004,7 +1007,7 @@ othercase(int ch)
 
 /*
  - bothcases - emit a dualcase version of a two-case character
- == static void bothcases(register struct parse *p, int ch);
+ == static void bothcases(struct parse *p, int ch);
  *
  * Boy, is this implementation ever a kludge...
  */
@@ -1030,7 +1033,7 @@ bothcases(struct parse *p, int ch)
 
 /*
  - ordinary - emit an ordinary character
- == static void ordinary(register struct parse *p, register int ch);
+ == static void ordinary(struct parse *p, int ch);
  */
 static void
 ordinary(struct parse *p, int ch)
@@ -1048,7 +1051,7 @@ ordinary(struct parse *p, int ch)
 
 /*
  - nonnewline - emit REG_NEWLINE version of OANY
- == static void nonnewline(register struct parse *p);
+ == static void nonnewline(struct parse *p);
  *
  * Boy, is this implementation ever a kludge...
  */
@@ -1073,7 +1076,7 @@ nonnewline(struct parse *p)
 
 /*
  - repeat - generate code for a bounded repetition, recursively if needed
- == static void repeat(register struct parse *p, sopno start, int from, int to);
+ == static void repeat(struct parse *p, sopno start, int from, int to);
  */
 static void
 repeat(struct parse *p,
@@ -1144,7 +1147,7 @@ repeat(struct parse *p,
 
 /*
  - seterr - set an error condition
- == static int seterr(register struct parse *p, int e);
+ == static int seterr(struct parse *p, int e);
  */
 static int                     /* useless but makes type checking happy */
 seterr(struct parse *p, int e)
@@ -1158,7 +1161,7 @@ seterr(struct parse *p, int e)
 
 /*
  - allocset - allocate a set of characters for []
- == static cset *allocset(register struct parse *p);
+ == static cset *allocset(struct parse *p);
  */
 static cset *
 allocset(struct parse *p)
@@ -1190,8 +1193,7 @@ allocset(struct parse *p)
                                p->g->sets[i].ptr = p->g->setbits + css*(i/CHAR_BIT);
                }
                if (p->g->sets != NULL && p->g->setbits != NULL)
-                       (void) memset((char *)p->g->setbits + (nbytes - css),
-                                                               0, css);
+                       memset((char *)p->g->setbits + (nbytes - css), 0, css);
                else {
                        no = 0;
                        SETERROR(REG_ESPACE);
@@ -1212,7 +1214,7 @@ allocset(struct parse *p)
 
 /*
  - freeset - free a now-unused set
- == static void freeset(register struct parse *p, register cset *cs);
+ == static void freeset(struct parse *p, cset *cs);
  */
 static void
 freeset(struct parse *p, cset *cs)
@@ -1229,7 +1231,7 @@ freeset(struct parse *p, cset *cs)
 
 /*
  - freezeset - final processing on a set of characters
- == static int freezeset(register struct parse *p, register cset *cs);
+ == static int freezeset(struct parse *p, cset *cs);
  *
  * The main task here is merging identical sets.  This is usually a waste
  * of time (although the hash code minimizes the overhead), but can win
@@ -1267,7 +1269,7 @@ freezeset(struct parse *p, cset *cs)
 
 /*
  - firstch - return first character in a set (which must have at least one)
- == static int firstch(register struct parse *p, register cset *cs);
+ == static int firstch(struct parse *p, cset *cs);
  */
 static int                     /* character; there is no "none" value */
 firstch(struct parse *p, cset *cs)
@@ -1284,7 +1286,7 @@ firstch(struct parse *p, cset *cs)
 
 /*
  - nch - number of characters in a set
- == static int nch(register struct parse *p, register cset *cs);
+ == static int nch(struct parse *p, cset *cs);
  */
 static int
 nch(struct parse *p, cset *cs)
@@ -1301,8 +1303,8 @@ nch(struct parse *p, cset *cs)
 
 /*
  - mcadd - add a collating element to a cset
- == static void mcadd(register struct parse *p, register cset *cs, \
- ==    register char *cp);
+ == static void mcadd(struct parse *p, cset *cs, \
+ ==    char *cp);
  */
 static void
 mcadd(struct parse *p, cset *cs, char *cp)
@@ -1319,14 +1321,14 @@ mcadd(struct parse *p, cset *cs, char *cp)
                return;
        }
 
-       (void) strcpy(cs->multis + oldend - 1, cp);
+       strcpy(cs->multis + oldend - 1, cp);
        cs->multis[cs->smultis - 1] = '\0';
 }
 
 #if used
 /*
  - mcsub - subtract a collating element from a cset
- == static void mcsub(register cset *cs, register char *cp);
+ == static void mcsub(cset *cs, char *cp);
  */
 static void
 mcsub(cset *cs, char *cp)
@@ -1335,8 +1337,7 @@ mcsub(cset *cs, char *cp)
        size_t len = strlen(fp);
 
        assert(fp != NULL);
-       (void) memmove(fp, fp + len + 1,
-                               cs->smultis - (fp + len + 1 - cs->multis));
+       memmove(fp, fp + len + 1, cs->smultis - (fp + len + 1 - cs->multis));
        cs->smultis -= len;
 
        if (cs->smultis == 0) {
@@ -1351,7 +1352,7 @@ mcsub(cset *cs, char *cp)
 
 /*
  - mcin - is a collating element in a cset?
- == static int mcin(register cset *cs, register char *cp);
+ == static int mcin(cset *cs, char *cp);
  */
 static int
 mcin(cset *cs, char *cp)
@@ -1361,7 +1362,7 @@ mcin(cset *cs, char *cp)
 
 /*
  - mcfind - find a collating element in a cset
- == static char *mcfind(register cset *cs, register char *cp);
+ == static char *mcfind(cset *cs, char *cp);
  */
 static char *
 mcfind(cset *cs, char *cp)
@@ -1379,33 +1380,33 @@ mcfind(cset *cs, char *cp)
 
 /*
  - mcinvert - invert the list of collating elements in a cset
- == static void mcinvert(register struct parse *p, register cset *cs);
+ == static void mcinvert(struct parse *p, cset *cs);
  *
  * This would have to know the set of possibilities.  Implementation
  * is deferred.
  */
 static void
-mcinvert(struct parse *p, cset *cs)
+mcinvert(struct parse *p __unused, cset *cs)
 {
        assert(cs->multis == NULL);     /* xxx */
 }
 
 /*
  - mccase - add case counterparts of the list of collating elements in a cset
- == static void mccase(register struct parse *p, register cset *cs);
+ == static void mccase(struct parse *p, cset *cs);
  *
  * This would have to know the set of possibilities.  Implementation
  * is deferred.
  */
 static void
-mccase(struct parse *p, cset *cs)
+mccase(struct parse *p __unused, cset *cs)
 {
        assert(cs->multis == NULL);     /* xxx */
 }
 
 /*
  - isinsets - is this character in any sets?
- == static int isinsets(register struct re_guts *g, int c);
+ == static int isinsets(struct re_guts *g, int c);
  */
 static int                     /* predicate */
 isinsets(struct re_guts *g, int c)
@@ -1423,7 +1424,7 @@ isinsets(struct re_guts *g, int c)
 
 /*
  - samesets - are these two characters in exactly the same sets?
- == static int samesets(register struct re_guts *g, int c1, int c2);
+ == static int samesets(struct re_guts *g, int c1, int c2);
  */
 static int                     /* predicate */
 samesets(struct re_guts *g, int c1, int c2)
@@ -1442,7 +1443,7 @@ samesets(struct re_guts *g, int c1, int c2)
 
 /*
  - categorize - sort out character categories
- == static void categorize(struct parse *p, register struct re_guts *g);
+ == static void categorize(struct parse *p, struct re_guts *g);
  */
 static void
 categorize(struct parse *p, struct re_guts *g)
@@ -1468,7 +1469,7 @@ categorize(struct parse *p, struct re_guts *g)
 
 /*
  - dupl - emit a duplicate of a bunch of sops
- == static sopno dupl(register struct parse *p, sopno start, sopno finish);
+ == static sopno dupl(struct parse *p, sopno start, sopno finish);
  */
 static sopno                   /* start of duplicate */
 dupl(struct parse *p,
@@ -1483,15 +1484,15 @@ dupl(struct parse *p,
                return(ret);
        enlarge(p, p->ssize + len);     /* this many unexpected additions */
        assert(p->ssize >= p->slen + len);
-       (void) memcpy((char *)(p->strip + p->slen),
-               (char *)(p->strip + start), (size_t)len*sizeof(sop));
+       memcpy((char *)(p->strip + p->slen), (char *)(p->strip + start),
+              (size_t)len*sizeof(sop));
        p->slen += len;
        return(ret);
 }
 
 /*
  - doemit - emit a strip operator
- == static void doemit(register struct parse *p, sop op, size_t opnd);
+ == static void doemit(struct parse *p, sop op, size_t opnd);
  *
  * It might seem better to implement this as a macro with a function as
  * hard-case backup, but it's just too big and messy unless there are
@@ -1518,7 +1519,7 @@ doemit(struct parse *p, sop op, size_t opnd)
 
 /*
  - doinsert - insert a sop into the strip
- == static void doinsert(register struct parse *p, sop op, size_t opnd, sopno pos);
+ == static void doinsert(struct parse *p, sop op, size_t opnd, sopno pos);
  */
 static void
 doinsert(struct parse *p, sop op, size_t opnd, sopno pos)
@@ -1554,7 +1555,7 @@ doinsert(struct parse *p, sop op, size_t opnd, sopno pos)
 
 /*
  - dofwd - complete a forward reference
- == static void dofwd(register struct parse *p, sopno pos, sop value);
+ == static void dofwd(struct parse *p, sopno pos, sop value);
  */
 static void
 dofwd(struct parse *p, sopno pos, sop value)
@@ -1569,7 +1570,7 @@ dofwd(struct parse *p, sopno pos, sop value)
 
 /*
  - enlarge - enlarge the strip
- == static void enlarge(register struct parse *p, sopno size);
+ == static void enlarge(struct parse *p, sopno size);
  */
 static void
 enlarge(struct parse *p, sopno size)
@@ -1590,7 +1591,7 @@ enlarge(struct parse *p, sopno size)
 
 /*
  - stripsnug - compact the strip
- == static void stripsnug(register struct parse *p, register struct re_guts *g);
+ == static void stripsnug(struct parse *p, struct re_guts *g);
  */
 static void
 stripsnug(struct parse *p, struct re_guts *g)
@@ -1605,7 +1606,7 @@ stripsnug(struct parse *p, struct re_guts *g)
 
 /*
  - findmust - fill in must and mlen with longest mandatory literal string
- == static void findmust(register struct parse *p, register struct re_guts *g);
+ == static void findmust(struct parse *p, struct re_guts *g);
  *
  * This algorithm could do fancy things like analyzing the operands of |
  * for common subsequences.  Someday.  This code is simple and finds most
@@ -1626,6 +1627,9 @@ findmust(struct parse *p, struct re_guts *g)
        int offset;
        int cs, mccs;
 
+       start = NULL;
+       newstart = NULL;
+       
        /* avoid making error situations worse */
        if (p->error != 0)
                return;
@@ -1848,7 +1852,7 @@ altoffset(sop *scan, int offset, int mccs)
 
 /*
  - computejumps - compute char jumps for BM scan
- == static void computejumps(register struct parse *p, register struct re_guts *g);
+ == static void computejumps(struct parse *p, struct re_guts *g);
  *
  * This algorithm assumes g->must exists and is has size greater than
  * zero. It's based on the algorithm found on Computer Algorithms by
@@ -1890,7 +1894,7 @@ computejumps(struct parse *p, struct re_guts *g)
 
 /*
  - computematchjumps - compute match jumps for BM scan
- == static void computematchjumps(register struct parse *p, register struct re_guts *g);
+ == static void computematchjumps(struct parse *p, struct re_guts *g);
  *
  * This algorithm assumes g->must exists and is has size greater than
  * zero. It's based on the algorithm found on Computer Algorithms by
@@ -1973,7 +1977,7 @@ computematchjumps(struct parse *p, struct re_guts *g)
 
 /*
  - pluscount - count + nesting
- == static sopno pluscount(register struct parse *p, register struct re_guts *g);
+ == static sopno pluscount(struct parse *p, struct re_guts *g);
  */
 static sopno                   /* nesting depth */
 pluscount(struct parse *p, struct re_guts *g)