aboutsummaryrefslogtreecommitdiff
path: root/src/backend/regex/regcomp.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/backend/regex/regcomp.c')
-rw-r--r--src/backend/regex/regcomp.c961
1 files changed, 481 insertions, 480 deletions
diff --git a/src/backend/regex/regcomp.c b/src/backend/regex/regcomp.c
index dcb95173c06..da4f2020ce3 100644
--- a/src/backend/regex/regcomp.c
+++ b/src/backend/regex/regcomp.c
@@ -38,7 +38,7 @@
*/
#if defined(LIBC_SCCS) && !defined(lint)
-static char sccsid[] = "@(#)regcomp.c 8.5 (Berkeley) 3/20/94";
+static char sccsid[] = "@(#)regcomp.c 8.5 (Berkeley) 3/20/94";
#endif /* LIBC_SCCS and not lint */
@@ -62,64 +62,64 @@ static char sccsid[] = "@(#)regcomp.c 8.5 (Berkeley) 3/20/94";
*/
struct parse
{
- char *next; /* next character in RE */
- char *end; /* end of string (-> NUL normally) */
- int error; /* has an error been seen? */
- sop *strip; /* malloced strip */
- sopno ssize; /* malloced strip size (allocated) */
- sopno slen; /* malloced strip length (used) */
- int ncsalloc; /* number of csets allocated */
+ char *next; /* next character in RE */
+ char *end; /* end of string (-> NUL normally) */
+ int error; /* has an error been seen? */
+ sop *strip; /* malloced strip */
+ sopno ssize; /* malloced strip size (allocated) */
+ sopno slen; /* malloced strip length (used) */
+ int ncsalloc; /* number of csets allocated */
struct re_guts *g;
#define NPAREN 10 /* we need to remember () 1-9 for back
* refs */
- sopno pbegin[NPAREN]; /* -> ( ([0] unused) */
- sopno pend[NPAREN]; /* -> ) ([0] unused) */
+ sopno pbegin[NPAREN]; /* -> ( ([0] unused) */
+ sopno pend[NPAREN]; /* -> ) ([0] unused) */
};
/* ========= begin header generated by ./mkh ========= */
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
/* === regcomp.c === */
- static void p_ere(struct parse * p, int stop);
- static void p_ere_exp(struct parse * p);
- static void p_str(struct parse * p);
- static void p_bre(struct parse * p, int end1, int end2);
- static int p_simp_re(struct parse * p, int starordinary);
- static int p_count(struct parse * p);
- static void p_bracket(struct parse * p);
- static void p_b_term(struct parse * p, cset * cs);
- static void p_b_cclass(struct parse * p, cset * cs);
- static void p_b_eclass(struct parse * p, cset * cs);
- static char p_b_symbol(struct parse * p);
- static char p_b_coll_elem(struct parse * p, int endc);
- static char othercase(int ch);
- static void bothcases(struct parse * p, int ch);
- static void ordinary(struct parse * p, int ch);
- static void nonnewline(struct parse * p);
- static void repeat(struct parse * p, sopno start, int from, int to);
- static int seterr(struct parse * p, int e);
- static cset *allocset(struct parse * p);
- static void freeset(struct parse * p, cset * cs);
- static int freezeset(struct parse * p, cset * cs);
- static int firstch(struct parse * p, cset * cs);
- static int nch(struct parse * p, cset * cs);
- static void mcadd(struct parse * p, cset * cs, char *cp);
- static void mcinvert(struct parse * p, cset * cs);
- static void mccase(struct parse * p, cset * cs);
- static int isinsets(struct re_guts * g, int c);
- static int samesets(struct re_guts * g, int c1, int c2);
- static void categorize(struct parse * p, struct re_guts * g);
- static sopno dupl(struct parse * p, sopno start, sopno finish);
- static void doemit(struct parse * p, sop op, size_t opnd);
- static void doinsert(struct parse * p, sop op, size_t opnd, sopno pos);
- static void dofwd(struct parse * p, sopno pos, sop value);
- static void enlarge(struct parse * p, sopno size);
- static void stripsnug(struct parse * p, struct re_guts * g);
- static void findmust(struct parse * p, struct re_guts * g);
- static sopno pluscount(struct parse * p, struct re_guts * g);
+ static void p_ere(struct parse * p, int stop);
+ static void p_ere_exp(struct parse * p);
+ static void p_str(struct parse * p);
+ static void p_bre(struct parse * p, int end1, int end2);
+ static int p_simp_re(struct parse * p, int starordinary);
+ static int p_count(struct parse * p);
+ static void p_bracket(struct parse * p);
+ static void p_b_term(struct parse * p, cset * cs);
+ static void p_b_cclass(struct parse * p, cset * cs);
+ static void p_b_eclass(struct parse * p, cset * cs);
+ static char p_b_symbol(struct parse * p);
+ static char p_b_coll_elem(struct parse * p, int endc);
+ static char othercase(int ch);
+ static void bothcases(struct parse * p, int ch);
+ static void ordinary(struct parse * p, int ch);
+ static void nonnewline(struct parse * p);
+ static void repeat(struct parse * p, sopno start, int from, int to);
+ static int seterr(struct parse * p, int e);
+ static cset *allocset(struct parse * p);
+ static void freeset(struct parse * p, cset * cs);
+ static int freezeset(struct parse * p, cset * cs);
+ static int firstch(struct parse * p, cset * cs);
+ static int nch(struct parse * p, cset * cs);
+ static void mcadd(struct parse * p, cset * cs, char *cp);
+ static void mcinvert(struct parse * p, cset * cs);
+ static void mccase(struct parse * p, cset * cs);
+ static int isinsets(struct re_guts * g, int c);
+ static int samesets(struct re_guts * g, int c1, int c2);
+ static void categorize(struct parse * p, struct re_guts * g);
+ static sopno dupl(struct parse * p, sopno start, sopno finish);
+ static void doemit(struct parse * p, sop op, size_t opnd);
+ static void doinsert(struct parse * p, sop op, size_t opnd, sopno pos);
+ static void dofwd(struct parse * p, sopno pos, sop value);
+ static void enlarge(struct parse * p, sopno size);
+ static void stripsnug(struct parse * p, struct re_guts * g);
+ static void findmust(struct parse * p, struct re_guts * g);
+ static sopno pluscount(struct parse * p, struct re_guts * g);
#ifdef __cplusplus
}
@@ -127,7 +127,7 @@ extern "C"
#endif
/* ========= end header generated by ./mkh ========= */
-static char nuls[10]; /* place to point scanner in event of
+static char nuls[10]; /* place to point scanner in event of
* error */
/*
@@ -161,7 +161,7 @@ static char nuls[10]; /* place to point scanner in event of
#define DROP(n) (p->slen -= (n))
#ifndef NDEBUG
-static int never = 0; /* for use in asserts; shuts lint up */
+static int never = 0; /* for use in asserts; shuts lint up */
#else
#define never 0 /* some <assert.h>s have bugs too */
@@ -181,14 +181,14 @@ static int never = 0; /* for use in asserts; shuts lint up */
*/
int /* 0 success, otherwise REG_something */
pg95_regcomp(preg, pattern, cflags)
-regex_t *preg;
-const char *pattern;
-int cflags;
+regex_t *preg;
+const char *pattern;
+int cflags;
{
- struct parse pa;
+ struct parse pa;
register struct re_guts *g;
register struct parse *p = &pa;
- register int i;
+ register int i;
register size_t len;
#ifdef REDEBUG
@@ -292,13 +292,13 @@ int cflags;
static void
p_ere(p, stop)
register struct parse *p;
-int stop; /* character this ERE should end at */
+int stop; /* character this ERE should end at */
{
- register char c;
- register sopno prevback = 0;
- register sopno prevfwd = 0;
- register sopno conc;
- register int first = 1; /* is this the first alternative? */
+ register char c;
+ register sopno prevback = 0;
+ register sopno prevfwd = 0;
+ register sopno conc;
+ register int first = 1; /* is this the first alternative? */
for (;;)
{
@@ -342,12 +342,12 @@ static void
p_ere_exp(p)
register struct parse *p;
{
- register char c;
- register sopno pos;
- register int count;
- register int count2;
- register sopno subno;
- int wascaret = 0;
+ register char c;
+ register sopno pos;
+ register int count;
+ register int count2;
+ register sopno subno;
+ int wascaret = 0;
assert(MORE()); /* caller should have ensured this */
c = GETNEXT();
@@ -355,75 +355,76 @@ register struct parse *p;
pos = HERE();
switch (c)
{
- case '(':
- REQUIRE(MORE(), REG_EPAREN);
- p->g->nsub++;
- subno = p->g->nsub;
- if (subno < NPAREN)
- p->pbegin[subno] = HERE();
- EMIT(OLPAREN, subno);
- if (!SEE(')'))
- p_ere(p, ')');
- if (subno < NPAREN)
- {
- p->pend[subno] = HERE();
- assert(p->pend[subno] != 0);
- }
- EMIT(ORPAREN, subno);
- MUSTEAT(')', REG_EPAREN);
- break;
+ case '(':
+ REQUIRE(MORE(), REG_EPAREN);
+ p->g->nsub++;
+ subno = p->g->nsub;
+ if (subno < NPAREN)
+ p->pbegin[subno] = HERE();
+ EMIT(OLPAREN, subno);
+ if (!SEE(')'))
+ p_ere(p, ')');
+ if (subno < NPAREN)
+ {
+ p->pend[subno] = HERE();
+ assert(p->pend[subno] != 0);
+ }
+ EMIT(ORPAREN, subno);
+ MUSTEAT(')', REG_EPAREN);
+ break;
#ifndef POSIX_MISTAKE
- case ')': /* happens only if no current unmatched ( */
-
- /*
- * You may ask, why the ifndef? Because I didn't notice this
- * until slightly too late for 1003.2, and none of the other
- * 1003.2 regular-expression reviewers noticed it at all. So an
- * unmatched ) is legal POSIX, at least until we can get it fixed.
- */
- SETERROR(REG_EPAREN);
- break;
+ case ')': /* happens only if no current unmatched ( */
+
+ /*
+ * You may ask, why the ifndef? Because I didn't notice this
+ * until slightly too late for 1003.2, and none of the other
+ * 1003.2 regular-expression reviewers noticed it at all. So
+ * an unmatched ) is legal POSIX, at least until we can get it
+ * fixed.
+ */
+ SETERROR(REG_EPAREN);
+ break;
#endif
- case '^':
- EMIT(OBOL, 0);
- p->g->iflags |= USEBOL;
- p->g->nbol++;
- wascaret = 1;
- break;
- case '$':
- EMIT(OEOL, 0);
- p->g->iflags |= USEEOL;
- p->g->neol++;
- break;
- case '|':
- SETERROR(REG_EMPTY);
- break;
- case '*':
- case '+':
- case '?':
- SETERROR(REG_BADRPT);
- break;
- case '.':
- if (p->g->cflags & REG_NEWLINE)
- nonnewline(p);
- else
- EMIT(OANY, 0);
- break;
- case '[':
- p_bracket(p);
- break;
- case '\\':
- REQUIRE(MORE(), REG_EESCAPE);
- c = GETNEXT();
- ordinary(p, c);
- break;
- case '{': /* okay as ordinary except if digit
+ case '^':
+ EMIT(OBOL, 0);
+ p->g->iflags |= USEBOL;
+ p->g->nbol++;
+ wascaret = 1;
+ break;
+ case '$':
+ EMIT(OEOL, 0);
+ p->g->iflags |= USEEOL;
+ p->g->neol++;
+ break;
+ case '|':
+ SETERROR(REG_EMPTY);
+ break;
+ case '*':
+ case '+':
+ case '?':
+ SETERROR(REG_BADRPT);
+ break;
+ case '.':
+ if (p->g->cflags & REG_NEWLINE)
+ nonnewline(p);
+ else
+ EMIT(OANY, 0);
+ break;
+ case '[':
+ p_bracket(p);
+ break;
+ case '\\':
+ REQUIRE(MORE(), REG_EESCAPE);
+ c = GETNEXT();
+ ordinary(p, c);
+ break;
+ case '{': /* okay as ordinary except if digit
* follows */
- REQUIRE(!MORE() || !isdigit(PEEK()), REG_BADRPT);
- /* FALLTHROUGH */
- default:
- ordinary(p, c);
- break;
+ REQUIRE(!MORE() || !isdigit(PEEK()), REG_BADRPT);
+ /* FALLTHROUGH */
+ default:
+ ordinary(p, c);
+ break;
}
if (!MORE())
@@ -438,51 +439,51 @@ register struct parse *p;
REQUIRE(!wascaret, REG_BADRPT);
switch (c)
{
- case '*': /* implemented as +? */
- /* this case does not require the (y|) trick, noKLUDGE */
- INSERT(OPLUS_, pos);
- ASTERN(O_PLUS, pos);
- INSERT(OQUEST_, pos);
- ASTERN(O_QUEST, pos);
- break;
- case '+':
- INSERT(OPLUS_, pos);
- ASTERN(O_PLUS, pos);
- break;
- case '?':
- /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
- INSERT(OCH_, pos); /* offset slightly wrong */
- ASTERN(OOR1, pos); /* this one's right */
- AHEAD(pos); /* fix the OCH_ */
- EMIT(OOR2, 0); /* offset very wrong... */
- AHEAD(THERE()); /* ...so fix it */
- ASTERN(O_CH, THERETHERE());
- break;
- case '{':
- count = p_count(p);
- if (EAT(','))
- {
- if (isdigit(PEEK()))
+ case '*': /* implemented as +? */
+ /* this case does not require the (y|) trick, noKLUDGE */
+ INSERT(OPLUS_, pos);
+ ASTERN(O_PLUS, pos);
+ INSERT(OQUEST_, pos);
+ ASTERN(O_QUEST, pos);
+ break;
+ case '+':
+ INSERT(OPLUS_, pos);
+ ASTERN(O_PLUS, pos);
+ break;
+ case '?':
+ /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
+ INSERT(OCH_, pos); /* offset slightly wrong */
+ ASTERN(OOR1, pos); /* this one's right */
+ AHEAD(pos); /* fix the OCH_ */
+ EMIT(OOR2, 0); /* offset very wrong... */
+ AHEAD(THERE()); /* ...so fix it */
+ ASTERN(O_CH, THERETHERE());
+ break;
+ case '{':
+ count = p_count(p);
+ if (EAT(','))
{
- count2 = p_count(p);
- REQUIRE(count <= count2, REG_BADBR);
+ if (isdigit(PEEK()))
+ {
+ count2 = p_count(p);
+ REQUIRE(count <= count2, REG_BADBR);
+ }
+ else
+/* single number with comma */
+ count2 = INFINITY;
}
else
-/* single number with comma */
- count2 = INFINITY;
- }
- else
/* just a single number */
- count2 = count;
- repeat(p, pos, count, count2);
- if (!EAT('}'))
- { /* error heuristics */
- while (MORE() && PEEK() != '}')
- NEXT();
- REQUIRE(MORE(), REG_EBRACE);
- SETERROR(REG_BADBR);
- }
- break;
+ count2 = count;
+ repeat(p, pos, count, count2);
+ if (!EAT('}'))
+ { /* error heuristics */
+ while (MORE() && PEEK() != '}')
+ NEXT();
+ REQUIRE(MORE(), REG_EBRACE);
+ SETERROR(REG_BADBR);
+ }
+ break;
}
if (!MORE())
@@ -522,12 +523,12 @@ register struct parse *p;
static void
p_bre(p, end1, end2)
register struct parse *p;
-register int end1; /* first terminating character */
-register int end2; /* second terminating character */
+register int end1; /* first terminating character */
+register int end2; /* second terminating character */
{
- register sopno start = HERE();
- register int first = 1; /* first subexpression? */
- register int wasdollar = 0;
+ register sopno start = HERE();
+ register int first = 1; /* first subexpression? */
+ register int wasdollar = 0;
if (EAT('^'))
{
@@ -558,14 +559,14 @@ register int end2; /* second terminating character */
static int /* was the simple RE an unbackslashed $? */
p_simp_re(p, starordinary)
register struct parse *p;
-int starordinary; /* is a leading * an ordinary character? */
+int starordinary; /* is a leading * an ordinary character? */
{
- register int c;
- register int count;
- register int count2;
- register sopno pos;
- register int i;
- register sopno subno;
+ register int c;
+ register int count;
+ register int count2;
+ register sopno pos;
+ register int i;
+ register sopno subno;
#define BACKSL (1<<CHAR_BIT)
@@ -580,70 +581,70 @@ int starordinary; /* is a leading * an ordinary character? */
}
switch (c)
{
- case '.':
- if (p->g->cflags & REG_NEWLINE)
- nonnewline(p);
- else
- EMIT(OANY, 0);
- break;
- case '[':
- p_bracket(p);
- break;
- case BACKSL | '{':
- SETERROR(REG_BADRPT);
- break;
- case BACKSL | '(':
- p->g->nsub++;
- subno = p->g->nsub;
- if (subno < NPAREN)
- p->pbegin[subno] = HERE();
- EMIT(OLPAREN, subno);
- /* the MORE here is an error heuristic */
- if (MORE() && !SEETWO('\\', ')'))
- p_bre(p, '\\', ')');
- if (subno < NPAREN)
- {
- p->pend[subno] = HERE();
- assert(p->pend[subno] != 0);
- }
- EMIT(ORPAREN, subno);
- REQUIRE(EATTWO('\\', ')'), REG_EPAREN);
- break;
- case BACKSL | ')': /* should not get here -- must be user */
- case BACKSL | '}':
- SETERROR(REG_EPAREN);
- break;
- case BACKSL | '1':
- case BACKSL | '2':
- case BACKSL | '3':
- case BACKSL | '4':
- case BACKSL | '5':
- case BACKSL | '6':
- case BACKSL | '7':
- case BACKSL | '8':
- case BACKSL | '9':
- i = (c & ~BACKSL) - '0';
- assert(i < NPAREN);
- if (p->pend[i] != 0)
- {
- assert(i <= p->g->nsub);
- EMIT(OBACK_, i);
- assert(p->pbegin[i] != 0);
- assert(OP(p->strip[p->pbegin[i]]) == OLPAREN);
- assert(OP(p->strip[p->pend[i]]) == ORPAREN);
- dupl(p, p->pbegin[i] + 1, p->pend[i]);
- EMIT(O_BACK, i);
- }
- else
- SETERROR(REG_ESUBREG);
- p->g->backrefs = 1;
- break;
- case '*':
- REQUIRE(starordinary, REG_BADRPT);
- /* FALLTHROUGH */
- default:
- ordinary(p, c & ~BACKSL);
- break;
+ case '.':
+ if (p->g->cflags & REG_NEWLINE)
+ nonnewline(p);
+ else
+ EMIT(OANY, 0);
+ break;
+ case '[':
+ p_bracket(p);
+ break;
+ case BACKSL | '{':
+ SETERROR(REG_BADRPT);
+ break;
+ case BACKSL | '(':
+ p->g->nsub++;
+ subno = p->g->nsub;
+ if (subno < NPAREN)
+ p->pbegin[subno] = HERE();
+ EMIT(OLPAREN, subno);
+ /* the MORE here is an error heuristic */
+ if (MORE() && !SEETWO('\\', ')'))
+ p_bre(p, '\\', ')');
+ if (subno < NPAREN)
+ {
+ p->pend[subno] = HERE();
+ assert(p->pend[subno] != 0);
+ }
+ EMIT(ORPAREN, subno);
+ REQUIRE(EATTWO('\\', ')'), REG_EPAREN);
+ break;
+ case BACKSL | ')': /* should not get here -- must be user */
+ case BACKSL | '}':
+ SETERROR(REG_EPAREN);
+ break;
+ case BACKSL | '1':
+ case BACKSL | '2':
+ case BACKSL | '3':
+ case BACKSL | '4':
+ case BACKSL | '5':
+ case BACKSL | '6':
+ case BACKSL | '7':
+ case BACKSL | '8':
+ case BACKSL | '9':
+ i = (c & ~BACKSL) - '0';
+ assert(i < NPAREN);
+ if (p->pend[i] != 0)
+ {
+ assert(i <= p->g->nsub);
+ EMIT(OBACK_, i);
+ assert(p->pbegin[i] != 0);
+ assert(OP(p->strip[p->pbegin[i]]) == OLPAREN);
+ assert(OP(p->strip[p->pend[i]]) == ORPAREN);
+ dupl(p, p->pbegin[i] + 1, p->pend[i]);
+ EMIT(O_BACK, i);
+ }
+ else
+ SETERROR(REG_ESUBREG);
+ p->g->backrefs = 1;
+ break;
+ case '*':
+ REQUIRE(starordinary, REG_BADRPT);
+ /* FALLTHROUGH */
+ default:
+ ordinary(p, c & ~BACKSL);
+ break;
}
if (EAT('*'))
@@ -694,8 +695,8 @@ static int /* the value */
p_count(p)
register struct parse *p;
{
- register int count = 0;
- register int ndigits = 0;
+ register int count = 0;
+ register int ndigits = 0;
while (MORE() && isdigit(PEEK()) && count <= DUPMAX)
{
@@ -718,8 +719,8 @@ static void
p_bracket(p)
register struct parse *p;
{
- register cset *cs = allocset(p);
- register int invert = 0;
+ register cset *cs = allocset(p);
+ register int invert = 0;
/* Dept of Truly Sickening Special-Case Kludges */
if (p->next + 5 < p->end && strncmp(p->next, "[:<:]]", 6) == 0)
@@ -752,8 +753,8 @@ register struct parse *p;
if (p->g->cflags & REG_ICASE)
{
- register int i;
- register int ci;
+ register int i;
+ register int ci;
for (i = p->g->csetsize - 1; i >= 0; i--)
if (CHIN(cs, i) && isalpha(i))
@@ -767,7 +768,7 @@ register struct parse *p;
}
if (invert)
{
- register int i;
+ register int i;
for (i = p->g->csetsize - 1; i >= 0; i--)
if (CHIN(cs, i))
@@ -798,67 +799,67 @@ register struct parse *p;
static void
p_b_term(p, cs)
register struct parse *p;
-register cset *cs;
+register cset *cs;
{
- register char c;
- register char start,
- finish;
- register int i;
+ register char c;
+ register char start,
+ finish;
+ register int i;
/* classify what we've got */
switch ((MORE()) ? PEEK() : '\0')
{
- case '[':
- c = (MORE2()) ? PEEK2() : '\0';
- break;
- case '-':
- SETERROR(REG_ERANGE);
- return; /* NOTE RETURN */
- break;
- default:
- c = '\0';
- break;
+ case '[':
+ c = (MORE2()) ? PEEK2() : '\0';
+ break;
+ case '-':
+ SETERROR(REG_ERANGE);
+ return; /* NOTE RETURN */
+ break;
+ default:
+ c = '\0';
+ break;
}
switch (c)
{
- case ':': /* character class */
- NEXT2();
- REQUIRE(MORE(), REG_EBRACK);
- c = PEEK();
- REQUIRE(c != '-' && c != ']', REG_ECTYPE);
- p_b_cclass(p, cs);
- REQUIRE(MORE(), REG_EBRACK);
- REQUIRE(EATTWO(':', ']'), REG_ECTYPE);
- break;
- case '=': /* equivalence class */
- NEXT2();
- REQUIRE(MORE(), REG_EBRACK);
- c = PEEK();
- REQUIRE(c != '-' && c != ']', REG_ECOLLATE);
- p_b_eclass(p, cs);
- REQUIRE(MORE(), REG_EBRACK);
- REQUIRE(EATTWO('=', ']'), REG_ECOLLATE);
- break;
- default: /* symbol, ordinary character, or range */
+ case ':': /* character class */
+ NEXT2();
+ REQUIRE(MORE(), REG_EBRACK);
+ c = PEEK();
+ REQUIRE(c != '-' && c != ']', REG_ECTYPE);
+ p_b_cclass(p, cs);
+ REQUIRE(MORE(), REG_EBRACK);
+ REQUIRE(EATTWO(':', ']'), REG_ECTYPE);
+ break;
+ case '=': /* equivalence class */
+ NEXT2();
+ REQUIRE(MORE(), REG_EBRACK);
+ c = PEEK();
+ REQUIRE(c != '-' && c != ']', REG_ECOLLATE);
+ p_b_eclass(p, cs);
+ REQUIRE(MORE(), REG_EBRACK);
+ REQUIRE(EATTWO('=', ']'), REG_ECOLLATE);
+ break;
+ default: /* symbol, ordinary character, or range */
/* xxx revision needed for multichar stuff */
- start = p_b_symbol(p);
- if (SEE('-') && MORE2() && PEEK2() != ']')
- {
- /* range */
- NEXT();
- if (EAT('-'))
- finish = '-';
+ start = p_b_symbol(p);
+ if (SEE('-') && MORE2() && PEEK2() != ']')
+ {
+ /* range */
+ NEXT();
+ if (EAT('-'))
+ finish = '-';
+ else
+ finish = p_b_symbol(p);
+ }
else
- finish = p_b_symbol(p);
- }
- else
- finish = start;
+ finish = start;
/* xxx what about signed chars here... */
- REQUIRE(start <= finish, REG_ERANGE);
- for (i = start; i <= finish; i++)
- CHadd(cs, i);
- break;
+ REQUIRE(start <= finish, REG_ERANGE);
+ for (i = start; i <= finish; i++)
+ CHadd(cs, i);
+ break;
}
}
@@ -869,13 +870,13 @@ register cset *cs;
static void
p_b_cclass(p, cs)
register struct parse *p;
-register cset *cs;
+register cset *cs;
{
- register char *sp = p->next;
+ register char *sp = p->next;
register struct cclass *cp;
register size_t len;
- register char *u;
- register char c;
+ register char *u;
+ register char c;
while (MORE() && isalpha(PEEK()))
NEXT();
@@ -906,9 +907,9 @@ register cset *cs;
static void
p_b_eclass(p, cs)
register struct parse *p;
-register cset *cs;
+register cset *cs;
{
- register char c;
+ register char c;
c = p_b_coll_elem(p, '=');
CHadd(cs, c);
@@ -922,7 +923,7 @@ static char /* value of symbol */
p_b_symbol(p)
register struct parse *p;
{
- register char value;
+ register char value;
REQUIRE(MORE(), REG_EBRACK);
if (!EATTWO('[', '.'))
@@ -941,11 +942,11 @@ register struct parse *p;
static char /* value of collating element */
p_b_coll_elem(p, endc)
register struct parse *p;
-int endc; /* name ended by endc,']' */
+int endc; /* name ended by endc,']' */
{
- register char *sp = p->next;
+ register char *sp = p->next;
register struct cname *cp;
- register int len;
+ register int len;
while (MORE() && !SEETWO(endc, ']'))
NEXT();
@@ -970,7 +971,7 @@ int endc; /* name ended by endc,']' */
*/
static char /* if no counterpart, return ch */
othercase(ch)
-int ch;
+int ch;
{
assert(isalpha(ch));
if (isupper(ch))
@@ -991,11 +992,11 @@ int ch;
static void
bothcases(p, ch)
register struct parse *p;
-int ch;
+int ch;
{
- register char *oldnext = p->next;
- register char *oldend = p->end;
- char bracket[3];
+ register char *oldnext = p->next;
+ register char *oldend = p->end;
+ char bracket[3];
assert(othercase(ch) != ch);/* p_bracket() would recurse */
p->next = bracket;
@@ -1016,7 +1017,7 @@ int ch;
static void
ordinary(p, ch)
register struct parse *p;
-register int ch;
+register int ch;
{
register cat_t *cap = p->g->categories;
@@ -1040,9 +1041,9 @@ static void
nonnewline(p)
register struct parse *p;
{
- register char *oldnext = p->next;
- register char *oldend = p->end;
- char bracket[4];
+ register char *oldnext = p->next;
+ register char *oldend = p->end;
+ char bracket[4];
p->next = bracket;
p->end = bracket + 3;
@@ -1063,18 +1064,18 @@ register struct parse *p;
static void
repeat(p, start, from, to)
register struct parse *p;
-sopno start; /* operand from here to end of strip */
-int from; /* repeated from this number */
-int to; /* to this number of times (maybe
+sopno start; /* operand from here to end of strip */
+int from; /* repeated from this number */
+int to; /* to this number of times (maybe
* INFINITY) */
{
- register sopno finish = HERE();
+ register sopno finish = HERE();
#define N 2
#define INF 3
#define REP(f, t) ((f)*8 + (t))
#define MAP(n) (((n) <= 1) ? (n) : ((n) == INFINITY) ? INF : N)
- register sopno copy;
+ register sopno copy;
if (p->error != 0) /* head off possible runaway recursion */
return;
@@ -1083,51 +1084,51 @@ int to; /* to this number of times (maybe
switch (REP(MAP(from), MAP(to)))
{
- case REP(0, 0): /* must be user doing this */
- DROP(finish - start); /* drop the operand */
- break;
- case REP(0, 1): /* as x{1,1}? */
- case REP(0, N): /* as x{1,n}? */
- case REP(0, INF): /* as x{1,}? */
- /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
- INSERT(OCH_, start); /* offset is wrong... */
- repeat(p, start + 1, 1, to);
- ASTERN(OOR1, start);
- AHEAD(start); /* ... fix it */
- EMIT(OOR2, 0);
- AHEAD(THERE());
- ASTERN(O_CH, THERETHERE());
- break;
- case REP(1, 1): /* trivial case */
- /* done */
- break;
- case REP(1, N): /* as x?x{1,n-1} */
- /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
- INSERT(OCH_, start);
- ASTERN(OOR1, start);
- AHEAD(start);
- EMIT(OOR2, 0); /* offset very wrong... */
- AHEAD(THERE()); /* ...so fix it */
- ASTERN(O_CH, THERETHERE());
- copy = dupl(p, start + 1, finish + 1);
- assert(copy == finish + 4);
- repeat(p, copy, 1, to - 1);
- break;
- case REP(1, INF): /* as x+ */
- INSERT(OPLUS_, start);
- ASTERN(O_PLUS, start);
- break;
- case REP(N, N): /* as xx{m-1,n-1} */
- copy = dupl(p, start, finish);
- repeat(p, copy, from - 1, to - 1);
- break;
- case REP(N, INF): /* as xx{n-1,INF} */
- copy = dupl(p, start, finish);
- repeat(p, copy, from - 1, to);
- break;
- default: /* "can't happen" */
- SETERROR(REG_ASSERT); /* just in case */
- break;
+ case REP(0, 0): /* must be user doing this */
+ DROP(finish - start); /* drop the operand */
+ break;
+ case REP(0, 1): /* as x{1,1}? */
+ case REP(0, N): /* as x{1,n}? */
+ case REP(0, INF): /* as x{1,}? */
+ /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
+ INSERT(OCH_, start);/* offset is wrong... */
+ repeat(p, start + 1, 1, to);
+ ASTERN(OOR1, start);
+ AHEAD(start); /* ... fix it */
+ EMIT(OOR2, 0);
+ AHEAD(THERE());
+ ASTERN(O_CH, THERETHERE());
+ break;
+ case REP(1, 1): /* trivial case */
+ /* done */
+ break;
+ case REP(1, N): /* as x?x{1,n-1} */
+ /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
+ INSERT(OCH_, start);
+ ASTERN(OOR1, start);
+ AHEAD(start);
+ EMIT(OOR2, 0); /* offset very wrong... */
+ AHEAD(THERE()); /* ...so fix it */
+ ASTERN(O_CH, THERETHERE());
+ copy = dupl(p, start + 1, finish + 1);
+ assert(copy == finish + 4);
+ repeat(p, copy, 1, to - 1);
+ break;
+ case REP(1, INF): /* as x+ */
+ INSERT(OPLUS_, start);
+ ASTERN(O_PLUS, start);
+ break;
+ case REP(N, N): /* as xx{m-1,n-1} */
+ copy = dupl(p, start, finish);
+ repeat(p, copy, from - 1, to - 1);
+ break;
+ case REP(N, INF): /* as xx{n-1,INF} */
+ copy = dupl(p, start, finish);
+ repeat(p, copy, from - 1, to);
+ break;
+ default: /* "can't happen" */
+ SETERROR(REG_ASSERT); /* just in case */
+ break;
}
}
@@ -1138,7 +1139,7 @@ int to; /* to this number of times (maybe
static int /* useless but makes type checking happy */
seterr(p, e)
register struct parse *p;
-int e;
+int e;
{
if (p->error == 0) /* keep earliest error condition */
p->error = e;
@@ -1151,16 +1152,16 @@ int e;
- allocset - allocate a set of characters for []
== static cset *allocset(register struct parse *p);
*/
-static cset *
+static cset *
allocset(p)
register struct parse *p;
{
- register int no = p->g->ncsets++;
+ register int no = p->g->ncsets++;
register size_t nc;
register size_t nbytes;
- register cset *cs;
+ register cset *cs;
register size_t css = (size_t) p->g->csetsize;
- register int i;
+ register int i;
if (no >= p->ncsalloc)
{ /* need another column of space */
@@ -1212,10 +1213,10 @@ register struct parse *p;
static void
freeset(p, cs)
register struct parse *p;
-register cset *cs;
+register cset *cs;
{
- register int i;
- register cset *top = &p->g->sets[p->g->ncsets];
+ register int i;
+ register cset *top = &p->g->sets[p->g->ncsets];
register size_t css = (size_t) p->g->csetsize;
for (i = 0; i < css; i++)
@@ -1237,12 +1238,12 @@ register cset *cs;
static int /* set number */
freezeset(p, cs)
register struct parse *p;
-register cset *cs;
+register cset *cs;
{
- register uch h = cs->hash;
- register int i;
- register cset *top = &p->g->sets[p->g->ncsets];
- register cset *cs2;
+ register uch h = cs->hash;
+ register int i;
+ register cset *top = &p->g->sets[p->g->ncsets];
+ register cset *cs2;
register size_t css = (size_t) p->g->csetsize;
/* look for an earlier one which is the same */
@@ -1273,9 +1274,9 @@ register cset *cs;
static int /* character; there is no "none" value */
firstch(p, cs)
register struct parse *p;
-register cset *cs;
+register cset *cs;
{
- register int i;
+ register int i;
register size_t css = (size_t) p->g->csetsize;
for (i = 0; i < css; i++)
@@ -1292,11 +1293,11 @@ register cset *cs;
static int
nch(p, cs)
register struct parse *p;
-register cset *cs;
+register cset *cs;
{
- register int i;
+ register int i;
register size_t css = (size_t) p->g->csetsize;
- register int n = 0;
+ register int n = 0;
for (i = 0; i < css; i++)
if (CHIN(cs, i))
@@ -1312,8 +1313,8 @@ register cset *cs;
static void
mcadd(p, cs, cp)
register struct parse *p;
-register cset *cs;
-register char *cp;
+register cset *cs;
+register char *cp;
{
register size_t oldend = cs->smultis;
@@ -1405,7 +1406,7 @@ register char *cp;
static void
mcinvert(p, cs)
register struct parse *p;
-register cset *cs;
+register cset *cs;
{
assert(cs->multis == NULL); /* xxx */
}
@@ -1420,7 +1421,7 @@ register cset *cs;
static void
mccase(p, cs)
register struct parse *p;
-register cset *cs;
+register cset *cs;
{
assert(cs->multis == NULL); /* xxx */
}
@@ -1432,11 +1433,11 @@ register cset *cs;
static int /* predicate */
isinsets(g, c)
register struct re_guts *g;
-int c;
+int c;
{
- register uch *col;
- register int i;
- register int ncols = (g->ncsets + (CHAR_BIT - 1)) / CHAR_BIT;
+ register uch *col;
+ register int i;
+ register int ncols = (g->ncsets + (CHAR_BIT - 1)) / CHAR_BIT;
register unsigned uc = (unsigned char) c;
for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
@@ -1452,12 +1453,12 @@ int c;
static int /* predicate */
samesets(g, c1, c2)
register struct re_guts *g;
-int c1;
-int c2;
+int c1;
+int c2;
{
- register uch *col;
- register int i;
- register int ncols = (g->ncsets + (CHAR_BIT - 1)) / CHAR_BIT;
+ register uch *col;
+ register int i;
+ register int ncols = (g->ncsets + (CHAR_BIT - 1)) / CHAR_BIT;
register unsigned uc1 = (unsigned char) c1;
register unsigned uc2 = (unsigned char) c2;
@@ -1473,13 +1474,13 @@ int c2;
*/
static void
categorize(p, g)
-struct parse *p;
+struct parse *p;
register struct re_guts *g;
{
register cat_t *cats = g->categories;
- register int c;
- register int c2;
- register cat_t cat;
+ register int c;
+ register int c2;
+ register cat_t cat;
/* avoid making error situations worse */
if (p->error != 0)
@@ -1500,14 +1501,14 @@ register 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 /* start of duplicate */
+static sopno /* start of duplicate */
dupl(p, start, finish)
register struct parse *p;
-sopno start; /* from here */
-sopno finish; /* to this less one */
+sopno start; /* from here */
+sopno finish; /* to this less one */
{
- register sopno ret = HERE();
- register sopno len = finish - start;
+ register sopno ret = HERE();
+ register sopno len = finish - start;
assert(finish >= start);
if (len == 0)
@@ -1531,8 +1532,8 @@ sopno finish; /* to this less one */
static void
doemit(p, op, opnd)
register struct parse *p;
-sop op;
-size_t opnd;
+sop op;
+size_t opnd;
{
/* avoid making error situations worse */
if (p->error != 0)
@@ -1557,13 +1558,13 @@ size_t opnd;
static void
doinsert(p, op, opnd, pos)
register struct parse *p;
-sop op;
-size_t opnd;
-sopno pos;
+sop op;
+size_t opnd;
+sopno pos;
{
- register sopno sn;
- register sop s;
- register int i;
+ register sopno sn;
+ register sop s;
+ register int i;
/* avoid making error situations worse */
if (p->error != 0)
@@ -1600,8 +1601,8 @@ sopno pos;
static void
dofwd(p, pos, value)
register struct parse *p;
-register sopno pos;
-sop value;
+register sopno pos;
+sop value;
{
/* avoid making error situations worse */
if (p->error != 0)
@@ -1618,9 +1619,9 @@ sop value;
static void
enlarge(p, size)
register struct parse *p;
-register sopno size;
+register sopno size;
{
- register sop *sp;
+ register sop *sp;
if (p->ssize >= size)
return;
@@ -1665,16 +1666,16 @@ register struct re_guts *g;
*/
static void
findmust(p, g)
-struct parse *p;
+struct parse *p;
register struct re_guts *g;
{
- register sop *scan;
- sop *start = 0;
- register sop *newstart = 0;
- register sopno newlen;
- register sop s;
- register char *cp;
- register sopno i;
+ register sop *scan;
+ sop *start = 0;
+ register sop *newstart = 0;
+ register sopno newlen;
+ register sop s;
+ register char *cp;
+ register sopno i;
/* avoid making error situations worse */
if (p->error != 0)
@@ -1688,39 +1689,39 @@ register struct re_guts *g;
s = *scan++;
switch (OP(s))
{
- case OCHAR: /* sequence member */
- if (newlen == 0) /* new sequence */
- newstart = scan - 1;
- newlen++;
- break;
- case OPLUS_: /* things that don't break one */
- case OLPAREN:
- case ORPAREN:
- break;
- case OQUEST_: /* things that must be skipped */
- case OCH_:
- scan--;
- do
- {
- scan += OPND(s);
- s = *scan;
- /* assert() interferes w debug printouts */
- if (OP(s) != O_QUEST && OP(s) != O_CH &&
- OP(s) != OOR2)
+ case OCHAR: /* sequence member */
+ if (newlen == 0)/* new sequence */
+ newstart = scan - 1;
+ newlen++;
+ break;
+ case OPLUS_: /* things that don't break one */
+ case OLPAREN:
+ case ORPAREN:
+ break;
+ case OQUEST_: /* things that must be skipped */
+ case OCH_:
+ scan--;
+ do
{
- g->iflags |= BAD;
- return;
+ scan += OPND(s);
+ s = *scan;
+ /* assert() interferes w debug printouts */
+ if (OP(s) != O_QUEST && OP(s) != O_CH &&
+ OP(s) != OOR2)
+ {
+ g->iflags |= BAD;
+ return;
+ }
+ } while (OP(s) != O_QUEST && OP(s) != O_CH);
+ /* fallthrough */
+ default: /* things that break a sequence */
+ if (newlen > g->mlen)
+ { /* ends one */
+ start = newstart;
+ g->mlen = newlen;
}
- } while (OP(s) != O_QUEST && OP(s) != O_CH);
- /* fallthrough */
- default: /* things that break a sequence */
- if (newlen > g->mlen)
- { /* ends one */
- start = newstart;
- g->mlen = newlen;
- }
- newlen = 0;
- break;
+ newlen = 0;
+ break;
}
} while (OP(s) != OEND);
@@ -1751,15 +1752,15 @@ register struct re_guts *g;
- pluscount - count + nesting
== static sopno pluscount(register struct parse *p, register struct re_guts *g);
*/
-static sopno /* nesting depth */
+static sopno /* nesting depth */
pluscount(p, g)
-struct parse *p;
+struct parse *p;
register struct re_guts *g;
{
- register sop *scan;
- register sop s;
- register sopno plusnest = 0;
- register sopno maxnest = 0;
+ register sop *scan;
+ register sop s;
+ register sopno plusnest = 0;
+ register sopno maxnest = 0;
if (p->error != 0)
return (0); /* there may not be an OEND */
@@ -1770,14 +1771,14 @@ register struct re_guts *g;
s = *scan++;
switch (OP(s))
{
- case OPLUS_:
- plusnest++;
- break;
- case O_PLUS:
- if (plusnest > maxnest)
- maxnest = plusnest;
- plusnest--;
- break;
+ case OPLUS_:
+ plusnest++;
+ break;
+ case O_PLUS:
+ if (plusnest > maxnest)
+ maxnest = plusnest;
+ plusnest--;
+ break;
}
} while (OP(s) != OEND);
if (plusnest != 0)
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-24 20:30:57 +0000