X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=regex-src%2Fregcomp.c;h=2f9fa70b53e6a63ffebb4df870b456a939e73fea;hb=refs%2Ftags%2Fupstream%2F2.5.1;hp=08e8a9fcf4acce40b497f88e6b25f1fed7a61046;hpb=94c03cae686e4196a345d72452fda2a5203768ce;p=debian%2Famanda diff --git a/regex-src/regcomp.c b/regex-src/regcomp.c index 08e8a9f..2f9fa70 100644 --- a/regex-src/regcomp.c +++ b/regex-src/regcomp.c @@ -1,11 +1,5 @@ -#include -#include -#include -#include -#include -#include +#include "amanda.h" #include - #include "utils.h" #include "regex2.h" @@ -21,8 +15,8 @@ struct parse { 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) */ + size_t ssize; /* malloced strip size (allocated) */ + size_t 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 */ @@ -56,13 +50,13 @@ static char nuls[10]; /* place to point scanner in event of error */ #define MUSTEAT(c, e) (REQUIRE(MORE() && GETNEXT() == (c), e)) #define MUSTNOTSEE(c, e) (REQUIRE(!MORE() || PEEK() != (c), e)) #define EMIT(op, sopnd) doemit(p, (sop)(op), (size_t)(sopnd)) -#define INSERT(op, pos) doinsert(p, (sop)(op), HERE()-(pos)+1, pos) -#define AHEAD(pos) dofwd(p, pos, HERE()-(pos)) -#define ASTERN(sop, pos) EMIT(sop, HERE()-pos) -#define HERE() (p->slen) -#define THERE() (p->slen - 1) -#define THERETHERE() (p->slen - 2) -#define DROP(n) (p->slen -= (n)) +#define INSERT(op, pos) doinsert(p, (sop)(op), HERE()-(size_t)(pos)+1, (size_t)pos) +#define AHEAD(pos) dofwd(p, (size_t)pos, HERE()-(size_t)(pos)) +#define ASTERN(sop, pos) EMIT(sop, HERE()-(size_t)(pos)) +#define HERE() (size_t)(p->slen) +#define THERE() (size_t)(p->slen - 1) +#define THERETHERE() (size_t)(p->slen - 2) +#define DROP(n) (p->slen = p->slen - (size_t)(n)) #ifndef NDEBUG static int never = 0; /* for use in asserts; shuts lint up */ @@ -70,6 +64,45 @@ static int never = 0; /* for use in asserts; shuts lint up */ #define never 0 /* some s have bugs too */ #endif +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); + + /* - regcomp - interface for parser and compilation = extern int regcomp(regex_t *, const char *, int); @@ -83,16 +116,16 @@ static int never = 0; /* for use in asserts; shuts lint up */ = #define REG_DUMP 0200 */ int /* 0 success, otherwise REG_something */ -regcomp(preg, pattern, cflags) -regex_t *preg; -const char *pattern; -int cflags; +regcomp( + regex_t * preg, + const char *pattern, + int cflags) { struct parse pa; - register struct re_guts *g; - register struct parse *p = &pa; - register int i; - register size_t len; + struct re_guts *g; + struct parse *p = &pa; + int i; + size_t len; #ifdef REDEBUG # define GOODFLAGS(f) (f) #else @@ -100,23 +133,27 @@ int cflags; #endif cflags = GOODFLAGS(cflags); +#if !defined(__lint) /* Lint global check knows nobody calls with this combo */ if ((cflags®_EXTENDED) && (cflags®_NOSPEC)) return(REG_INVARG); - if (cflags®_PEND) { + if (cflags & REG_PEND) { + /*@ignore@*/ if (preg->re_endp < pattern) return(REG_INVARG); - len = preg->re_endp - pattern; + len = (size_t)(preg->re_endp - pattern); + /*@end@*/ } else +#endif len = strlen((char *)pattern); /* do the mallocs early so failure handling is easy */ - g = (struct re_guts *)malloc(sizeof(struct re_guts) + - (NC-1)*sizeof(cat_t)); + g = (struct re_guts *)malloc(SIZEOF(struct re_guts) + + (NC-1)*SIZEOF(cat_t)); if (g == NULL) return(REG_ESPACE); - p->ssize = len/(size_t)2*(size_t)3 + (size_t)1; /* ugh */ - p->strip = (sop *)malloc(p->ssize * sizeof(sop)); + p->ssize = (sopno)(((len / (size_t)2) * (size_t)3) + (size_t)1); + p->strip = (sop *)malloc((size_t)p->ssize * SIZEOF(sop)); p->slen = 0; if (p->strip == NULL) { free((char *)g); @@ -146,15 +183,15 @@ 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)); + (void) memset((char *)g->catspace, 0, NC*SIZEOF(cat_t)); g->backrefs = 0; /* do it */ EMIT(OEND, 0); - g->firststate = THERE(); - if (cflags®_EXTENDED) + g->firststate = (sopno)THERE(); + if (cflags & REG_EXTENDED) p_ere(p, OUT); - else if (cflags®_NOSPEC) + else if (cflags & REG_NOSPEC) p_str(p); else p_bre(p, OUT, OUT); @@ -167,9 +204,11 @@ int cflags; findmust(p, g); g->nplus = pluscount(p, g); g->magic = MAGIC2; + /*@ignore@*/ preg->re_nsub = g->nsub; preg->re_g = g; preg->re_magic = MAGIC1; + /*@end@*/ #ifndef REDEBUG /* not debugging, so can't rely on the assert() in regexec() */ if (g->iflags&BAD) @@ -184,25 +223,25 @@ 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(p, stop) -register struct parse *p; -int stop; /* character this ERE should end at */ +p_ere( + struct parse * p, + 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? */ + char c; + sopno prevback = 0; + sopno prevfwd = 0; + sopno conc; + int first = 1; /* is this the first alternative? */ for (;;) { /* do a bunch of concatenated expressions */ conc = HERE(); while (MORE() && (c = PEEK()) != '|' && c != stop) p_ere_exp(p); - REQUIRE(HERE() != conc, REG_EMPTY); /* require nonempty */ + (void)REQUIRE(HERE() != conc, REG_EMPTY); /* require nonempty */ if (!EAT('|')) break; /* NOTE BREAK OUT */ @@ -230,17 +269,17 @@ int stop; /* character this ERE should end at */ /* - 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(p) -register struct parse *p; +p_ere_exp( + struct parse * p) { - register char c; - register sopno pos; - register int count; - register int count2; - register sopno subno; + char c; + sopno pos; + int count; + int count2; + sopno subno; int wascaret = 0; assert(MORE()); /* caller should have ensured this */ @@ -249,7 +288,7 @@ register struct parse *p; pos = HERE(); switch (c) { case '(': - REQUIRE(MORE(), REG_EPAREN); + (void)REQUIRE(MORE(), REG_EPAREN); p->g->nsub++; subno = p->g->nsub; if (subno < NPAREN) @@ -262,7 +301,7 @@ register struct parse *p; assert(p->pend[subno] != 0); } EMIT(ORPAREN, subno); - MUSTEAT(')', REG_EPAREN); + (void)MUSTEAT(')', REG_EPAREN); break; #ifndef POSIX_MISTAKE case ')': /* happens only if no current unmatched ( */ @@ -305,12 +344,12 @@ register struct parse *p; p_bracket(p); break; case '\\': - REQUIRE(MORE(), REG_EESCAPE); + (void)REQUIRE(MORE(), REG_EESCAPE); c = GETNEXT(); ordinary(p, c); break; case '{': /* okay as ordinary except if digit follows */ - REQUIRE(!MORE() || !isdigit(PEEK()), REG_BADRPT); + (void)REQUIRE(!MORE() || !isdigit(PEEK()), REG_BADRPT); /* FALLTHROUGH */ default: ordinary(p, c); @@ -326,7 +365,7 @@ register struct parse *p; return; /* no repetition, we're done */ NEXT(); - REQUIRE(!wascaret, REG_BADRPT); + (void)REQUIRE(!wascaret, REG_BADRPT); switch (c) { case '*': /* implemented as +? */ /* this case does not require the (y|) trick, noKLUDGE */ @@ -353,16 +392,16 @@ register struct parse *p; if (EAT(',')) { if (isdigit(PEEK())) { count2 = p_count(p); - REQUIRE(count <= count2, REG_BADBR); + (void)REQUIRE(count <= count2, REG_BADBR); } else /* single number with comma */ - count2 = INFINITY; + count2 = (int)REINFINITY; } else /* just a single number */ count2 = count; repeat(p, pos, count, count2); if (!EAT('}')) { /* error heuristics */ while (MORE() && PEEK() != '}') NEXT(); - REQUIRE(MORE(), REG_EBRACE); + (void)REQUIRE(MORE(), REG_EBRACE); SETERROR(REG_BADBR); } break; @@ -379,21 +418,21 @@ register 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(p) -register struct parse *p; +p_str( + struct parse * p) { - REQUIRE(MORE(), REG_EMPTY); + (void)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, register 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 @@ -403,14 +442,14 @@ register struct parse *p; * The amount of lookahead needed to avoid this kludge is excessive. */ static void -p_bre(p, end1, end2) -register struct parse *p; -register int end1; /* first terminating character */ -register int end2; /* second terminating character */ +p_bre( + struct parse * p, + int end1, /* first terminating character */ + int end2) /* second terminating character */ { - register sopno start = HERE(); - register int first = 1; /* first subexpression? */ - register int wasdollar = 0; + sopno start = HERE(); + int first = 1; /* first subexpression? */ + int wasdollar = 0; if (EAT('^')) { EMIT(OBOL, 0); @@ -428,24 +467,24 @@ register int end2; /* second terminating character */ p->g->neol++; } - REQUIRE(HERE() != start, REG_EMPTY); /* require nonempty */ + (void)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(p, starordinary) -register struct parse *p; -int starordinary; /* is a leading * an ordinary character? */ +p_simp_re( + struct parse * p, + 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; + int c; + int count; + int count2; + sopno pos; + int i; + sopno subno; # define BACKSL (1<pend[subno] != 0); } EMIT(ORPAREN, subno); - REQUIRE(EATTWO('\\', ')'), REG_EPAREN); + (void)REQUIRE(EATTWO('\\', ')'), REG_EPAREN); break; case BACKSL|')': /* should not get here -- must be user */ case BACKSL|'}': @@ -501,19 +540,19 @@ int starordinary; /* is a leading * an ordinary character? */ i = (c&~BACKSL) - '0'; assert(i < NPAREN); if (p->pend[i] != 0) { - assert(i <= p->g->nsub); + assert(i <= (int)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); - (void) dupl(p, p->pbegin[i]+1, p->pend[i]); + (void)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); + (void)REQUIRE(starordinary, REG_BADRPT); /* FALLTHROUGH */ default: ordinary(p, c &~ BACKSL); @@ -531,16 +570,16 @@ int starordinary; /* is a leading * an ordinary character? */ if (EAT(',')) { if (MORE() && isdigit(PEEK())) { count2 = p_count(p); - REQUIRE(count <= count2, REG_BADBR); + (void)REQUIRE(count <= count2, REG_BADBR); } else /* single number with comma */ - count2 = INFINITY; + count2 = REINFINITY; } else /* just a single number */ count2 = count; repeat(p, pos, count, count2); if (!EATTWO('\\', '}')) { /* error heuristics */ while (MORE() && !SEETWO('\\', '}')) NEXT(); - REQUIRE(MORE(), REG_EBRACE); + (void)REQUIRE(MORE(), REG_EBRACE); SETERROR(REG_BADBR); } } else if (c == (unsigned char)'$') /* $ (but not \$) ends it */ @@ -551,37 +590,37 @@ int starordinary; /* is a leading * an ordinary character? */ /* - 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(p) -register struct parse *p; +p_count( + struct parse * p) { - register int count = 0; - register int ndigits = 0; + int count = 0; + int ndigits = 0; while (MORE() && isdigit(PEEK()) && count <= DUPMAX) { count = count*10 + (GETNEXT() - '0'); ndigits++; } - REQUIRE(ndigits > 0 && count <= DUPMAX, REG_BADBR); + (void)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. */ static void -p_bracket(p) -register struct parse *p; +p_bracket( + struct parse * p) { - register cset *cs = allocset(p); - register int invert = 0; + cset *cs = allocset(p); + int invert = 0; /* Dept of Truly Sickening Special-Case Kludges */ if (p->next + 5 < p->end && strncmp(p->next, "[:<:]]", 6) == 0) { @@ -605,14 +644,14 @@ register struct parse *p; p_b_term(p, cs); if (EAT('-')) CHadd(cs, '-'); - MUSTEAT(']', REG_EBRACK); + (void)MUSTEAT(']', REG_EBRACK); if (p->error != 0) /* don't mess things up further */ return; if (p->g->cflags®_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)) { @@ -624,7 +663,7 @@ register 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)) @@ -648,26 +687,26 @@ register 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, register cset *cs); */ static void -p_b_term(p, cs) -register struct parse *p; -register cset *cs; +p_b_term( + struct parse * p, + cset * cs) { - register char c; - register char start, finish; - register int i; + char c; + char start, finish; + int i; /* classify what we've got */ switch ((MORE()) ? PEEK() : '\0') { case '[': - c = (MORE2()) ? PEEK2() : '\0'; + c = (char)((MORE2()) ? PEEK2() : '\0'); break; case '-': SETERROR(REG_ERANGE); return; /* NOTE RETURN */ - break; + default: c = '\0'; break; @@ -676,36 +715,36 @@ register cset *cs; switch (c) { case ':': /* character class */ NEXT2(); - REQUIRE(MORE(), REG_EBRACK); + (void)REQUIRE(MORE(), REG_EBRACK); c = PEEK(); - REQUIRE(c != '-' && c != ']', REG_ECTYPE); + (void)REQUIRE(c != '-' && c != ']', REG_ECTYPE); p_b_cclass(p, cs); - REQUIRE(MORE(), REG_EBRACK); - REQUIRE(EATTWO(':', ']'), REG_ECTYPE); + (void)REQUIRE(MORE(), REG_EBRACK); + (void)REQUIRE(EATTWO(':', ']'), REG_ECTYPE); break; case '=': /* equivalence class */ NEXT2(); - REQUIRE(MORE(), REG_EBRACK); + (void)REQUIRE(MORE(), REG_EBRACK); c = PEEK(); - REQUIRE(c != '-' && c != ']', REG_ECOLLATE); + (void)REQUIRE(c != '-' && c != ']', REG_ECOLLATE); p_b_eclass(p, cs); - REQUIRE(MORE(), REG_EBRACK); - REQUIRE(EATTWO('=', ']'), REG_ECOLLATE); + (void)REQUIRE(MORE(), REG_EBRACK); + (void)REQUIRE(EATTWO('=', ']'), REG_ECOLLATE); break; default: /* symbol, ordinary character, or range */ /* xxx revision needed for multichar stuff */ - start = p_b_symbol(p); + start = (char)p_b_symbol(p); if (SEE('-') && MORE2() && PEEK2() != ']') { /* range */ NEXT(); if (EAT('-')) finish = '-'; else - finish = p_b_symbol(p); + finish = (char)p_b_symbol(p); } else finish = start; /* xxx what about signed chars here... */ - REQUIRE(start <= finish, REG_ERANGE); + (void)REQUIRE(start <= finish, REG_ERANGE); for (i = start; i <= finish; i++) CHadd(cs, i); break; @@ -714,22 +753,22 @@ register 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, register cset *cs); */ static void -p_b_cclass(p, cs) -register struct parse *p; -register cset *cs; +p_b_cclass( + struct parse * p, + cset * cs) { - register char *sp = p->next; - register struct cclass *cp; - register size_t len; - register char *u; - register char c; + char *sp = p->next; + struct cclass *cp; + size_t len; + char *u; + char c; while (MORE() && isalpha(PEEK())) NEXT(); - len = p->next - sp; + len = (size_t)(p->next - sp); for (cp = cclasses; cp->name != NULL; cp++) if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0') break; @@ -748,68 +787,68 @@ register 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, register cset *cs); * * This implementation is incomplete. xxx */ static void -p_b_eclass(p, cs) -register struct parse *p; -register cset *cs; +p_b_eclass( + struct parse * p, + cset * cs) { - register char c; + char c; - c = p_b_coll_elem(p, '='); + c = (char)p_b_coll_elem(p, '='); CHadd(cs, c); } /* - 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(p) -register struct parse *p; +p_b_symbol( + struct parse * p) { - register char value; + char value; - REQUIRE(MORE(), REG_EBRACK); + (void)REQUIRE(MORE(), REG_EBRACK); if (!EATTWO('[', '.')) return(GETNEXT()); /* collating symbol */ - value = p_b_coll_elem(p, '.'); - REQUIRE(EATTWO('.', ']'), REG_ECOLLATE); + value = (char)p_b_coll_elem(p, '.'); + (void)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(p, endc) -register struct parse *p; -int endc; /* name ended by endc,']' */ +p_b_coll_elem( + struct parse * p, + int endc) /* name ended by endc,']' */ { - register char *sp = p->next; - register struct cname *cp; - register int len; + char *sp = p->next; + struct cname *cp; + size_t len; while (MORE() && !SEETWO(endc, ']')) NEXT(); if (!MORE()) { SETERROR(REG_EBRACK); - return(0); + return((char)0); } - len = p->next - sp; + len = (size_t)(p->next - sp); for (cp = cnames; cp->name != NULL; cp++) if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0') return(cp->code); /* known name */ if (len == 1) return(*sp); /* single character */ SETERROR(REG_ECOLLATE); /* neither */ - return(0); + return((char)0); } /* @@ -817,8 +856,8 @@ int endc; /* name ended by endc,']' */ == static char othercase(int ch); */ static char /* if no counterpart, return ch */ -othercase(ch) -int ch; +othercase( + int ch) { assert(isalpha(ch)); if (isupper(ch)) @@ -831,23 +870,23 @@ 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... */ static void -bothcases(p, ch) -register struct parse *p; -int ch; +bothcases( + struct parse * p, + int ch) { - register char *oldnext = p->next; - register char *oldend = p->end; - char bracket[3]; + char *oldnext = p->next; + char *oldend = p->end; + static char bracket[3]; assert(othercase(ch) != ch); /* p_bracket() would recurse */ p->next = bracket; p->end = bracket+2; - bracket[0] = ch; + bracket[0] = (char)ch; bracket[1] = ']'; bracket[2] = '\0'; p_bracket(p); @@ -858,37 +897,37 @@ int ch; /* - ordinary - emit an ordinary character - == static void ordinary(register struct parse *p, register int ch); + == static void ordinary(struct parse *p, register int ch); */ static void -ordinary(p, ch) -register struct parse *p; -register int ch; +ordinary( + struct parse * p, + int ch) { - register cat_t *cap = p->g->categories; + cat_t *cap = p->g->categories; if ((p->g->cflags®_ICASE) && isalpha(ch) && othercase(ch) != ch) bothcases(p, ch); else { EMIT(OCHAR, (unsigned char)ch); if (cap[ch] == 0) - cap[ch] = p->g->ncategories++; + cap[ch] = (cat_t)(p->g->ncategories++); } } /* - 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... */ static void -nonnewline(p) -register struct parse *p; +nonnewline( + struct parse * p) { - register char *oldnext = p->next; - register char *oldend = p->end; - char bracket[4]; + char *oldnext = p->next; + char *oldend = p->end; + static char bracket[4]; p->next = bracket; p->end = bracket+3; @@ -904,21 +943,21 @@ register 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(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 INFINITY) */ +repeat( + 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 REINFINITY) */ { - register sopno finish = HERE(); + 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; +# define MAP(n) (((n) <= 1) ? (n) : ((n) == REINFINITY) ? INF : N) + sopno copy; if (p->error != 0) /* head off possible runaway recursion */ return; @@ -976,12 +1015,12 @@ int to; /* to this number of times (maybe INFINITY) */ /* - 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(p, e) -register struct parse *p; -int e; +seterr( + struct parse * p, + int e) { if (p->error == 0) /* keep earliest error condition */ p->error = e; @@ -992,18 +1031,18 @@ 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(p) -register struct parse *p; +allocset( + struct parse * p) { - register int no = p->g->ncsets++; - register size_t nc; - register size_t nbytes; - register cset *cs; - register size_t css = (size_t)p->g->csetsize; - register int i; + int no = p->g->ncsets++; + int nc; + size_t nbytes; + cset *cs; + size_t css = (size_t)p->g->csetsize; + int i; if (no >= p->ncsalloc) { /* need another column of space */ p->ncsalloc += CHAR_BIT; @@ -1011,18 +1050,19 @@ register struct parse *p; assert(nc % CHAR_BIT == 0); nbytes = nc / CHAR_BIT * css; if (p->g->sets == NULL) - p->g->sets = (cset *)malloc(nc * sizeof(cset)); + p->g->sets = (cset *)malloc(nc * SIZEOF(cset)); else p->g->sets = (cset *)realloc((char *)p->g->sets, - nc * sizeof(cset)); + (size_t)nc * SIZEOF(cset)); if (p->g->setbits == NULL) p->g->setbits = (uch *)malloc(nbytes); else { p->g->setbits = (uch *)realloc((char *)p->g->setbits, nbytes); /* xxx this isn't right if setbits is now NULL */ - for (i = 0; i < no; i++) - p->g->sets[i].ptr = p->g->setbits + css*(i/CHAR_BIT); + if (p->g->sets && p->g->setbits) + for (i = 0; i < no; i++) + 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), @@ -1037,7 +1077,7 @@ register struct parse *p; assert(p->g->sets != NULL); /* xxx */ cs = &p->g->sets[no]; cs->ptr = p->g->setbits + css*((no)/CHAR_BIT); - cs->mask = 1 << ((no) % CHAR_BIT); + cs->mask = (uch)(1 << ((no) % CHAR_BIT)); cs->hash = 0; cs->smultis = 0; cs->multis = NULL; @@ -1047,16 +1087,16 @@ register 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, register cset *cs); */ static void -freeset(p, cs) -register struct parse *p; -register cset *cs; +freeset( + struct parse * p, + cset * cs) { - register int i; - register cset *top = &p->g->sets[p->g->ncsets]; - register size_t css = (size_t)p->g->csetsize; + int i; + cset *top = &p->g->sets[p->g->ncsets]; + int css = p->g->csetsize; for (i = 0; i < css; i++) CHsub(cs, i); @@ -1066,7 +1106,7 @@ register 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, register 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 @@ -1075,15 +1115,15 @@ register cset *cs; * the same value! */ static int /* set number */ -freezeset(p, cs) -register struct parse *p; -register cset *cs; +freezeset( + struct parse * p, + cset * cs) { - 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; + uch h = cs->hash; + int i; + cset *top = &p->g->sets[p->g->ncsets]; + cset *cs2; + int css = p->g->csetsize; /* look for an earlier one which is the same */ for (cs2 = &p->g->sets[0]; cs2 < top; cs2++) @@ -1106,15 +1146,15 @@ register 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, register cset *cs); */ static int /* character; there is no "none" value */ -firstch(p, cs) -register struct parse *p; -register cset *cs; +firstch( + struct parse * p, + cset * cs) { - register int i; - register size_t css = (size_t)p->g->csetsize; + int i; + int css = p->g->csetsize; for (i = 0; i < css; i++) if (CHIN(cs, i)) @@ -1125,16 +1165,16 @@ register 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, register cset *cs); */ static int -nch(p, cs) -register struct parse *p; -register cset *cs; +nch( + struct parse * p, + cset * cs) { - register int i; - register size_t css = (size_t)p->g->csetsize; - register int n = 0; + int i; + int css = p->g->csetsize; + int n = 0; for (i = 0; i < css; i++) if (CHIN(cs, i)) @@ -1144,134 +1184,79 @@ register 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, register cset *cs, \ + == char *cp); */ static void -mcadd(p, cs, cp) -register struct parse *p; -register cset *cs; -register char *cp; +mcadd( + struct parse * p, + cset * cs, + char * cp) { - register size_t oldend = cs->smultis; + size_t oldend = cs->smultis; cs->smultis += strlen(cp) + 1; if (cs->multis == NULL) cs->multis = malloc(cs->smultis); else - cs->multis = realloc(cs->multis, cs->smultis); + cs->multis = realloc(cs->multis, (size_t)cs->smultis); if (cs->multis == NULL) { SETERROR(REG_ESPACE); return; } - (void) strcpy(cs->multis + oldend - 1, cp); + (void) strncpy(cs->multis + oldend - 1, cp, cs->smultis - (oldend - 1)); cs->multis[cs->smultis - 1] = '\0'; } -#if 0 -/* - * - mcsub - subtract a collating element from a cset - * == static void mcsub(register cset *cs, register char *cp); - */ -static void -mcsub(cs, cp) -register cset *cs; -register char *cp; -{ - register char *fp = mcfind(cs, cp); - register size_t len = strlen(fp); - - assert(fp != NULL); - (void) memmove(fp, fp + len + 1, - cs->smultis - (fp + len + 1 - cs->multis)); - cs->smultis -= len; - - if (cs->smultis == 0) { - free(cs->multis); - cs->multis = NULL; - return; - } - - cs->multis = realloc(cs->multis, cs->smultis); - assert(cs->multis != NULL); -} - -/* - * - mcin - is a collating element in a cset? - * == static int mcin(register cset *cs, register char *cp); - */ -static int -mcin(cs, cp) -register cset *cs; -register char *cp; -{ - return(mcfind(cs, cp) != NULL); -} - -/* - * - mcfind - find a collating element in a cset - * == static char *mcfind(register cset *cs, register char *cp); - */ -static char * -mcfind(cs, cp) -register cset *cs; -register char *cp; -{ - register char *p; - - if (cs->multis == NULL) - return(NULL); - for (p = cs->multis; *p != '\0'; p += strlen(p) + 1) - if (strcmp(cp, p) == 0) - return(p); - return(NULL); -} -#endif /* 0 */ /* - 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, register cset *cs); * * This would have to know the set of possibilities. Implementation * is deferred. */ static void -mcinvert(p, cs) -register struct parse *p; -register cset *cs; +mcinvert( + struct parse * p, + cset * cs) { + (void)p; /* Quiet unused parameter warning */ + (void)cs; /* Quiet unused parameter warning */ 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, register cset *cs); * * This would have to know the set of possibilities. Implementation * is deferred. */ static void -mccase(p, cs) -register struct parse *p; -register cset *cs; +mccase( + struct parse * p, + cset * cs) { + (void)p; /* Quiet unused parameter warning */ + (void)cs; /* Quiet unused parameter warning */ 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(g, c) -register struct re_guts *g; -int c; +isinsets( + struct re_guts * g, + int c) { - register uch *col; - register int i; - register int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT; - register unsigned uc = (unsigned char)c; + uch *col; + int i; + int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT; + unsigned uc = (unsigned char)c; for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize) if (col[uc] != 0) @@ -1281,19 +1266,19 @@ 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(g, c1, c2) -register struct re_guts *g; -int c1; -int c2; +samesets( + struct re_guts * g, + int c1, + int c2) { - 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; + uch *col; + int i; + int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT; + unsigned uc1 = (unsigned char)c1; + unsigned uc2 = (unsigned char)c2; for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize) if (col[uc1] != col[uc2]) @@ -1303,17 +1288,17 @@ 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(p, g) -struct parse *p; -register struct re_guts *g; +categorize( + struct parse * p, + struct re_guts * g) { - register cat_t *cats = g->categories; - register int c; - register int c2; - register cat_t cat; + cat_t *cats = g->categories; + int c; + int c2; + cat_t cat; /* avoid making error situations worse */ if (p->error != 0) @@ -1321,7 +1306,7 @@ register struct re_guts *g; for (c = CHAR_MIN; c <= CHAR_MAX; c++) if (cats[c] == 0 && isinsets(g, c)) { - cat = g->ncategories++; + cat = (cat_t)g->ncategories++; cats[c] = cat; for (c2 = c+1; c2 <= CHAR_MAX; c2++) if (cats[c2] == 0 && samesets(g, c, c2)) @@ -1331,48 +1316,48 @@ 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 dupl(struct parse *p, sopno start, sopno finish); */ static sopno /* start of duplicate */ -dupl(p, start, finish) -register struct parse *p; -sopno start; /* from here */ -sopno finish; /* to this less one */ +dupl( + struct parse * p, + sopno start, /* from here */ + sopno finish) /* to this less one */ { - register sopno ret = HERE(); - register sopno len = finish - start; + sopno ret = HERE(); + size_t len = (size_t)(finish - start); assert(finish >= start); if (len == 0) return(ret); enlarge(p, p->ssize + len); /* this many unexpected additions */ - assert(p->ssize >= p->slen + len); + assert(p->ssize >= (p->slen + len)); (void) memcpy((char *)(p->strip + p->slen), - (char *)(p->strip + start), (size_t)len*sizeof(sop)); + (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 * some changes to the data structures. Maybe later. */ static void -doemit(p, op, opnd) -register struct parse *p; -sop op; -size_t opnd; +doemit( + struct parse * p, + sop op, + size_t opnd) { /* avoid making error situations worse */ if (p->error != 0) return; /* deal with oversize operands ("can't happen", more or less) */ - assert(opnd < 1<slen >= p->ssize) @@ -1385,18 +1370,18 @@ 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(p, op, opnd, pos) -register struct parse *p; -sop op; -size_t opnd; -sopno pos; +doinsert( + struct parse * p, + sop op, + size_t opnd, + sopno pos) { - register sopno sn; - register sop s; - register int i; + sopno sn; + sop s; + int i; /* avoid making error situations worse */ if (p->error != 0) @@ -1419,19 +1404,19 @@ sopno pos; } memmove((char *)&p->strip[pos+1], (char *)&p->strip[pos], - (HERE()-pos-1)*sizeof(sop)); + (HERE() - (size_t)pos - 1) * SIZEOF(sop)); p->strip[pos] = s; } /* - 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(p, pos, value) -register struct parse *p; -register sopno pos; -sop value; +dofwd( + struct parse * p, + sopno pos, + sop value) { /* avoid making error situations worse */ if (p->error != 0) @@ -1439,42 +1424,43 @@ sop value; assert(value < 1<strip[pos] = OP(p->strip[pos]) | 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(p, size) -register struct parse *p; -register sopno size; +enlarge( + struct parse * p, + sopno size) { - register sop *sp; + sop *sp; - if (p->ssize >= size) + assert(size <= (sopno)SSIZE_MAX); + if (p->ssize >= (size_t)size) return; - sp = (sop *)realloc(p->strip, size*sizeof(sop)); + sp = (sop *)realloc(p->strip, (size_t)size * SIZEOF(sop)); if (sp == NULL) { SETERROR(REG_ESPACE); return; } p->strip = sp; - p->ssize = size; + p->ssize = (size_t)size; } /* - stripsnug - compact the strip - == static void stripsnug(register struct parse *p, register struct re_guts *g); + == static void stripsnug(struct parse *p, register struct re_guts *g); */ static void -stripsnug(p, g) -register struct parse *p; -register struct re_guts *g; +stripsnug( + /*@keep@*/ struct parse * p, + /*@keep@*/ struct re_guts *g) { g->nstates = p->slen; - g->strip = (sop *)realloc((char *)p->strip, p->slen * sizeof(sop)); + g->strip = (sop *)realloc((char *)p->strip, + (size_t)p->slen * SIZEOF(sop)); if (g->strip == NULL) { SETERROR(REG_ESPACE); g->strip = p->strip; @@ -1483,7 +1469,7 @@ register 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, register 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 @@ -1492,17 +1478,17 @@ register struct re_guts *g; * Note that must and mlen got initialized during setup. */ static void -findmust(p, g) -struct parse *p; -register struct re_guts *g; +findmust( + struct parse * p, + struct re_guts * g) { - register sop *scan; + sop *scan; sop *start; - register sop *newstart = NULL; - register sopno newlen; - register sop s; - register char *cp; - register sopno i; + sop *newstart = NULL; + sopno newlen; + sop s; + char *cp; + sopno i; /* avoid making error situations worse */ if (p->error != 0) @@ -1559,8 +1545,9 @@ register struct re_guts *g; cp = g->must; scan = start; for (i = g->mlen; i > 0; i--) { - while (OP(s = *scan++) != OCHAR) - continue; + s = *scan++; + while (OP(s) != OCHAR) + s = *scan++; assert(cp < g->must + g->mlen); *cp++ = (char)OPND(s); } @@ -1570,17 +1557,17 @@ register 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, register struct re_guts *g); */ static sopno /* nesting depth */ -pluscount(p, g) -struct parse *p; -register struct re_guts *g; +pluscount( + struct parse * p, + struct re_guts * g) { - register sop *scan; - register sop s; - register sopno plusnest = 0; - register sopno maxnest = 0; + sop *scan; + sop s; + sopno plusnest = 0; + sopno maxnest = 0; if (p->error != 0) return(0); /* there may not be an OEND */