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

diff --git a/lib/libc/regex/regcomp.c b/lib/libc/regex/regcomp.c
index 2a0ad5aa85..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.5 2004/10/25 19:38:01 drhodus 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 */
@@ -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 */
@@ -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;
@@ -497,7 +500,7 @@ p_ere_exp(struct parse *p)
 static void
 p_str(struct parse *p)
 {
-	(void)REQUIRE(MORE(), REG_EMPTY);
+	REQUIRE(MORE(), REG_EMPTY);
 	while (MORE())
 		ordinary(p, GETNEXT());
 }
@@ -539,7 +542,7 @@ p_bre(struct parse *p,
 		p->g->neol++;
 	}
 
-	(void)REQUIRE(HERE() != start, REG_EMPTY);	/* require nonempty */
+	REQUIRE(HERE() != start, REG_EMPTY);	/* require nonempty */
 }
 
 /*
@@ -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 */
@@ -674,7 +677,7 @@ p_count(struct parse *p)
 		ndigits++;
 	}
 
-	(void)REQUIRE(ndigits > 0 && count <= DUPMAX, REG_BADBR);
+	REQUIRE(ndigits > 0 && count <= DUPMAX, REG_BADBR);
 	return(count);
 }
 
@@ -713,7 +716,7 @@ 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;
@@ -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
@@ -947,13 +950,13 @@ 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);
 }
 
@@ -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);
@@ -1319,7 +1321,7 @@ 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';
 }
 
@@ -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) {
@@ -1385,7 +1386,7 @@ mcfind(cset *cs, char *cp)
  * is deferred.
  */
 static void
-mcinvert(struct parse *p, cset *cs)
+mcinvert(struct parse *p __unused, cset *cs)
 {
 	assert(cs->multis == NULL);	/* xxx */
 }
@@ -1398,7 +1399,7 @@ mcinvert(struct parse *p, cset *cs)
  * is deferred.
  */
 static void
-mccase(struct parse *p, cset *cs)
+mccase(struct parse *p __unused, cset *cs)
 {
 	assert(cs->multis == NULL);	/* xxx */
 }
@@ -1483,8 +1484,8 @@ 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);
 }
@@ -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;