6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-08-15 06:29:05 +00:00
Code Issues Projects Releases Wiki Activity

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

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@100438 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Owen Anderson
2010-04-05 17:50:20 +00:00
parent 0752cda4de
commit d2520dcc70
2 changed files with 51 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
lib/Support/regengine.inc
View File

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

4
lib/Support/regexec.c
View File

@@ -155,7 +155,7 @@ llvm_regexec(const llvm_regex_t *preg, const char *string, size_t nmatch,
eflags = GOODFLAGS(eflags); eflags = GOODFLAGS(eflags);
if (g->nstates <= (long)(CHAR_BIT*sizeof(states1)) && !(eflags&REG_LARGE)) 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 else
return(lmatcher(g, (char *)string, nmatch, pmatch, eflags)); return(lmatcher(g, string, nmatch, pmatch, eflags));
} }