Commit a52223b5 authored by Tanya Lattner's avatar Tanya Lattner
Browse files

Merge 100438 from mainline. 

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

llvm-svn: 100450
parent b76aad9f

llvm/lib/Support/regengine.inc

+49 −42
Original line number Diff line number Diff line
@@ -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);

llvm/lib/Support/regexec.c

+2 −2
Original line number Diff line number Diff line
@@ -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));

}