X-Git-Url: https://gitweb.dragonflybsd.org/dragonfly.git/blobdiff_plain/00ca19905df30d0ca6b2478303af8d44ce26f076..ba4bf14e4de249e95eebf9ef32d8b825594e5936:/lib/libc/regex/regcomp.c

diff --git a/lib/libc/regex/regcomp.c b/lib/libc/regex/regcomp.c
index c539d6e199..54c313476c 100644
--- a/lib/libc/regex/regcomp.c
+++ b/lib/libc/regex/regcomp.c
@@ -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)