mirror of
https://github.com/3proxy/3proxy.git
synced 2025-04-11 15:03:11 +08:00
8079c71b8a
The MySQL server uses Henry Spencer's library for regular expressions to support the REGEXP/RLIKE string operator. This changeset adapts a recent fix from the upstream for better 32-bit compatiblity. (Note that we cannot simply use the current upstream version as a drop-in replacement for the version used by the server as the latter has been extended to understand MySQL charsets etc.)
3835 lines
96 KiB
C
3835 lines
96 KiB
C
#include <sys/types.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <limits.h>
|
|
#include <ctype.h>
|
|
#include <assert.h>
|
|
|
|
#include "regex.h"
|
|
|
|
/* utility definitions */
|
|
#ifdef _POSIX2_RE_DUP_MAX
|
|
#define DUPMAX _POSIX2_RE_DUP_MAX
|
|
#else
|
|
#define DUPMAX 255
|
|
#endif
|
|
#define INFINITY (DUPMAX + 1)
|
|
#define NC (CHAR_MAX - CHAR_MIN + 1)
|
|
typedef unsigned char uch;
|
|
|
|
/* for old systems with bcopy() but no memmove() */
|
|
#ifdef USEBCOPY
|
|
#define memmove(d, s, c) bcopy(s, d, c)
|
|
#endif
|
|
|
|
#define MAGIC1 ((('r'^0200)<<8) | 'e')
|
|
|
|
/*
|
|
* The internal representation is a *strip*, a sequence of
|
|
* operators ending with an endmarker. (Some terminology etc. is a
|
|
* historical relic of earlier versions which used multiple strips.)
|
|
* Certain oddities in the representation are there to permit running
|
|
* the machinery backwards; in particular, any deviation from sequential
|
|
* flow must be marked at both its source and its destination. Some
|
|
* fine points:
|
|
*
|
|
* - OPLUS_ and O_PLUS are *inside* the loop they create.
|
|
* - OQUEST_ and O_QUEST are *outside* the bypass they create.
|
|
* - OCH_ and O_CH are *outside* the multi-way branch they create, while
|
|
* OOR1 and OOR2 are respectively the end and the beginning of one of
|
|
* the branches. Note that there is an implicit OOR2 following OCH_
|
|
* and an implicit OOR1 preceding O_CH.
|
|
*
|
|
* In state representations, an operator's bit is on to signify a state
|
|
* immediately *preceding* "execution" of that operator.
|
|
*/
|
|
typedef long sop; /* strip operator */
|
|
typedef long sopno;
|
|
#define OPRMASK 0x7c000000
|
|
#define OPDMASK 0x03ffffff
|
|
#define OPSHIFT (26)
|
|
#define OP(n) ((n)&OPRMASK)
|
|
#define OPND(n) ((n)&OPDMASK)
|
|
#define SOP(op, opnd) ((op)|(opnd))
|
|
/* operators meaning operand */
|
|
/* (back, fwd are offsets) */
|
|
#define OEND (1<<OPSHIFT) /* endmarker - */
|
|
#define OCHAR (2<<OPSHIFT) /* character unsigned char */
|
|
#define OBOL (3<<OPSHIFT) /* left anchor - */
|
|
#define OEOL (4<<OPSHIFT) /* right anchor - */
|
|
#define OANY (5<<OPSHIFT) /* . - */
|
|
#define OANYOF (6<<OPSHIFT) /* [...] set number */
|
|
#define OBACK_ (7<<OPSHIFT) /* begin \d paren number */
|
|
#define O_BACK (8<<OPSHIFT) /* end \d paren number */
|
|
#define OPLUS_ (9<<OPSHIFT) /* + prefix fwd to suffix */
|
|
#define O_PLUS (10<<OPSHIFT) /* + suffix back to prefix */
|
|
#define OQUEST_ (11<<OPSHIFT) /* ? prefix fwd to suffix */
|
|
#define O_QUEST (12<<OPSHIFT) /* ? suffix back to prefix */
|
|
#define OLPAREN (13<<OPSHIFT) /* ( fwd to ) */
|
|
#define ORPAREN (14<<OPSHIFT) /* ) back to ( */
|
|
#define OCH_ (15<<OPSHIFT) /* begin choice fwd to OOR2 */
|
|
#define OOR1 (16<<OPSHIFT) /* | pt. 1 back to OOR1 or OCH_ */
|
|
#define OOR2 (17<<OPSHIFT) /* | pt. 2 fwd to OOR2 or O_CH */
|
|
#define O_CH (18<<OPSHIFT) /* end choice back to OOR1 */
|
|
#define OBOW (19<<OPSHIFT) /* begin word - */
|
|
#define OEOW (20<<OPSHIFT) /* end word - */
|
|
|
|
/*
|
|
* Structure for [] character-set representation. Character sets are
|
|
* done as bit vectors, grouped 8 to a byte vector for compactness.
|
|
* The individual set therefore has both a pointer to the byte vector
|
|
* and a mask to pick out the relevant bit of each byte. A hash code
|
|
* simplifies testing whether two sets could be identical.
|
|
*
|
|
* This will get trickier for multicharacter collating elements. As
|
|
* preliminary hooks for dealing with such things, we also carry along
|
|
* a string of multi-character elements, and decide the size of the
|
|
* vectors at run time.
|
|
*/
|
|
typedef struct {
|
|
uch *ptr; /* -> uch [csetsize] */
|
|
uch mask; /* bit within array */
|
|
uch hash; /* hash code */
|
|
size_t smultis;
|
|
char *multis; /* -> char[smulti] ab\0cd\0ef\0\0 */
|
|
} cset;
|
|
/* note that CHadd and CHsub are unsafe, and CHIN doesn't yield 0/1 */
|
|
#define CHadd(cs, c) ((cs)->ptr[(uch)(c)] |= (cs)->mask, (cs)->hash += (c))
|
|
#define CHsub(cs, c) ((cs)->ptr[(uch)(c)] &= ~(cs)->mask, (cs)->hash -= (c))
|
|
#define CHIN(cs, c) ((cs)->ptr[(uch)(c)] & (cs)->mask)
|
|
#define MCadd(p, cs, cp) mcadd(p, cs, cp) /* regcomp() internal fns */
|
|
|
|
/* stuff for character categories */
|
|
typedef unsigned char cat_t;
|
|
|
|
/*
|
|
* main compiled-expression structure
|
|
*/
|
|
struct re_guts {
|
|
int magic;
|
|
# define MAGIC2 ((('R'^0200)<<8)|'E')
|
|
sop *strip; /* malloced area for strip */
|
|
int csetsize; /* number of bits in a cset vector */
|
|
int ncsets; /* number of csets in use */
|
|
cset *sets; /* -> cset [ncsets] */
|
|
uch *setbits; /* -> uch[csetsize][ncsets/CHAR_BIT] */
|
|
int cflags; /* copy of regcomp() cflags argument */
|
|
sopno nstates; /* = number of sops */
|
|
sopno firststate; /* the initial OEND (normally 0) */
|
|
sopno laststate; /* the final OEND */
|
|
int iflags; /* internal flags */
|
|
# define USEBOL 01 /* used ^ */
|
|
# define USEEOL 02 /* used $ */
|
|
# define BAD 04 /* something wrong */
|
|
int nbol; /* number of ^ used */
|
|
int neol; /* number of $ used */
|
|
int ncategories; /* how many character categories */
|
|
cat_t *categories; /* ->catspace[-CHAR_MIN] */
|
|
char *must; /* match must contain this string */
|
|
int mlen; /* length of must */
|
|
size_t nsub; /* copy of re_nsub */
|
|
int backrefs; /* does it use back references? */
|
|
sopno nplus; /* how deep does it nest +s? */
|
|
/* catspace must be last */
|
|
cat_t catspace[1]; /* actually [NC] */
|
|
};
|
|
|
|
/* misc utilities */
|
|
#define OUT (CHAR_MAX+1) /* a non-character value */
|
|
#define ISWORD(c) (isalnum(c) || (c) == '_')
|
|
|
|
|
|
/* character-class table */
|
|
static struct cclass {
|
|
char *name;
|
|
char *chars;
|
|
char *multis;
|
|
} cclasses[] = {
|
|
{"alnum","ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",""},
|
|
{"alpha", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ""},
|
|
{"blank"," \t", ""},
|
|
{"cntrl","\007\b\t\n\v\f\r\1\2\3\4\5\6\16\17\20\21\22\23\24\25\26\27\30\31\32\33\34\35\36\37\177",""},
|
|
{"digit","0123456789",""},
|
|
{"graph","ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",""},
|
|
{"lower","abcdefghijklmnopqrstuvwxyz",""},
|
|
{"print","ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ",""},
|
|
{"punct","!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",""},
|
|
{"space","\t\n\v\f\r ", ""},
|
|
{"upper","ABCDEFGHIJKLMNOPQRSTUVWXYZ",""},
|
|
{"xdigit","0123456789ABCDEFabcdef",""},
|
|
{NULL,NULL,""}
|
|
};
|
|
|
|
/* character-name table */
|
|
static struct cname {
|
|
char *name;
|
|
char code;
|
|
} cnames[] = {
|
|
{"NUL", '\0'},
|
|
{"SOH", '\001'},
|
|
{"STX", '\002'},
|
|
{"ETX", '\003'},
|
|
{"EOT", '\004'},
|
|
{"ENQ", '\005'},
|
|
{"ACK", '\006'},
|
|
{"BEL", '\007'},
|
|
{"alert", '\007'},
|
|
{"BS", '\010'},
|
|
{"backspace", '\b'},
|
|
{"HT", '\011'},
|
|
{"tab", '\t'},
|
|
{"LF", '\012'},
|
|
{"newline", '\n'},
|
|
{"VT", '\013'},
|
|
{"vertical-tab", '\v'},
|
|
{"FF", '\014'},
|
|
{"form-feed", '\f'},
|
|
{"CR", '\015'},
|
|
{"carriage-return", '\r'},
|
|
{"SO", '\016'},
|
|
{"SI", '\017'},
|
|
{"DLE", '\020'},
|
|
{"DC1", '\021'},
|
|
{"DC2", '\022'},
|
|
{"DC3", '\023'},
|
|
{"DC4", '\024'},
|
|
{"NAK", '\025'},
|
|
{"SYN", '\026'},
|
|
{"ETB", '\027'},
|
|
{"CAN", '\030'},
|
|
{"EM", '\031'},
|
|
{"SUB", '\032'},
|
|
{"ESC", '\033'},
|
|
{"IS4", '\034'},
|
|
{"FS", '\034'},
|
|
{"IS3", '\035'},
|
|
{"GS", '\035'},
|
|
{"IS2", '\036'},
|
|
{"RS", '\036'},
|
|
{"IS1", '\037'},
|
|
{"US", '\037'},
|
|
{"space", ' '},
|
|
{"exclamation-mark", '!'},
|
|
{"quotation-mark", '"'},
|
|
{"number-sign", '#'},
|
|
{"dollar-sign", '$'},
|
|
{"percent-sign", '%'},
|
|
{"ampersand", '&'},
|
|
{"apostrophe", '\''},
|
|
{"left-parenthesis", '('},
|
|
{"right-parenthesis", ')'},
|
|
{"asterisk", '*'},
|
|
{"plus-sign", '+'},
|
|
{"comma", ','},
|
|
{"hyphen", '-'},
|
|
{"hyphen-minus", '-'},
|
|
{"period", '.'},
|
|
{"full-stop", '.'},
|
|
{"slash", '/'},
|
|
{"solidus", '/'},
|
|
{"zero", '0'},
|
|
{"one", '1'},
|
|
{"two", '2'},
|
|
{"three", '3'},
|
|
{"four", '4'},
|
|
{"five", '5'},
|
|
{"six", '6'},
|
|
{"seven", '7'},
|
|
{"eight", '8'},
|
|
{"nine", '9'},
|
|
{"colon", ':'},
|
|
{"semicolon", ';'},
|
|
{"less-than-sign", '<'},
|
|
{"equals-sign", '='},
|
|
{"greater-than-sign", '>'},
|
|
{"question-mark", '?'},
|
|
{"commercial-at", '@'},
|
|
{"left-square-bracket", '['},
|
|
{"backslash", '\\'},
|
|
{"reverse-solidus", '\\'},
|
|
{"right-square-bracket", ']'},
|
|
{"circumflex", '^'},
|
|
{"circumflex-accent", '^'},
|
|
{"underscore", '_'},
|
|
{"low-line", '_'},
|
|
{"grave-accent", '`'},
|
|
{"left-brace", '{'},
|
|
{"left-curly-bracket", '{'},
|
|
{"vertical-line", '|'},
|
|
{"right-brace", '}'},
|
|
{"right-curly-bracket", '}'},
|
|
{"tilde", '~'},
|
|
{"DEL", '\177'},
|
|
{NULL, 0}
|
|
};
|
|
|
|
|
|
/*
|
|
* parse structure, passed up and down to avoid global variables and
|
|
* other clumsinesses
|
|
*/
|
|
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 */
|
|
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) */
|
|
};
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
static void p_ere(register struct parse *p, int stop);
|
|
static void p_ere_exp(register struct parse *p);
|
|
static void p_str(register struct parse *p);
|
|
static void p_bre(register struct parse *p, register int end1, register int end2);
|
|
static int p_simp_re(register struct parse *p, int starordinary);
|
|
static int p_count(register struct parse *p);
|
|
static void p_bracket(register struct parse *p);
|
|
static void p_b_term(register struct parse *p, register cset *cs);
|
|
static void p_b_cclass(register struct parse *p, register cset *cs);
|
|
static void p_b_eclass(register struct parse *p, register cset *cs);
|
|
static char p_b_symbol(register struct parse *p);
|
|
static char p_b_coll_elem(register struct parse *p, int endc);
|
|
static char othercase(int ch);
|
|
static void bothcases(register struct parse *p, int ch);
|
|
static void ordinary(register struct parse *p, register int ch);
|
|
static void nonnewline(register struct parse *p);
|
|
static void repeat(register struct parse *p, sopno start, int from, int to);
|
|
static int seterr(register struct parse *p, int e);
|
|
static cset *allocset(register struct parse *p);
|
|
static void freeset(register struct parse *p, register cset *cs);
|
|
static int freezeset(register struct parse *p, register cset *cs);
|
|
static int firstch(register struct parse *p, register cset *cs);
|
|
static int nch(register struct parse *p, register cset *cs);
|
|
static void mcadd(register struct parse *p, register cset *cs, register char *cp);
|
|
static void mcinvert(register struct parse *p, register cset *cs);
|
|
static void mccase(register struct parse *p, register cset *cs);
|
|
static int isinsets(register struct re_guts *g, int c);
|
|
static int samesets(register struct re_guts *g, int c1, int c2);
|
|
static void categorize(struct parse *p, register struct re_guts *g);
|
|
static sopno dupl(register struct parse *p, sopno start, sopno finish);
|
|
static void doemit(register struct parse *p, sop op, size_t opnd);
|
|
static void doinsert(register struct parse *p, sop op, size_t opnd, sopno pos);
|
|
static void dofwd(register struct parse *p, sopno pos, sop value);
|
|
static void enlarge(register struct parse *p, sopno size);
|
|
static void stripsnug(register struct parse *p, register struct re_guts *g);
|
|
static void findmust(register struct parse *p, register struct re_guts *g);
|
|
static sopno pluscount(register struct parse *p, register struct re_guts *g);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
static char nuls[10]; /* place to point scanner in event of error */
|
|
|
|
/*
|
|
* macros for use with parse structure
|
|
* BEWARE: these know that the parse structure is named `p' !!!
|
|
*/
|
|
#define PEEK() (*p->next)
|
|
#define PEEK2() (*(p->next+1))
|
|
#define MORE() (p->next < p->end)
|
|
#define MORE2() (p->next+1 < p->end)
|
|
#define SEE(c) (MORE() && PEEK() == (c))
|
|
#define SEETWO(a, b) (MORE() && MORE2() && PEEK() == (a) && PEEK2() == (b))
|
|
#define EAT(c) ((SEE(c)) ? (NEXT(), 1) : 0)
|
|
#define EATTWO(a, b) ((SEETWO(a, b)) ? (NEXT2(), 1) : 0)
|
|
#define NEXT() (p->next++)
|
|
#define NEXT2() (p->next += 2)
|
|
#define NEXTn(n) (p->next += (n))
|
|
#define GETNEXT() (*p->next++)
|
|
#define SETERROR(e) seterr(p, (e))
|
|
#define REQUIRE(co, e) ((co) || SETERROR(e))
|
|
#define MUSTSEE(c, e) (REQUIRE(MORE() && PEEK() == (c), e))
|
|
#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 never 0 /* some <assert.h>s have bugs too */
|
|
|
|
int /* 0 success, otherwise REG_something */
|
|
regcomp(preg, pattern, cflags)
|
|
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;
|
|
#define GOODFLAGS(f) ((f)&~REG_DUMP)
|
|
|
|
cflags = GOODFLAGS(cflags);
|
|
if ((cflags®_EXTENDED) && (cflags®_NOSPEC))
|
|
return(REG_INVARG);
|
|
|
|
if (cflags®_PEND) {
|
|
if (preg->re_endp < pattern)
|
|
return(REG_INVARG);
|
|
len = preg->re_endp - pattern;
|
|
} else
|
|
len = strlen((char *)pattern);
|
|
/*
|
|
Find the maximum len we can safely process
|
|
without a rollover and a mis-malloc.
|
|
p->ssize is a sopno is a long (32+ bit signed);
|
|
size_t is 16+ bit unsigned.
|
|
*/
|
|
{
|
|
size_t new_ssize = len / (size_t)2 * (size_t)3 + (size_t)1; /* ugh */
|
|
if ((new_ssize < len) || /* size_t rolled over */
|
|
((SIZE_T_MAX / sizeof(sop)) < new_ssize) || /* malloc arg */
|
|
(new_ssize > LONG_MAX)) /* won't fit in ssize */
|
|
return(REG_ESPACE); /* MY_REG_ESPACE or MY_REG_INVARG */
|
|
p->ssize = new_ssize;
|
|
}
|
|
/* do the mallocs early so failure handling is easy */
|
|
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->slen = 0;
|
|
if (p->strip == NULL) {
|
|
free((char *)g);
|
|
return(REG_ESPACE);
|
|
}
|
|
|
|
/* set things up */
|
|
p->g = g;
|
|
p->next = (char *)pattern; /* convenience; we do not modify it */
|
|
p->end = p->next + len;
|
|
p->error = 0;
|
|
p->ncsalloc = 0;
|
|
for (i = 0; i < NPAREN; i++) {
|
|
p->pbegin[i] = 0;
|
|
p->pend[i] = 0;
|
|
}
|
|
g->csetsize = NC;
|
|
g->sets = NULL;
|
|
g->setbits = NULL;
|
|
g->ncsets = 0;
|
|
g->cflags = cflags;
|
|
g->iflags = 0;
|
|
g->nbol = 0;
|
|
g->neol = 0;
|
|
g->must = NULL;
|
|
g->mlen = 0;
|
|
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));
|
|
g->backrefs = 0;
|
|
|
|
/* do it */
|
|
EMIT(OEND, 0);
|
|
g->firststate = THERE();
|
|
if (cflags®_EXTENDED)
|
|
p_ere(p, OUT);
|
|
else if (cflags®_NOSPEC)
|
|
p_str(p);
|
|
else
|
|
p_bre(p, OUT, OUT);
|
|
EMIT(OEND, 0);
|
|
g->laststate = THERE();
|
|
|
|
/* tidy up loose ends and fill things in */
|
|
categorize(p, g);
|
|
stripsnug(p, g);
|
|
findmust(p, g);
|
|
g->nplus = pluscount(p, g);
|
|
g->magic = MAGIC2;
|
|
preg->re_nsub = g->nsub;
|
|
preg->re_g = g;
|
|
preg->re_magic = MAGIC1;
|
|
/* not debugging, so can't rely on the assert() in regexec() */
|
|
if (g->iflags&BAD)
|
|
SETERROR(REG_ASSERT);
|
|
|
|
/* win or lose, we're done */
|
|
if (p->error != 0) /* lose */
|
|
regfree(preg);
|
|
return(p->error);
|
|
#undef GOODFLAGS
|
|
}
|
|
|
|
/*
|
|
- p_ere - ERE parser top level, concatenation and alternation
|
|
== static void p_ere(register struct parse *p, int stop);
|
|
*/
|
|
static void
|
|
p_ere(p, stop)
|
|
register struct parse *p;
|
|
int stop; /* character this ERE should end at */
|
|
{
|
|
register char c;
|
|
register sopno prevback;
|
|
register sopno prevfwd;
|
|
register sopno conc;
|
|
register 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 */
|
|
|
|
if (!EAT('|'))
|
|
break; /* NOTE BREAK OUT */
|
|
|
|
if (first) {
|
|
INSERT(OCH_, conc); /* offset is wrong */
|
|
prevfwd = conc;
|
|
prevback = conc;
|
|
first = 0;
|
|
}
|
|
ASTERN(OOR1, prevback);
|
|
prevback = THERE();
|
|
AHEAD(prevfwd); /* fix previous offset */
|
|
prevfwd = HERE();
|
|
EMIT(OOR2, 0); /* offset is very wrong */
|
|
}
|
|
|
|
if (!first) { /* tail-end fixups */
|
|
AHEAD(prevfwd);
|
|
ASTERN(O_CH, prevback);
|
|
}
|
|
|
|
assert(!MORE() || SEE(stop));
|
|
}
|
|
|
|
/*
|
|
- 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(p)
|
|
register struct parse *p;
|
|
{
|
|
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();
|
|
|
|
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 '^':
|
|
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®_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;
|
|
}
|
|
|
|
if (!MORE())
|
|
return;
|
|
c = PEEK();
|
|
/* we call { a repetition if followed by a digit */
|
|
if (!( c == '*' || c == '+' || c == '?' ||
|
|
(c == '{' && MORE2() && isdigit(PEEK2())) ))
|
|
return; /* no repetition, we're done */
|
|
NEXT();
|
|
|
|
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())) {
|
|
count2 = p_count(p);
|
|
REQUIRE(count <= count2, REG_BADBR);
|
|
} 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;
|
|
}
|
|
|
|
if (!MORE())
|
|
return;
|
|
c = PEEK();
|
|
if (!( c == '*' || c == '+' || c == '?' ||
|
|
(c == '{' && MORE2() && isdigit(PEEK2())) ) )
|
|
return;
|
|
SETERROR(REG_BADRPT);
|
|
}
|
|
|
|
/*
|
|
- p_str - string (no metacharacters) "parser"
|
|
== static void p_str(register struct parse *p);
|
|
*/
|
|
static void
|
|
p_str(p)
|
|
register struct parse *p;
|
|
{
|
|
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);
|
|
* Giving end1 as OUT essentially eliminates the end1/end2 check.
|
|
*
|
|
* This implementation is a bit of a kludge, in that a trailing $ is first
|
|
* taken as an ordinary character and then revised to be an anchor. The
|
|
* only undesirable side effect is that '$' gets included as a character
|
|
* category in such cases. This is fairly harmless; not worth fixing.
|
|
* 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 */
|
|
{
|
|
register sopno start = HERE();
|
|
register int first = 1; /* first subexpression? */
|
|
register int wasdollar = 0;
|
|
|
|
if (EAT('^')) {
|
|
EMIT(OBOL, 0);
|
|
p->g->iflags |= USEBOL;
|
|
p->g->nbol++;
|
|
}
|
|
while (MORE() && !SEETWO(end1, end2)) {
|
|
wasdollar = p_simp_re(p, first);
|
|
first = 0;
|
|
}
|
|
if (wasdollar) { /* oops, that was a trailing anchor */
|
|
DROP(1);
|
|
EMIT(OEOL, 0);
|
|
p->g->iflags |= USEEOL;
|
|
p->g->neol++;
|
|
}
|
|
|
|
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 /* was the simple RE an unbackslashed $? */
|
|
p_simp_re(p, starordinary)
|
|
register 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;
|
|
# define BACKSL (1<<CHAR_BIT)
|
|
|
|
pos = HERE(); /* repetion op, if any, covers from here */
|
|
|
|
assert(MORE()); /* caller should have ensured this */
|
|
c = GETNEXT();
|
|
if (c == '\\') {
|
|
REQUIRE(MORE(), REG_EESCAPE);
|
|
c = BACKSL | (unsigned char)GETNEXT();
|
|
}
|
|
switch (c) {
|
|
case '.':
|
|
if (p->g->cflags®_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);
|
|
(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);
|
|
/* FALLTHROUGH */
|
|
default:
|
|
ordinary(p, (char)c); /* takes off BACKSL, if any */
|
|
break;
|
|
}
|
|
|
|
if (EAT('*')) { /* 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);
|
|
} else if (EATTWO('\\', '{')) {
|
|
count = p_count(p);
|
|
if (EAT(',')) {
|
|
if (MORE() && isdigit(PEEK())) {
|
|
count2 = p_count(p);
|
|
REQUIRE(count <= count2, REG_BADBR);
|
|
} else /* single number with comma */
|
|
count2 = INFINITY;
|
|
} else /* just a single number */
|
|
count2 = count;
|
|
repeat(p, pos, count, count2);
|
|
if (!EATTWO('\\', '}')) { /* error heuristics */
|
|
while (MORE() && !SEETWO('\\', '}'))
|
|
NEXT();
|
|
REQUIRE(MORE(), REG_EBRACE);
|
|
SETERROR(REG_BADBR);
|
|
}
|
|
} else if (c == (unsigned char)'$') /* $ (but not \$) ends it */
|
|
return(1);
|
|
|
|
return(0);
|
|
}
|
|
|
|
/*
|
|
- p_count - parse a repetition count
|
|
== static int p_count(register struct parse *p);
|
|
*/
|
|
static int /* the value */
|
|
p_count(p)
|
|
register struct parse *p;
|
|
{
|
|
register int count = 0;
|
|
register int ndigits = 0;
|
|
|
|
while (MORE() && isdigit(PEEK()) && count <= DUPMAX) {
|
|
count = count*10 + (GETNEXT() - '0');
|
|
ndigits++;
|
|
}
|
|
|
|
REQUIRE(ndigits > 0 && count <= DUPMAX, REG_BADBR);
|
|
return(count);
|
|
}
|
|
|
|
/*
|
|
- p_bracket - parse a bracketed character list
|
|
== static void p_bracket(register 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;
|
|
{
|
|
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) {
|
|
EMIT(OBOW, 0);
|
|
NEXTn(6);
|
|
return;
|
|
}
|
|
if (p->next + 5 < p->end && strncmp(p->next, "[:>:]]", 6) == 0) {
|
|
EMIT(OEOW, 0);
|
|
NEXTn(6);
|
|
return;
|
|
}
|
|
|
|
if (EAT('^'))
|
|
invert++; /* make note to invert set at end */
|
|
if (EAT(']'))
|
|
CHadd(cs, ']');
|
|
else if (EAT('-'))
|
|
CHadd(cs, '-');
|
|
while (MORE() && PEEK() != ']' && !SEETWO('-', ']'))
|
|
p_b_term(p, cs);
|
|
if (EAT('-'))
|
|
CHadd(cs, '-');
|
|
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;
|
|
|
|
for (i = p->g->csetsize - 1; i >= 0; i--)
|
|
if (CHIN(cs, i) && isalpha(i)) {
|
|
ci = othercase(i);
|
|
if (ci != i)
|
|
CHadd(cs, ci);
|
|
}
|
|
if (cs->multis != NULL)
|
|
mccase(p, cs);
|
|
}
|
|
if (invert) {
|
|
register int i;
|
|
|
|
for (i = p->g->csetsize - 1; i >= 0; i--)
|
|
if (CHIN(cs, i))
|
|
CHsub(cs, i);
|
|
else
|
|
CHadd(cs, i);
|
|
if (p->g->cflags®_NEWLINE)
|
|
CHsub(cs, '\n');
|
|
if (cs->multis != NULL)
|
|
mcinvert(p, cs);
|
|
}
|
|
|
|
assert(cs->multis == NULL); /* xxx */
|
|
|
|
if (nch(p, cs) == 1) { /* optimize singleton sets */
|
|
ordinary(p, firstch(p, cs));
|
|
freeset(p, cs);
|
|
} else
|
|
EMIT(OANYOF, freezeset(p, cs));
|
|
}
|
|
|
|
/*
|
|
- 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(p, cs)
|
|
register struct parse *p;
|
|
register cset *cs;
|
|
{
|
|
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;
|
|
}
|
|
|
|
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 */
|
|
/* xxx revision needed for multichar stuff */
|
|
start = p_b_symbol(p);
|
|
if (SEE('-') && MORE2() && PEEK2() != ']') {
|
|
/* range */
|
|
NEXT();
|
|
if (EAT('-'))
|
|
finish = '-';
|
|
else
|
|
finish = p_b_symbol(p);
|
|
} else
|
|
finish = start;
|
|
/* xxx what about signed chars here... */
|
|
REQUIRE(start <= finish, REG_ERANGE);
|
|
for (i = start; i <= finish; i++)
|
|
CHadd(cs, i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
- 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(p, cs)
|
|
register struct parse *p;
|
|
register cset *cs;
|
|
{
|
|
register char *sp = p->next;
|
|
register struct cclass *cp;
|
|
register size_t len;
|
|
register char *u;
|
|
register char c;
|
|
|
|
while (MORE() && isalpha(PEEK()))
|
|
NEXT();
|
|
len = p->next - sp;
|
|
for (cp = cclasses; cp->name != NULL; cp++)
|
|
if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')
|
|
break;
|
|
if (cp->name == NULL) {
|
|
/* oops, didn't find it */
|
|
SETERROR(REG_ECTYPE);
|
|
return;
|
|
}
|
|
|
|
u = cp->chars;
|
|
while ((c = *u++) != '\0')
|
|
CHadd(cs, c);
|
|
for (u = cp->multis; *u != '\0'; u += strlen(u) + 1)
|
|
MCadd(p, cs, u);
|
|
}
|
|
|
|
/*
|
|
- p_b_eclass - parse an equivalence-class name and deal with it
|
|
== static void p_b_eclass(register 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;
|
|
{
|
|
register char c;
|
|
|
|
c = 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 /* value of symbol */
|
|
p_b_symbol(p)
|
|
register struct parse *p;
|
|
{
|
|
register char value;
|
|
|
|
REQUIRE(MORE(), REG_EBRACK);
|
|
if (!EATTWO('[', '.'))
|
|
return(GETNEXT());
|
|
|
|
/* collating symbol */
|
|
value = p_b_coll_elem(p, '.');
|
|
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 /* value of collating element */
|
|
p_b_coll_elem(p, endc)
|
|
register struct parse *p;
|
|
int endc; /* name ended by endc,']' */
|
|
{
|
|
register char *sp = p->next;
|
|
register struct cname *cp;
|
|
register int len;
|
|
|
|
while (MORE() && !SEETWO(endc, ']'))
|
|
NEXT();
|
|
if (!MORE()) {
|
|
SETERROR(REG_EBRACK);
|
|
return(0);
|
|
}
|
|
len = 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);
|
|
}
|
|
|
|
/*
|
|
- othercase - return the case counterpart of an alphabetic
|
|
== static char othercase(int ch);
|
|
*/
|
|
static char /* if no counterpart, return ch */
|
|
othercase(ch)
|
|
int ch;
|
|
{
|
|
assert(isalpha(ch));
|
|
if (isupper(ch))
|
|
return(tolower(ch));
|
|
else if (islower(ch))
|
|
return(toupper(ch));
|
|
else /* peculiar, but could happen */
|
|
return(ch);
|
|
}
|
|
|
|
/*
|
|
- bothcases - emit a dualcase version of a two-case character
|
|
== static void bothcases(register struct parse *p, int ch);
|
|
*
|
|
* Boy, is this implementation ever a kludge...
|
|
*/
|
|
static void
|
|
bothcases(p, ch)
|
|
register struct parse *p;
|
|
int ch;
|
|
{
|
|
register char *oldnext = p->next;
|
|
register char *oldend = p->end;
|
|
char bracket[3];
|
|
|
|
assert(othercase(ch) != ch); /* p_bracket() would recurse */
|
|
p->next = bracket;
|
|
p->end = bracket+2;
|
|
bracket[0] = ch;
|
|
bracket[1] = ']';
|
|
bracket[2] = '\0';
|
|
p_bracket(p);
|
|
assert(p->next == bracket+2);
|
|
p->next = oldnext;
|
|
p->end = oldend;
|
|
}
|
|
|
|
/*
|
|
- ordinary - emit an ordinary character
|
|
== static void ordinary(register struct parse *p, register int ch);
|
|
*/
|
|
static void
|
|
ordinary(p, ch)
|
|
register struct parse *p;
|
|
register int ch;
|
|
{
|
|
register 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++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
- nonnewline - emit REG_NEWLINE version of OANY
|
|
== static void nonnewline(register struct parse *p);
|
|
*
|
|
* Boy, is this implementation ever a kludge...
|
|
*/
|
|
static void
|
|
nonnewline(p)
|
|
register struct parse *p;
|
|
{
|
|
register char *oldnext = p->next;
|
|
register char *oldend = p->end;
|
|
char bracket[4];
|
|
|
|
p->next = bracket;
|
|
p->end = bracket+3;
|
|
bracket[0] = '^';
|
|
bracket[1] = '\n';
|
|
bracket[2] = ']';
|
|
bracket[3] = '\0';
|
|
p_bracket(p);
|
|
assert(p->next == bracket+3);
|
|
p->next = oldnext;
|
|
p->end = oldend;
|
|
}
|
|
|
|
/*
|
|
- 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(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) */
|
|
{
|
|
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;
|
|
|
|
if (p->error != 0) /* head off possible runaway recursion */
|
|
return;
|
|
|
|
assert(from <= to);
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
/*
|
|
- seterr - set an error condition
|
|
== static int seterr(register struct parse *p, int e);
|
|
*/
|
|
static int /* useless but makes type checking happy */
|
|
seterr(p, e)
|
|
register struct parse *p;
|
|
int e;
|
|
{
|
|
if (p->error == 0) /* keep earliest error condition */
|
|
p->error = e;
|
|
p->next = nuls; /* try to bring things to a halt */
|
|
p->end = nuls;
|
|
return(0); /* make the return value well-defined */
|
|
}
|
|
|
|
/*
|
|
- allocset - allocate a set of characters for []
|
|
== static cset *allocset(register struct parse *p);
|
|
*/
|
|
static cset *
|
|
allocset(p)
|
|
register 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;
|
|
|
|
if (no >= p->ncsalloc) { /* need another column of space */
|
|
p->ncsalloc += CHAR_BIT;
|
|
nc = p->ncsalloc;
|
|
assert(nc % CHAR_BIT == 0);
|
|
nbytes = nc / CHAR_BIT * css;
|
|
if (p->g->sets == NULL)
|
|
p->g->sets = (cset *)malloc(nc * sizeof(cset));
|
|
else
|
|
p->g->sets = (cset *)realloc((char *)p->g->sets,
|
|
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 != NULL && p->g->setbits != NULL)
|
|
(void) memset((char *)p->g->setbits + (nbytes - css),
|
|
0, css);
|
|
else {
|
|
no = 0;
|
|
SETERROR(REG_ESPACE);
|
|
/* caller's responsibility not to do set ops */
|
|
}
|
|
}
|
|
|
|
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->hash = 0;
|
|
cs->smultis = 0;
|
|
cs->multis = NULL;
|
|
|
|
return(cs);
|
|
}
|
|
|
|
/*
|
|
- freeset - free a now-unused set
|
|
== static void freeset(register struct parse *p, register cset *cs);
|
|
*/
|
|
static void
|
|
freeset(p, cs)
|
|
register struct parse *p;
|
|
register cset *cs;
|
|
{
|
|
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++)
|
|
CHsub(cs, i);
|
|
if (cs == top-1) /* recover only the easy case */
|
|
p->g->ncsets--;
|
|
}
|
|
|
|
/*
|
|
- freezeset - final processing on a set of characters
|
|
== static int freezeset(register 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
|
|
* big if REG_ICASE is being used. REG_ICASE, by the way, is why the hash
|
|
* is done using addition rather than xor -- all ASCII [aA] sets xor to
|
|
* the same value!
|
|
*/
|
|
static int /* set number */
|
|
freezeset(p, cs)
|
|
register struct parse *p;
|
|
register 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;
|
|
|
|
/* look for an earlier one which is the same */
|
|
for (cs2 = &p->g->sets[0]; cs2 < top; cs2++)
|
|
if (cs2->hash == h && cs2 != cs) {
|
|
/* maybe */
|
|
for (i = 0; i < css; i++)
|
|
if (!!CHIN(cs2, i) != !!CHIN(cs, i))
|
|
break; /* no */
|
|
if (i == css)
|
|
break; /* yes */
|
|
}
|
|
|
|
if (cs2 < top) { /* found one */
|
|
freeset(p, cs);
|
|
cs = cs2;
|
|
}
|
|
|
|
return((int)(cs - p->g->sets));
|
|
}
|
|
|
|
/*
|
|
- 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 /* character; there is no "none" value */
|
|
firstch(p, cs)
|
|
register struct parse *p;
|
|
register cset *cs;
|
|
{
|
|
register int i;
|
|
register size_t css = (size_t)p->g->csetsize;
|
|
|
|
for (i = 0; i < css; i++)
|
|
if (CHIN(cs, i))
|
|
return((char)i);
|
|
assert(never);
|
|
return(0); /* arbitrary */
|
|
}
|
|
|
|
/*
|
|
- nch - number of characters in a set
|
|
== static int nch(register struct parse *p, register cset *cs);
|
|
*/
|
|
static int
|
|
nch(p, cs)
|
|
register struct parse *p;
|
|
register cset *cs;
|
|
{
|
|
register int i;
|
|
register size_t css = (size_t)p->g->csetsize;
|
|
register int n = 0;
|
|
|
|
for (i = 0; i < css; i++)
|
|
if (CHIN(cs, i))
|
|
n++;
|
|
return(n);
|
|
}
|
|
|
|
/*
|
|
- mcadd - add a collating element to a cset
|
|
== static void mcadd(register struct parse *p, register cset *cs, \
|
|
== register char *cp);
|
|
*/
|
|
static void
|
|
mcadd(p, cs, cp)
|
|
register struct parse *p;
|
|
register cset *cs;
|
|
register char *cp;
|
|
{
|
|
register 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);
|
|
if (cs->multis == NULL) {
|
|
SETERROR(REG_ESPACE);
|
|
return;
|
|
}
|
|
|
|
(void) strcpy(cs->multis + oldend - 1, cp);
|
|
cs->multis[cs->smultis - 1] = '\0';
|
|
}
|
|
|
|
/*
|
|
- mcinvert - invert the list of collating elements in a cset
|
|
== static void mcinvert(register 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;
|
|
{
|
|
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);
|
|
*
|
|
* This would have to know the set of possibilities. Implementation
|
|
* is deferred.
|
|
*/
|
|
static void
|
|
mccase(p, cs)
|
|
register struct parse *p;
|
|
register cset *cs;
|
|
{
|
|
assert(cs->multis == NULL); /* xxx */
|
|
}
|
|
|
|
/*
|
|
- isinsets - is this character in any sets?
|
|
== static int isinsets(register struct re_guts *g, int c);
|
|
*/
|
|
static int /* predicate */
|
|
isinsets(g, c)
|
|
register 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;
|
|
|
|
for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
|
|
if (col[uc] != 0)
|
|
return(1);
|
|
return(0);
|
|
}
|
|
|
|
/*
|
|
- samesets - are these two characters in exactly the same sets?
|
|
== static int samesets(register struct re_guts *g, int c1, int c2);
|
|
*/
|
|
static int /* predicate */
|
|
samesets(g, c1, c2)
|
|
register 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;
|
|
|
|
for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
|
|
if (col[uc1] != col[uc2])
|
|
return(0);
|
|
return(1);
|
|
}
|
|
|
|
/*
|
|
- categorize - sort out character categories
|
|
== static void categorize(struct parse *p, register struct re_guts *g);
|
|
*/
|
|
static void
|
|
categorize(p, g)
|
|
struct parse *p;
|
|
register struct re_guts *g;
|
|
{
|
|
register cat_t *cats = g->categories;
|
|
register int c;
|
|
register int c2;
|
|
register cat_t cat;
|
|
|
|
/* avoid making error situations worse */
|
|
if (p->error != 0)
|
|
return;
|
|
|
|
for (c = CHAR_MIN; c <= CHAR_MAX; c++)
|
|
if (cats[c] == 0 && isinsets(g, c)) {
|
|
cat = g->ncategories++;
|
|
cats[c] = cat;
|
|
for (c2 = c+1; c2 <= CHAR_MAX; c2++)
|
|
if (cats[c2] == 0 && samesets(g, c, c2))
|
|
cats[c2] = cat;
|
|
}
|
|
}
|
|
|
|
/*
|
|
- 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 */
|
|
dupl(p, start, finish)
|
|
register struct parse *p;
|
|
sopno start; /* from here */
|
|
sopno finish; /* to this less one */
|
|
{
|
|
register sopno ret = HERE();
|
|
register sopno len = 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);
|
|
(void) memcpy((char *)(p->strip + p->slen),
|
|
(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);
|
|
*
|
|
* 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;
|
|
{
|
|
/* avoid making error situations worse */
|
|
if (p->error != 0)
|
|
return;
|
|
|
|
/* deal with oversize operands ("can't happen", more or less) */
|
|
assert(opnd < 1<<OPSHIFT);
|
|
|
|
/* deal with undersized strip */
|
|
if (p->slen >= p->ssize)
|
|
enlarge(p, (p->ssize+1) / 2 * 3); /* +50% */
|
|
assert(p->slen < p->ssize);
|
|
|
|
/* finally, it's all reduced to the easy case */
|
|
p->strip[p->slen++] = SOP(op, 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(p, op, opnd, pos)
|
|
register struct parse *p;
|
|
sop op;
|
|
size_t opnd;
|
|
sopno pos;
|
|
{
|
|
register sopno sn;
|
|
register sop s;
|
|
register int i;
|
|
|
|
/* avoid making error situations worse */
|
|
if (p->error != 0)
|
|
return;
|
|
|
|
sn = HERE();
|
|
EMIT(op, opnd); /* do checks, ensure space */
|
|
assert(HERE() == sn+1);
|
|
s = p->strip[sn];
|
|
|
|
/* adjust paren pointers */
|
|
assert(pos > 0);
|
|
for (i = 1; i < NPAREN; i++) {
|
|
if (p->pbegin[i] >= pos) {
|
|
p->pbegin[i]++;
|
|
}
|
|
if (p->pend[i] >= pos) {
|
|
p->pend[i]++;
|
|
}
|
|
}
|
|
|
|
memmove((char *)&p->strip[pos+1], (char *)&p->strip[pos],
|
|
(HERE()-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(p, pos, value)
|
|
register struct parse *p;
|
|
register sopno pos;
|
|
sop value;
|
|
{
|
|
/* avoid making error situations worse */
|
|
if (p->error != 0)
|
|
return;
|
|
|
|
assert(value < 1<<OPSHIFT);
|
|
p->strip[pos] = OP(p->strip[pos]) | value;
|
|
}
|
|
|
|
/*
|
|
- enlarge - enlarge the strip
|
|
== static void enlarge(register struct parse *p, sopno size);
|
|
*/
|
|
static void
|
|
enlarge(p, size)
|
|
register struct parse *p;
|
|
register sopno size;
|
|
{
|
|
register sop *sp;
|
|
|
|
if (p->ssize >= size)
|
|
return;
|
|
|
|
sp = (sop *)realloc(p->strip, size*sizeof(sop));
|
|
if (sp == NULL) {
|
|
SETERROR(REG_ESPACE);
|
|
return;
|
|
}
|
|
p->strip = sp;
|
|
p->ssize = size;
|
|
}
|
|
|
|
/*
|
|
- stripsnug - compact the strip
|
|
== static void stripsnug(register struct parse *p, register struct re_guts *g);
|
|
*/
|
|
static void
|
|
stripsnug(p, g)
|
|
register struct parse *p;
|
|
register struct re_guts *g;
|
|
{
|
|
g->nstates = p->slen;
|
|
g->strip = (sop *)realloc((char *)p->strip, p->slen * sizeof(sop));
|
|
if (g->strip == NULL) {
|
|
SETERROR(REG_ESPACE);
|
|
g->strip = p->strip;
|
|
}
|
|
}
|
|
|
|
/*
|
|
- findmust - fill in must and mlen with longest mandatory literal string
|
|
== static void findmust(register 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
|
|
* of the interesting cases.
|
|
*
|
|
* Note that must and mlen got initialized during setup.
|
|
*/
|
|
static void
|
|
findmust(p, g)
|
|
struct parse *p;
|
|
register struct re_guts *g;
|
|
{
|
|
register sop *scan;
|
|
sop *start;
|
|
register sop *newstart;
|
|
register sopno newlen;
|
|
register sop s;
|
|
register char *cp;
|
|
register sopno i;
|
|
|
|
/* avoid making error situations worse */
|
|
if (p->error != 0)
|
|
return;
|
|
|
|
/* find the longest OCHAR sequence in strip */
|
|
newlen = 0;
|
|
scan = g->strip + 1;
|
|
do {
|
|
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) {
|
|
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;
|
|
}
|
|
newlen = 0;
|
|
break;
|
|
}
|
|
} while (OP(s) != OEND);
|
|
|
|
if (g->mlen == 0) /* there isn't one */
|
|
return;
|
|
|
|
/* turn it into a character string */
|
|
g->must = malloc((size_t)g->mlen + 1);
|
|
if (g->must == NULL) { /* argh; just forget it */
|
|
g->mlen = 0;
|
|
return;
|
|
}
|
|
cp = g->must;
|
|
scan = start;
|
|
for (i = g->mlen; i > 0; i--) {
|
|
while (OP(s = *scan++) != OCHAR)
|
|
continue;
|
|
assert(cp < g->must + g->mlen);
|
|
*cp++ = (char)OPND(s);
|
|
}
|
|
assert(cp == g->must + g->mlen);
|
|
*cp++ = '\0'; /* just on general principles */
|
|
}
|
|
|
|
/*
|
|
- pluscount - count + nesting
|
|
== static sopno pluscount(register struct parse *p, register struct re_guts *g);
|
|
*/
|
|
static sopno /* nesting depth */
|
|
pluscount(p, g)
|
|
struct parse *p;
|
|
register struct re_guts *g;
|
|
{
|
|
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 */
|
|
|
|
scan = g->strip + 1;
|
|
do {
|
|
s = *scan++;
|
|
switch (OP(s)) {
|
|
case OPLUS_:
|
|
plusnest++;
|
|
break;
|
|
case O_PLUS:
|
|
if (plusnest > maxnest)
|
|
maxnest = plusnest;
|
|
plusnest--;
|
|
break;
|
|
}
|
|
} while (OP(s) != OEND);
|
|
if (plusnest != 0)
|
|
g->iflags |= BAD;
|
|
return(maxnest);
|
|
}
|
|
|
|
static int nope = 0; /* for use in asserts; shuts lint up */
|
|
|
|
/* macros for manipulating states, small version */
|
|
#define states unsigned
|
|
#define states1 unsigned /* for later use in regexec() decision */
|
|
#define CLEAR(v) ((v) = 0)
|
|
#define SET0(v, n) ((v) &= ~((unsigned)1 << (n)))
|
|
#define SET1(v, n) ((v) |= (unsigned)1 << (n))
|
|
#define ISSET(v, n) ((v) & ((unsigned)1 << (n)))
|
|
#define ASSIGN(d, s) ((d) = (s))
|
|
#define EQ(a, b) ((a) == (b))
|
|
#define STATEVARS int dummy /* dummy version */
|
|
#define STATESETUP(m, n) /* nothing */
|
|
#define STATETEARDOWN(m) /* nothing */
|
|
#define SETUP(v) ((v) = 0)
|
|
#define onestate unsigned
|
|
#define INIT(o, n) ((o) = (unsigned)1 << (n))
|
|
#define INC(o) ((o) <<= 1)
|
|
#define ISSTATEIN(v, o) ((v) & (o))
|
|
/* some abbreviations; note that some of these know variable names! */
|
|
/* do "if I'm here, I can also be there" etc without branches */
|
|
#define FWD(dst, src, n) ((dst) |= ((unsigned)(src)&(here)) << (n))
|
|
#define BACK(dst, src, n) ((dst) |= ((unsigned)(src)&(here)) >> (n))
|
|
#define ISSETBACK(v, n) ((v) & ((unsigned)here >> (n)))
|
|
/* function names */
|
|
#define SNAMES /* engine.c looks after details */
|
|
|
|
/*
|
|
* The matching engine and friends. This file is #included by regexec.c
|
|
* after suitable #defines of a variety of macros used herein, so that
|
|
* different state representations can be used without duplicating masses
|
|
* of code.
|
|
*/
|
|
|
|
#ifdef SNAMES
|
|
#define matcher smatcher
|
|
#define fast sfast
|
|
#define slow sslow
|
|
#define dissect sdissect
|
|
#define backref sbackref
|
|
#define step sstep
|
|
#define print sprint
|
|
#define at sat
|
|
#define match smat
|
|
#endif
|
|
#ifdef LNAMES
|
|
#define matcher lmatcher
|
|
#define fast lfast
|
|
#define slow lslow
|
|
#define dissect ldissect
|
|
#define backref lbackref
|
|
#define step lstep
|
|
#define print lprint
|
|
#define at lat
|
|
#define match lmat
|
|
#endif
|
|
|
|
/* another structure passed up and down to avoid zillions of parameters */
|
|
struct match {
|
|
struct re_guts *g;
|
|
int eflags;
|
|
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] */
|
|
STATEVARS;
|
|
states st; /* current states */
|
|
states fresh; /* states for a fresh start */
|
|
states tmp; /* temporary */
|
|
states empty; /* empty set of states */
|
|
};
|
|
|
|
static int matcher(register struct re_guts *g, char *string, size_t nmatch, regmatch_t pmatch[], int eflags);
|
|
static char *dissect(register struct match *m, char *start, char *stop, sopno startst, sopno stopst);
|
|
static char *backref(register struct match *m, char *start, char *stop, sopno startst, sopno stopst, sopno lev);
|
|
static char *fast(register struct match *m, char *start, char *stop, sopno startst, sopno stopst);
|
|
static char *slow(register struct match *m, char *start, char *stop, sopno startst, sopno stopst);
|
|
static states step(register struct re_guts *g, sopno start, sopno stop, register states bef, int ch, register states aft);
|
|
#define BOL (OUT+1)
|
|
#define EOL (BOL+1)
|
|
#define BOLEOL (BOL+2)
|
|
#define NOTHING (BOL+3)
|
|
#define BOW (BOL+4)
|
|
#define EOW (BOL+5)
|
|
#define CODEMAX (BOL+5) /* highest code used */
|
|
#define NONCHAR(c) ((c) > CHAR_MAX)
|
|
#define NNONCHAR (CODEMAX-CHAR_MAX)
|
|
#define SP(t, s, c) /* nothing */
|
|
#define AT(t, p1, p2, s1, s2) /* nothing */
|
|
#define NOTE(s) /* nothing */
|
|
|
|
/*
|
|
- matcher - the actual matching engine
|
|
== static int matcher(register struct re_guts *g, char *string, \
|
|
== size_t nmatch, regmatch_t pmatch[], int eflags);
|
|
*/
|
|
static int /* 0 success, REG_NOMATCH failure */
|
|
matcher(g, string, nmatch, pmatch, eflags)
|
|
register struct re_guts *g;
|
|
char *string;
|
|
size_t nmatch;
|
|
regmatch_t pmatch[];
|
|
int eflags;
|
|
{
|
|
register char *endp;
|
|
register int i;
|
|
struct match mv;
|
|
register struct match *m = &mv;
|
|
register char *dp;
|
|
const register sopno gf = g->firststate+1; /* +1 for OEND */
|
|
const register sopno gl = g->laststate;
|
|
char *start;
|
|
char *stop;
|
|
|
|
/* simplify the situation where possible */
|
|
if (g->cflags®_NOSUB)
|
|
nmatch = 0;
|
|
if (eflags®_STARTEND) {
|
|
start = string + pmatch[0].rm_so;
|
|
stop = string + pmatch[0].rm_eo;
|
|
} else {
|
|
start = string;
|
|
stop = start + strlen(start);
|
|
}
|
|
if (stop < start)
|
|
return(REG_INVARG);
|
|
|
|
/* prescreening; this does wonders for this rather slow code */
|
|
if (g->must != NULL) {
|
|
for (dp = start; dp < stop; dp++)
|
|
if (*dp == g->must[0] && stop - dp >= g->mlen &&
|
|
memcmp(dp, g->must, (size_t)g->mlen) == 0)
|
|
break;
|
|
if (dp == stop) /* we didn't find g->must */
|
|
return(REG_NOMATCH);
|
|
}
|
|
|
|
/* match struct setup */
|
|
m->g = g;
|
|
m->eflags = eflags;
|
|
m->pmatch = NULL;
|
|
m->lastpos = NULL;
|
|
m->offp = string;
|
|
m->beginp = start;
|
|
m->endp = stop;
|
|
STATESETUP(m, 4);
|
|
SETUP(m->st);
|
|
SETUP(m->fresh);
|
|
SETUP(m->tmp);
|
|
SETUP(m->empty);
|
|
CLEAR(m->empty);
|
|
|
|
/* this loop does only one repetition except for backrefs */
|
|
for (;;) {
|
|
endp = fast(m, start, stop, gf, gl);
|
|
if (endp == NULL) { /* a miss */
|
|
STATETEARDOWN(m);
|
|
return(REG_NOMATCH);
|
|
}
|
|
if (nmatch == 0 && !g->backrefs)
|
|
break; /* no further info needed */
|
|
|
|
/* where? */
|
|
assert(m->coldp != NULL);
|
|
for (;;) {
|
|
NOTE("finding start");
|
|
endp = slow(m, m->coldp, stop, gf, gl);
|
|
if (endp != NULL)
|
|
break;
|
|
assert(m->coldp < m->endp);
|
|
m->coldp++;
|
|
}
|
|
if (nmatch == 1 && !g->backrefs)
|
|
break; /* no further info needed */
|
|
|
|
/* oh my, he wants the subexpressions... */
|
|
if (m->pmatch == NULL)
|
|
m->pmatch = (regmatch_t *)malloc((m->g->nsub + 1) *
|
|
sizeof(regmatch_t));
|
|
if (m->pmatch == NULL) {
|
|
STATETEARDOWN(m);
|
|
return(REG_ESPACE);
|
|
}
|
|
for (i = 1; i <= m->g->nsub; i++)
|
|
m->pmatch[i].rm_so = m->pmatch[i].rm_eo = -1;
|
|
if (!g->backrefs && !(m->eflags®_BACKR)) {
|
|
NOTE("dissecting");
|
|
dp = dissect(m, m->coldp, endp, gf, gl);
|
|
} else {
|
|
if (g->nplus > 0 && m->lastpos == NULL)
|
|
m->lastpos = (char **)malloc((g->nplus+1) *
|
|
sizeof(char *));
|
|
if (g->nplus > 0 && m->lastpos == NULL) {
|
|
free(m->pmatch);
|
|
STATETEARDOWN(m);
|
|
return(REG_ESPACE);
|
|
}
|
|
NOTE("backref dissect");
|
|
dp = backref(m, m->coldp, endp, gf, gl, (sopno)0);
|
|
}
|
|
if (dp != NULL)
|
|
break;
|
|
|
|
/* uh-oh... we couldn't find a subexpression-level match */
|
|
assert(g->backrefs); /* must be back references doing it */
|
|
assert(g->nplus == 0 || m->lastpos != NULL);
|
|
for (;;) {
|
|
if (dp != NULL || endp <= m->coldp)
|
|
break; /* defeat */
|
|
NOTE("backoff");
|
|
endp = slow(m, m->coldp, endp-1, gf, gl);
|
|
if (endp == NULL)
|
|
break; /* defeat */
|
|
/* try it on a shorter possibility */
|
|
NOTE("backoff dissect");
|
|
dp = backref(m, m->coldp, endp, gf, gl, (sopno)0);
|
|
}
|
|
assert(dp == NULL || dp == endp);
|
|
if (dp != NULL) /* found a shorter one */
|
|
break;
|
|
|
|
/* despite initial appearances, there is no match here */
|
|
NOTE("false alarm");
|
|
start = m->coldp + 1; /* recycle starting later */
|
|
assert(start <= stop);
|
|
}
|
|
|
|
/* fill in the details if requested */
|
|
if (nmatch > 0) {
|
|
pmatch[0].rm_so = m->coldp - m->offp;
|
|
pmatch[0].rm_eo = endp - m->offp;
|
|
}
|
|
if (nmatch > 1) {
|
|
assert(m->pmatch != NULL);
|
|
for (i = 1; i < nmatch; i++)
|
|
if (i <= m->g->nsub)
|
|
pmatch[i] = m->pmatch[i];
|
|
else {
|
|
pmatch[i].rm_so = -1;
|
|
pmatch[i].rm_eo = -1;
|
|
}
|
|
}
|
|
|
|
if (m->pmatch != NULL)
|
|
free((char *)m->pmatch);
|
|
if (m->lastpos != NULL)
|
|
free((char *)m->lastpos);
|
|
STATETEARDOWN(m);
|
|
return(0);
|
|
}
|
|
|
|
/*
|
|
- dissect - figure out what matched what, no back references
|
|
== static char *dissect(register struct match *m, char *start, \
|
|
== char *stop, sopno startst, sopno stopst);
|
|
*/
|
|
static char * /* == stop (success) always */
|
|
dissect(m, start, stop, startst, stopst)
|
|
register struct match *m;
|
|
char *start;
|
|
char *stop;
|
|
sopno startst;
|
|
sopno stopst;
|
|
{
|
|
register int i;
|
|
register sopno ss; /* start sop of current subRE */
|
|
register sopno es; /* end sop of current subRE */
|
|
register char *sp; /* start of string matched by it */
|
|
register char *stp; /* string matched by it cannot pass here */
|
|
register char *rest; /* start of rest of string */
|
|
register char *tail; /* string unmatched by rest of RE */
|
|
register sopno ssub; /* start sop of subsubRE */
|
|
register sopno esub; /* end sop of subsubRE */
|
|
register char *ssp; /* start of string matched by subsubRE */
|
|
register char *sep; /* end of string matched by subsubRE */
|
|
register char *oldssp; /* previous ssp */
|
|
register char *dp;
|
|
|
|
AT("diss", start, stop, startst, stopst);
|
|
sp = start;
|
|
for (ss = startst; ss < stopst; ss = es) {
|
|
/* identify end of subRE */
|
|
es = ss;
|
|
switch (OP(m->g->strip[es])) {
|
|
case OPLUS_:
|
|
case OQUEST_:
|
|
es += OPND(m->g->strip[es]);
|
|
break;
|
|
case OCH_:
|
|
while (OP(m->g->strip[es]) != O_CH)
|
|
es += OPND(m->g->strip[es]);
|
|
break;
|
|
}
|
|
es++;
|
|
|
|
/* figure out what it matched */
|
|
switch (OP(m->g->strip[ss])) {
|
|
case OEND:
|
|
assert(nope);
|
|
break;
|
|
case OCHAR:
|
|
sp++;
|
|
break;
|
|
case OBOL:
|
|
case OEOL:
|
|
case OBOW:
|
|
case OEOW:
|
|
break;
|
|
case OANY:
|
|
case OANYOF:
|
|
sp++;
|
|
break;
|
|
case OBACK_:
|
|
case O_BACK:
|
|
assert(nope);
|
|
break;
|
|
/* cases where length of match is hard to find */
|
|
case OQUEST_:
|
|
stp = stop;
|
|
for (;;) {
|
|
/* how long could this one be? */
|
|
rest = slow(m, sp, stp, ss, es);
|
|
assert(rest != NULL); /* it did match */
|
|
/* could the rest match the rest? */
|
|
tail = slow(m, rest, stop, es, stopst);
|
|
if (tail == stop)
|
|
break; /* yes! */
|
|
/* no -- try a shorter match for this one */
|
|
stp = rest - 1;
|
|
assert(stp >= sp); /* it did work */
|
|
}
|
|
ssub = ss + 1;
|
|
esub = es - 1;
|
|
/* did innards match? */
|
|
if (slow(m, sp, rest, ssub, esub) != NULL) {
|
|
dp = dissect(m, sp, rest, ssub, esub);
|
|
assert(dp == rest);
|
|
} else /* no */
|
|
assert(sp == rest);
|
|
sp = rest;
|
|
break;
|
|
case OPLUS_:
|
|
stp = stop;
|
|
for (;;) {
|
|
/* how long could this one be? */
|
|
rest = slow(m, sp, stp, ss, es);
|
|
assert(rest != NULL); /* it did match */
|
|
/* could the rest match the rest? */
|
|
tail = slow(m, rest, stop, es, stopst);
|
|
if (tail == stop)
|
|
break; /* yes! */
|
|
/* no -- try a shorter match for this one */
|
|
stp = rest - 1;
|
|
assert(stp >= sp); /* it did work */
|
|
}
|
|
ssub = ss + 1;
|
|
esub = es - 1;
|
|
ssp = sp;
|
|
oldssp = ssp;
|
|
for (;;) { /* find last match of innards */
|
|
sep = slow(m, ssp, rest, ssub, esub);
|
|
if (sep == NULL || sep == ssp)
|
|
break; /* failed or matched null */
|
|
oldssp = ssp; /* on to next try */
|
|
ssp = sep;
|
|
}
|
|
if (sep == NULL) {
|
|
/* last successful match */
|
|
sep = ssp;
|
|
ssp = oldssp;
|
|
}
|
|
assert(sep == rest); /* must exhaust substring */
|
|
assert(slow(m, ssp, sep, ssub, esub) == rest);
|
|
dp = dissect(m, ssp, sep, ssub, esub);
|
|
assert(dp == sep);
|
|
sp = rest;
|
|
break;
|
|
case OCH_:
|
|
stp = stop;
|
|
for (;;) {
|
|
/* how long could this one be? */
|
|
rest = slow(m, sp, stp, ss, es);
|
|
assert(rest != NULL); /* it did match */
|
|
/* could the rest match the rest? */
|
|
tail = slow(m, rest, stop, es, stopst);
|
|
if (tail == stop)
|
|
break; /* yes! */
|
|
/* no -- try a shorter match for this one */
|
|
stp = rest - 1;
|
|
assert(stp >= sp); /* it did work */
|
|
}
|
|
ssub = ss + 1;
|
|
esub = ss + OPND(m->g->strip[ss]) - 1;
|
|
assert(OP(m->g->strip[esub]) == OOR1);
|
|
for (;;) { /* find first matching branch */
|
|
if (slow(m, sp, rest, ssub, esub) == rest)
|
|
break; /* it matched all of it */
|
|
/* that one missed, try next one */
|
|
assert(OP(m->g->strip[esub]) == OOR1);
|
|
esub++;
|
|
assert(OP(m->g->strip[esub]) == OOR2);
|
|
ssub = esub + 1;
|
|
esub += OPND(m->g->strip[esub]);
|
|
if (OP(m->g->strip[esub]) == OOR2)
|
|
esub--;
|
|
else
|
|
assert(OP(m->g->strip[esub]) == O_CH);
|
|
}
|
|
dp = dissect(m, sp, rest, ssub, esub);
|
|
assert(dp == rest);
|
|
sp = rest;
|
|
break;
|
|
case O_PLUS:
|
|
case O_QUEST:
|
|
case OOR1:
|
|
case OOR2:
|
|
case O_CH:
|
|
assert(nope);
|
|
break;
|
|
case OLPAREN:
|
|
i = OPND(m->g->strip[ss]);
|
|
assert(0 < i && i <= m->g->nsub);
|
|
m->pmatch[i].rm_so = sp - m->offp;
|
|
break;
|
|
case ORPAREN:
|
|
i = OPND(m->g->strip[ss]);
|
|
assert(0 < i && i <= m->g->nsub);
|
|
m->pmatch[i].rm_eo = sp - m->offp;
|
|
break;
|
|
default: /* uh oh */
|
|
assert(nope);
|
|
break;
|
|
}
|
|
}
|
|
|
|
assert(sp == stop);
|
|
return(sp);
|
|
}
|
|
|
|
/*
|
|
- backref - figure out what matched what, figuring in back references
|
|
== static char *backref(register struct match *m, char *start, \
|
|
== char *stop, sopno startst, sopno stopst, sopno lev);
|
|
*/
|
|
static char * /* == stop (success) or NULL (failure) */
|
|
backref(m, start, stop, startst, stopst, lev)
|
|
register struct match *m;
|
|
char *start;
|
|
char *stop;
|
|
sopno startst;
|
|
sopno stopst;
|
|
sopno lev; /* PLUS nesting level */
|
|
{
|
|
register int i;
|
|
register sopno ss; /* start sop of current subRE */
|
|
register char *sp; /* start of string matched by it */
|
|
register sopno ssub; /* start sop of subsubRE */
|
|
register sopno esub; /* end sop of subsubRE */
|
|
register char *ssp; /* start of string matched by subsubRE */
|
|
register char *dp;
|
|
register size_t len;
|
|
register int hard;
|
|
register sop s;
|
|
register regoff_t offsave;
|
|
register cset *cs;
|
|
|
|
AT("back", start, stop, startst, stopst);
|
|
sp = start;
|
|
|
|
/* get as far as we can with easy stuff */
|
|
hard = 0;
|
|
for (ss = startst; !hard && ss < stopst; ss++)
|
|
switch (OP(s = m->g->strip[ss])) {
|
|
case OCHAR:
|
|
if (sp == stop || *sp++ != (char)OPND(s))
|
|
return(NULL);
|
|
break;
|
|
case OANY:
|
|
if (sp == stop)
|
|
return(NULL);
|
|
sp++;
|
|
break;
|
|
case OANYOF:
|
|
cs = &m->g->sets[OPND(s)];
|
|
if (sp == stop || !CHIN(cs, *sp++))
|
|
return(NULL);
|
|
break;
|
|
case OBOL:
|
|
if ( (sp == m->beginp && !(m->eflags®_NOTBOL)) ||
|
|
(sp < m->endp && *(sp-1) == '\n' &&
|
|
(m->g->cflags®_NEWLINE)) )
|
|
{ /* yes */ }
|
|
else
|
|
return(NULL);
|
|
break;
|
|
case OEOL:
|
|
if ( (sp == m->endp && !(m->eflags®_NOTEOL)) ||
|
|
(sp < m->endp && *sp == '\n' &&
|
|
(m->g->cflags®_NEWLINE)) )
|
|
{ /* yes */ }
|
|
else
|
|
return(NULL);
|
|
break;
|
|
case OBOW:
|
|
if (( (sp == m->beginp && !(m->eflags®_NOTBOL)) ||
|
|
(sp < m->endp && *(sp-1) == '\n' &&
|
|
(m->g->cflags®_NEWLINE)) ||
|
|
(sp > m->beginp &&
|
|
!ISWORD(*(sp-1))) ) &&
|
|
(sp < m->endp && ISWORD(*sp)) )
|
|
{ /* yes */ }
|
|
else
|
|
return(NULL);
|
|
break;
|
|
case OEOW:
|
|
if (( (sp == m->endp && !(m->eflags®_NOTEOL)) ||
|
|
(sp < m->endp && *sp == '\n' &&
|
|
(m->g->cflags®_NEWLINE)) ||
|
|
(sp < m->endp && !ISWORD(*sp)) ) &&
|
|
(sp > m->beginp && ISWORD(*(sp-1))) )
|
|
{ /* yes */ }
|
|
else
|
|
return(NULL);
|
|
break;
|
|
case O_QUEST:
|
|
break;
|
|
case OOR1: /* matches null but needs to skip */
|
|
ss++;
|
|
s = m->g->strip[ss];
|
|
do {
|
|
assert(OP(s) == OOR2);
|
|
ss += OPND(s);
|
|
} while (OP(s = m->g->strip[ss]) != O_CH);
|
|
/* note that the ss++ gets us past the O_CH */
|
|
break;
|
|
default: /* have to make a choice */
|
|
hard = 1;
|
|
break;
|
|
}
|
|
if (!hard) { /* that was it! */
|
|
if (sp != stop)
|
|
return(NULL);
|
|
return(sp);
|
|
}
|
|
ss--; /* adjust for the for's final increment */
|
|
|
|
/* the hard stuff */
|
|
AT("hard", sp, stop, ss, stopst);
|
|
s = m->g->strip[ss];
|
|
switch (OP(s)) {
|
|
case OBACK_: /* the vilest depths */
|
|
i = OPND(s);
|
|
assert(0 < i && i <= m->g->nsub);
|
|
if (m->pmatch[i].rm_eo == -1)
|
|
return(NULL);
|
|
assert(m->pmatch[i].rm_so != -1);
|
|
len = m->pmatch[i].rm_eo - m->pmatch[i].rm_so;
|
|
assert(stop - m->beginp >= len);
|
|
if (sp > stop - len)
|
|
return(NULL); /* not enough left to match */
|
|
ssp = m->offp + m->pmatch[i].rm_so;
|
|
if (memcmp(sp, ssp, len) != 0)
|
|
return(NULL);
|
|
while (m->g->strip[ss] != SOP(O_BACK, i))
|
|
ss++;
|
|
return(backref(m, sp+len, stop, ss+1, stopst, lev));
|
|
break;
|
|
case OQUEST_: /* to null or not */
|
|
dp = backref(m, sp, stop, ss+1, stopst, lev);
|
|
if (dp != NULL)
|
|
return(dp); /* not */
|
|
return(backref(m, sp, stop, ss+OPND(s)+1, stopst, lev));
|
|
break;
|
|
case OPLUS_:
|
|
assert(m->lastpos != NULL);
|
|
assert(lev+1 <= m->g->nplus);
|
|
m->lastpos[lev+1] = sp;
|
|
return(backref(m, sp, stop, ss+1, stopst, lev+1));
|
|
break;
|
|
case O_PLUS:
|
|
if (sp == m->lastpos[lev]) /* last pass matched null */
|
|
return(backref(m, sp, stop, ss+1, stopst, lev-1));
|
|
/* try another pass */
|
|
m->lastpos[lev] = sp;
|
|
dp = backref(m, sp, stop, ss-OPND(s)+1, stopst, lev);
|
|
if (dp == NULL)
|
|
return(backref(m, sp, stop, ss+1, stopst, lev-1));
|
|
else
|
|
return(dp);
|
|
break;
|
|
case OCH_: /* find the right one, if any */
|
|
ssub = ss + 1;
|
|
esub = ss + OPND(s) - 1;
|
|
assert(OP(m->g->strip[esub]) == OOR1);
|
|
for (;;) { /* find first matching branch */
|
|
dp = backref(m, sp, stop, ssub, esub, lev);
|
|
if (dp != NULL)
|
|
return(dp);
|
|
/* that one missed, try next one */
|
|
if (OP(m->g->strip[esub]) == O_CH)
|
|
return(NULL); /* there is none */
|
|
esub++;
|
|
assert(OP(m->g->strip[esub]) == OOR2);
|
|
ssub = esub + 1;
|
|
esub += OPND(m->g->strip[esub]);
|
|
if (OP(m->g->strip[esub]) == OOR2)
|
|
esub--;
|
|
else
|
|
assert(OP(m->g->strip[esub]) == O_CH);
|
|
}
|
|
break;
|
|
case OLPAREN: /* must undo assignment if rest fails */
|
|
i = OPND(s);
|
|
assert(0 < i && i <= m->g->nsub);
|
|
offsave = m->pmatch[i].rm_so;
|
|
m->pmatch[i].rm_so = sp - m->offp;
|
|
dp = backref(m, sp, stop, ss+1, stopst, lev);
|
|
if (dp != NULL)
|
|
return(dp);
|
|
m->pmatch[i].rm_so = offsave;
|
|
return(NULL);
|
|
break;
|
|
case ORPAREN: /* must undo assignment if rest fails */
|
|
i = OPND(s);
|
|
assert(0 < i && i <= m->g->nsub);
|
|
offsave = m->pmatch[i].rm_eo;
|
|
m->pmatch[i].rm_eo = sp - m->offp;
|
|
dp = backref(m, sp, stop, ss+1, stopst, lev);
|
|
if (dp != NULL)
|
|
return(dp);
|
|
m->pmatch[i].rm_eo = offsave;
|
|
return(NULL);
|
|
break;
|
|
default: /* uh oh */
|
|
assert(nope);
|
|
break;
|
|
}
|
|
|
|
/* "can't happen" */
|
|
assert(nope);
|
|
/* NOTREACHED */
|
|
return((char *)NULL); /* dummy */
|
|
}
|
|
|
|
/*
|
|
- fast - step through the string at top speed
|
|
== static char *fast(register struct match *m, char *start, \
|
|
== char *stop, sopno startst, sopno stopst);
|
|
*/
|
|
static char * /* where tentative match ended, or NULL */
|
|
fast(m, start, stop, startst, stopst)
|
|
register struct match *m;
|
|
char *start;
|
|
char *stop;
|
|
sopno startst;
|
|
sopno stopst;
|
|
{
|
|
register states st = m->st;
|
|
register states fresh = m->fresh;
|
|
register states tmp = m->tmp;
|
|
register char *p = start;
|
|
register int c = (start == m->beginp) ? OUT : *(start-1);
|
|
register int lastc; /* previous c */
|
|
register int flagch;
|
|
register int i;
|
|
register char *coldp; /* last p after which no match was underway */
|
|
|
|
CLEAR(st);
|
|
SET1(st, startst);
|
|
st = step(m->g, startst, stopst, st, NOTHING, st);
|
|
ASSIGN(fresh, st);
|
|
SP("start", st, *p);
|
|
coldp = NULL;
|
|
for (;;) {
|
|
/* next character */
|
|
lastc = c;
|
|
c = (p == m->endp) ? OUT : *p;
|
|
if (EQ(st, fresh))
|
|
coldp = p;
|
|
|
|
/* is there an EOL and/or BOL between lastc and c? */
|
|
flagch = '\0';
|
|
i = 0;
|
|
if ( (lastc == '\n' && m->g->cflags®_NEWLINE) ||
|
|
(lastc == OUT && !(m->eflags®_NOTBOL)) ) {
|
|
flagch = BOL;
|
|
i = m->g->nbol;
|
|
}
|
|
if ( (c == '\n' && m->g->cflags®_NEWLINE) ||
|
|
(c == OUT && !(m->eflags®_NOTEOL)) ) {
|
|
flagch = (flagch == BOL) ? BOLEOL : EOL;
|
|
i += m->g->neol;
|
|
}
|
|
if (i != 0) {
|
|
for (; i > 0; i--)
|
|
st = step(m->g, startst, stopst, st, flagch, st);
|
|
SP("boleol", st, c);
|
|
}
|
|
|
|
/* how about a word boundary? */
|
|
if ( (flagch == BOL || (lastc != OUT && !ISWORD(lastc))) &&
|
|
(c != OUT && ISWORD(c)) ) {
|
|
flagch = BOW;
|
|
}
|
|
if ( (lastc != OUT && ISWORD(lastc)) &&
|
|
(flagch == EOL || (c != OUT && !ISWORD(c))) ) {
|
|
flagch = EOW;
|
|
}
|
|
if (flagch == BOW || flagch == EOW) {
|
|
st = step(m->g, startst, stopst, st, flagch, st);
|
|
SP("boweow", st, c);
|
|
}
|
|
|
|
/* are we done? */
|
|
if (ISSET(st, stopst) || p == stop)
|
|
break; /* NOTE BREAK OUT */
|
|
|
|
/* no, we must deal with this character */
|
|
ASSIGN(tmp, st);
|
|
ASSIGN(st, fresh);
|
|
assert(c != OUT);
|
|
st = step(m->g, startst, stopst, tmp, c, st);
|
|
SP("aft", st, c);
|
|
assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st));
|
|
p++;
|
|
}
|
|
|
|
assert(coldp != NULL);
|
|
m->coldp = coldp;
|
|
if (ISSET(st, stopst))
|
|
return(p+1);
|
|
else
|
|
return(NULL);
|
|
}
|
|
|
|
/*
|
|
- slow - step through the string more deliberately
|
|
== static char *slow(register struct match *m, char *start, \
|
|
== char *stop, sopno startst, sopno stopst);
|
|
*/
|
|
static char * /* where it ended */
|
|
slow(m, start, stop, startst, stopst)
|
|
register struct match *m;
|
|
char *start;
|
|
char *stop;
|
|
sopno startst;
|
|
sopno stopst;
|
|
{
|
|
register states st = m->st;
|
|
register states empty = m->empty;
|
|
register states tmp = m->tmp;
|
|
register char *p = start;
|
|
register int c = (start == m->beginp) ? OUT : *(start-1);
|
|
register int lastc; /* previous c */
|
|
register int flagch;
|
|
register int i;
|
|
register char *matchp; /* last p at which a match ended */
|
|
|
|
AT("slow", start, stop, startst, stopst);
|
|
CLEAR(st);
|
|
SET1(st, startst);
|
|
SP("sstart", st, *p);
|
|
st = step(m->g, startst, stopst, st, NOTHING, st);
|
|
matchp = NULL;
|
|
for (;;) {
|
|
/* next character */
|
|
lastc = c;
|
|
c = (p == m->endp) ? OUT : *p;
|
|
|
|
/* is there an EOL and/or BOL between lastc and c? */
|
|
flagch = '\0';
|
|
i = 0;
|
|
if ( (lastc == '\n' && m->g->cflags®_NEWLINE) ||
|
|
(lastc == OUT && !(m->eflags®_NOTBOL)) ) {
|
|
flagch = BOL;
|
|
i = m->g->nbol;
|
|
}
|
|
if ( (c == '\n' && m->g->cflags®_NEWLINE) ||
|
|
(c == OUT && !(m->eflags®_NOTEOL)) ) {
|
|
flagch = (flagch == BOL) ? BOLEOL : EOL;
|
|
i += m->g->neol;
|
|
}
|
|
if (i != 0) {
|
|
for (; i > 0; i--)
|
|
st = step(m->g, startst, stopst, st, flagch, st);
|
|
SP("sboleol", st, c);
|
|
}
|
|
|
|
/* how about a word boundary? */
|
|
if ( (flagch == BOL || (lastc != OUT && !ISWORD(lastc))) &&
|
|
(c != OUT && ISWORD(c)) ) {
|
|
flagch = BOW;
|
|
}
|
|
if ( (lastc != OUT && ISWORD(lastc)) &&
|
|
(flagch == EOL || (c != OUT && !ISWORD(c))) ) {
|
|
flagch = EOW;
|
|
}
|
|
if (flagch == BOW || flagch == EOW) {
|
|
st = step(m->g, startst, stopst, st, flagch, st);
|
|
SP("sboweow", st, c);
|
|
}
|
|
|
|
/* are we done? */
|
|
if (ISSET(st, stopst))
|
|
matchp = p;
|
|
if (EQ(st, empty) || p == stop)
|
|
break; /* NOTE BREAK OUT */
|
|
|
|
/* no, we must deal with this character */
|
|
ASSIGN(tmp, st);
|
|
ASSIGN(st, empty);
|
|
assert(c != OUT);
|
|
st = step(m->g, startst, stopst, tmp, c, st);
|
|
SP("saft", st, c);
|
|
assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st));
|
|
p++;
|
|
}
|
|
|
|
return(matchp);
|
|
}
|
|
|
|
|
|
/*
|
|
- step - map set of states reachable before char to set reachable after
|
|
== static states step(register struct re_guts *g, sopno start, sopno stop, \
|
|
== register states bef, int ch, register states aft);
|
|
== #define BOL (OUT+1)
|
|
== #define EOL (BOL+1)
|
|
== #define BOLEOL (BOL+2)
|
|
== #define NOTHING (BOL+3)
|
|
== #define BOW (BOL+4)
|
|
== #define EOW (BOL+5)
|
|
== #define CODEMAX (BOL+5) // highest code used
|
|
== #define NONCHAR(c) ((c) > CHAR_MAX)
|
|
== #define NNONCHAR (CODEMAX-CHAR_MAX)
|
|
*/
|
|
static states
|
|
step(g, start, stop, bef, ch, aft)
|
|
register struct re_guts *g;
|
|
sopno start; /* start state within strip */
|
|
sopno stop; /* state after stop state within strip */
|
|
register states bef; /* states reachable before */
|
|
int ch; /* character or NONCHAR code */
|
|
register states aft; /* states already known reachable after */
|
|
{
|
|
register cset *cs;
|
|
register sop s;
|
|
register sopno pc;
|
|
register onestate here; /* note, macros know this name */
|
|
register sopno look;
|
|
register long i;
|
|
|
|
for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) {
|
|
s = g->strip[pc];
|
|
switch (OP(s)) {
|
|
case OEND:
|
|
assert(pc == stop-1);
|
|
break;
|
|
case OCHAR:
|
|
/* only characters can match */
|
|
assert(!NONCHAR(ch) || ch != (char)OPND(s));
|
|
if (ch == (char)OPND(s))
|
|
FWD(aft, bef, 1);
|
|
break;
|
|
case OBOL:
|
|
if (ch == BOL || ch == BOLEOL)
|
|
FWD(aft, bef, 1);
|
|
break;
|
|
case OEOL:
|
|
if (ch == EOL || ch == BOLEOL)
|
|
FWD(aft, bef, 1);
|
|
break;
|
|
case OBOW:
|
|
if (ch == BOW)
|
|
FWD(aft, bef, 1);
|
|
break;
|
|
case OEOW:
|
|
if (ch == EOW)
|
|
FWD(aft, bef, 1);
|
|
break;
|
|
case OANY:
|
|
if (!NONCHAR(ch))
|
|
FWD(aft, bef, 1);
|
|
break;
|
|
case OANYOF:
|
|
cs = &g->sets[OPND(s)];
|
|
if (!NONCHAR(ch) && CHIN(cs, ch))
|
|
FWD(aft, bef, 1);
|
|
break;
|
|
case OBACK_: /* ignored here */
|
|
case O_BACK:
|
|
FWD(aft, aft, 1);
|
|
break;
|
|
case OPLUS_: /* forward, this is just an empty */
|
|
FWD(aft, aft, 1);
|
|
break;
|
|
case O_PLUS: /* both forward and back */
|
|
FWD(aft, aft, 1);
|
|
i = ISSETBACK(aft, OPND(s));
|
|
BACK(aft, aft, OPND(s));
|
|
if (!i && ISSETBACK(aft, OPND(s))) {
|
|
/* oho, must reconsider loop body */
|
|
pc -= OPND(s) + 1;
|
|
INIT(here, pc);
|
|
}
|
|
break;
|
|
case OQUEST_: /* two branches, both forward */
|
|
FWD(aft, aft, 1);
|
|
FWD(aft, aft, OPND(s));
|
|
break;
|
|
case O_QUEST: /* just an empty */
|
|
FWD(aft, aft, 1);
|
|
break;
|
|
case OLPAREN: /* not significant here */
|
|
case ORPAREN:
|
|
FWD(aft, aft, 1);
|
|
break;
|
|
case OCH_: /* mark the first two branches */
|
|
FWD(aft, aft, 1);
|
|
assert(OP(g->strip[pc+OPND(s)]) == OOR2);
|
|
FWD(aft, aft, OPND(s));
|
|
break;
|
|
case OOR1: /* done a branch, find the O_CH */
|
|
if (ISSTATEIN(aft, here)) {
|
|
for (look = 1;
|
|
OP(s = g->strip[pc+look]) != O_CH;
|
|
look += OPND(s))
|
|
assert(OP(s) == OOR2);
|
|
FWD(aft, aft, look);
|
|
}
|
|
break;
|
|
case OOR2: /* propagate OCH_'s marking */
|
|
FWD(aft, aft, 1);
|
|
if (OP(g->strip[pc+OPND(s)]) != O_CH) {
|
|
assert(OP(g->strip[pc+OPND(s)]) == OOR2);
|
|
FWD(aft, aft, OPND(s));
|
|
}
|
|
break;
|
|
case O_CH: /* just empty */
|
|
FWD(aft, aft, 1);
|
|
break;
|
|
default: /* ooooops... */
|
|
assert(nope);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return(aft);
|
|
}
|
|
|
|
#undef matcher
|
|
#undef fast
|
|
#undef slow
|
|
#undef dissect
|
|
#undef backref
|
|
#undef step
|
|
#undef print
|
|
#undef at
|
|
#undef match
|
|
|
|
/* now undo things */
|
|
#undef states
|
|
#undef CLEAR
|
|
#undef SET0
|
|
#undef SET1
|
|
#undef ISSET
|
|
#undef ASSIGN
|
|
#undef EQ
|
|
#undef STATEVARS
|
|
#undef STATESETUP
|
|
#undef STATETEARDOWN
|
|
#undef SETUP
|
|
#undef onestate
|
|
#undef INIT
|
|
#undef INC
|
|
#undef ISSTATEIN
|
|
#undef FWD
|
|
#undef BACK
|
|
#undef ISSETBACK
|
|
#undef SNAMES
|
|
|
|
/* macros for manipulating states, large version */
|
|
#define states char *
|
|
#define CLEAR(v) memset(v, 0, m->g->nstates)
|
|
#define SET0(v, n) ((v)[n] = 0)
|
|
#define SET1(v, n) ((v)[n] = 1)
|
|
#define ISSET(v, n) ((v)[n])
|
|
#define ASSIGN(d, s) memcpy(d, s, m->g->nstates)
|
|
#define EQ(a, b) (memcmp(a, b, m->g->nstates) == 0)
|
|
#define STATEVARS int vn; char *space
|
|
#define STATESETUP(m, nv) { (m)->space = malloc((nv)*(m)->g->nstates); \
|
|
if ((m)->space == NULL) return(REG_ESPACE); \
|
|
(m)->vn = 0; }
|
|
#define STATETEARDOWN(m) { free((m)->space); }
|
|
#define SETUP(v) ((v) = &m->space[m->vn++ * m->g->nstates])
|
|
#define onestate int
|
|
#define INIT(o, n) ((o) = (n))
|
|
#define INC(o) ((o)++)
|
|
#define ISSTATEIN(v, o) ((v)[o])
|
|
/* some abbreviations; note that some of these know variable names! */
|
|
/* do "if I'm here, I can also be there" etc without branches */
|
|
#define FWD(dst, src, n) ((dst)[here+(n)] |= (src)[here])
|
|
#define BACK(dst, src, n) ((dst)[here-(n)] |= (src)[here])
|
|
#define ISSETBACK(v, n) ((v)[here - (n)])
|
|
/* function names */
|
|
#define LNAMES /* flag */
|
|
|
|
/*
|
|
* The matching engine and friends. This file is #included by regexec.c
|
|
* after suitable #defines of a variety of macros used herein, so that
|
|
* different state representations can be used without duplicating masses
|
|
* of code.
|
|
*/
|
|
|
|
#ifdef SNAMES
|
|
#define matcher smatcher
|
|
#define fast sfast
|
|
#define slow sslow
|
|
#define dissect sdissect
|
|
#define backref sbackref
|
|
#define step sstep
|
|
#define print sprint
|
|
#define at sat
|
|
#define match smat
|
|
#endif
|
|
#ifdef LNAMES
|
|
#define matcher lmatcher
|
|
#define fast lfast
|
|
#define slow lslow
|
|
#define dissect ldissect
|
|
#define backref lbackref
|
|
#define step lstep
|
|
#define print lprint
|
|
#define at lat
|
|
#define match lmat
|
|
#endif
|
|
|
|
/* another structure passed up and down to avoid zillions of parameters */
|
|
struct match {
|
|
struct re_guts *g;
|
|
int eflags;
|
|
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] */
|
|
STATEVARS;
|
|
states st; /* current states */
|
|
states fresh; /* states for a fresh start */
|
|
states tmp; /* temporary */
|
|
states empty; /* empty set of states */
|
|
};
|
|
|
|
static int matcher(register struct re_guts *g, char *string, size_t nmatch, regmatch_t pmatch[], int eflags);
|
|
static char *dissect(register struct match *m, char *start, char *stop, sopno startst, sopno stopst);
|
|
static char *backref(register struct match *m, char *start, char *stop, sopno startst, sopno stopst, sopno lev);
|
|
static char *fast(register struct match *m, char *start, char *stop, sopno startst, sopno stopst);
|
|
static char *slow(register struct match *m, char *start, char *stop, sopno startst, sopno stopst);
|
|
static states step(register struct re_guts *g, sopno start, sopno stop, register states bef, int ch, register states aft);
|
|
#define BOL (OUT+1)
|
|
#define EOL (BOL+1)
|
|
#define BOLEOL (BOL+2)
|
|
#define NOTHING (BOL+3)
|
|
#define BOW (BOL+4)
|
|
#define EOW (BOL+5)
|
|
#define CODEMAX (BOL+5) /* highest code used */
|
|
#define NONCHAR(c) ((c) > CHAR_MAX)
|
|
#define NNONCHAR (CODEMAX-CHAR_MAX)
|
|
#define SP(t, s, c) /* nothing */
|
|
#define AT(t, p1, p2, s1, s2) /* nothing */
|
|
#define NOTE(s) /* nothing */
|
|
|
|
/*
|
|
- matcher - the actual matching engine
|
|
== static int matcher(register struct re_guts *g, char *string, \
|
|
== size_t nmatch, regmatch_t pmatch[], int eflags);
|
|
*/
|
|
static int /* 0 success, REG_NOMATCH failure */
|
|
matcher(g, string, nmatch, pmatch, eflags)
|
|
register struct re_guts *g;
|
|
char *string;
|
|
size_t nmatch;
|
|
regmatch_t pmatch[];
|
|
int eflags;
|
|
{
|
|
register char *endp;
|
|
register int i;
|
|
struct match mv;
|
|
register struct match *m = &mv;
|
|
register char *dp;
|
|
const register sopno gf = g->firststate+1; /* +1 for OEND */
|
|
const register sopno gl = g->laststate;
|
|
char *start;
|
|
char *stop;
|
|
|
|
/* simplify the situation where possible */
|
|
if (g->cflags®_NOSUB)
|
|
nmatch = 0;
|
|
if (eflags®_STARTEND) {
|
|
start = string + pmatch[0].rm_so;
|
|
stop = string + pmatch[0].rm_eo;
|
|
} else {
|
|
start = string;
|
|
stop = start + strlen(start);
|
|
}
|
|
if (stop < start)
|
|
return(REG_INVARG);
|
|
|
|
/* prescreening; this does wonders for this rather slow code */
|
|
if (g->must != NULL) {
|
|
for (dp = start; dp < stop; dp++)
|
|
if (*dp == g->must[0] && stop - dp >= g->mlen &&
|
|
memcmp(dp, g->must, (size_t)g->mlen) == 0)
|
|
break;
|
|
if (dp == stop) /* we didn't find g->must */
|
|
return(REG_NOMATCH);
|
|
}
|
|
|
|
/* match struct setup */
|
|
m->g = g;
|
|
m->eflags = eflags;
|
|
m->pmatch = NULL;
|
|
m->lastpos = NULL;
|
|
m->offp = string;
|
|
m->beginp = start;
|
|
m->endp = stop;
|
|
STATESETUP(m, 4);
|
|
SETUP(m->st);
|
|
SETUP(m->fresh);
|
|
SETUP(m->tmp);
|
|
SETUP(m->empty);
|
|
CLEAR(m->empty);
|
|
|
|
/* this loop does only one repetition except for backrefs */
|
|
for (;;) {
|
|
endp = fast(m, start, stop, gf, gl);
|
|
if (endp == NULL) { /* a miss */
|
|
STATETEARDOWN(m);
|
|
return(REG_NOMATCH);
|
|
}
|
|
if (nmatch == 0 && !g->backrefs)
|
|
break; /* no further info needed */
|
|
|
|
/* where? */
|
|
assert(m->coldp != NULL);
|
|
for (;;) {
|
|
NOTE("finding start");
|
|
endp = slow(m, m->coldp, stop, gf, gl);
|
|
if (endp != NULL)
|
|
break;
|
|
assert(m->coldp < m->endp);
|
|
m->coldp++;
|
|
}
|
|
if (nmatch == 1 && !g->backrefs)
|
|
break; /* no further info needed */
|
|
|
|
/* oh my, he wants the subexpressions... */
|
|
if (m->pmatch == NULL)
|
|
m->pmatch = (regmatch_t *)malloc((m->g->nsub + 1) *
|
|
sizeof(regmatch_t));
|
|
if (m->pmatch == NULL) {
|
|
STATETEARDOWN(m);
|
|
return(REG_ESPACE);
|
|
}
|
|
for (i = 1; i <= m->g->nsub; i++)
|
|
m->pmatch[i].rm_so = m->pmatch[i].rm_eo = -1;
|
|
if (!g->backrefs && !(m->eflags®_BACKR)) {
|
|
NOTE("dissecting");
|
|
dp = dissect(m, m->coldp, endp, gf, gl);
|
|
} else {
|
|
if (g->nplus > 0 && m->lastpos == NULL)
|
|
m->lastpos = (char **)malloc((g->nplus+1) *
|
|
sizeof(char *));
|
|
if (g->nplus > 0 && m->lastpos == NULL) {
|
|
free(m->pmatch);
|
|
STATETEARDOWN(m);
|
|
return(REG_ESPACE);
|
|
}
|
|
NOTE("backref dissect");
|
|
dp = backref(m, m->coldp, endp, gf, gl, (sopno)0);
|
|
}
|
|
if (dp != NULL)
|
|
break;
|
|
|
|
/* uh-oh... we couldn't find a subexpression-level match */
|
|
assert(g->backrefs); /* must be back references doing it */
|
|
assert(g->nplus == 0 || m->lastpos != NULL);
|
|
for (;;) {
|
|
if (dp != NULL || endp <= m->coldp)
|
|
break; /* defeat */
|
|
NOTE("backoff");
|
|
endp = slow(m, m->coldp, endp-1, gf, gl);
|
|
if (endp == NULL)
|
|
break; /* defeat */
|
|
/* try it on a shorter possibility */
|
|
NOTE("backoff dissect");
|
|
dp = backref(m, m->coldp, endp, gf, gl, (sopno)0);
|
|
}
|
|
assert(dp == NULL || dp == endp);
|
|
if (dp != NULL) /* found a shorter one */
|
|
break;
|
|
|
|
/* despite initial appearances, there is no match here */
|
|
NOTE("false alarm");
|
|
start = m->coldp + 1; /* recycle starting later */
|
|
assert(start <= stop);
|
|
}
|
|
|
|
/* fill in the details if requested */
|
|
if (nmatch > 0) {
|
|
pmatch[0].rm_so = m->coldp - m->offp;
|
|
pmatch[0].rm_eo = endp - m->offp;
|
|
}
|
|
if (nmatch > 1) {
|
|
assert(m->pmatch != NULL);
|
|
for (i = 1; i < nmatch; i++)
|
|
if (i <= m->g->nsub)
|
|
pmatch[i] = m->pmatch[i];
|
|
else {
|
|
pmatch[i].rm_so = -1;
|
|
pmatch[i].rm_eo = -1;
|
|
}
|
|
}
|
|
|
|
if (m->pmatch != NULL)
|
|
free((char *)m->pmatch);
|
|
if (m->lastpos != NULL)
|
|
free((char *)m->lastpos);
|
|
STATETEARDOWN(m);
|
|
return(0);
|
|
}
|
|
|
|
/*
|
|
- dissect - figure out what matched what, no back references
|
|
== static char *dissect(register struct match *m, char *start, \
|
|
== char *stop, sopno startst, sopno stopst);
|
|
*/
|
|
static char * /* == stop (success) always */
|
|
dissect(m, start, stop, startst, stopst)
|
|
register struct match *m;
|
|
char *start;
|
|
char *stop;
|
|
sopno startst;
|
|
sopno stopst;
|
|
{
|
|
register int i;
|
|
register sopno ss; /* start sop of current subRE */
|
|
register sopno es; /* end sop of current subRE */
|
|
register char *sp; /* start of string matched by it */
|
|
register char *stp; /* string matched by it cannot pass here */
|
|
register char *rest; /* start of rest of string */
|
|
register char *tail; /* string unmatched by rest of RE */
|
|
register sopno ssub; /* start sop of subsubRE */
|
|
register sopno esub; /* end sop of subsubRE */
|
|
register char *ssp; /* start of string matched by subsubRE */
|
|
register char *sep; /* end of string matched by subsubRE */
|
|
register char *oldssp; /* previous ssp */
|
|
register char *dp;
|
|
|
|
AT("diss", start, stop, startst, stopst);
|
|
sp = start;
|
|
for (ss = startst; ss < stopst; ss = es) {
|
|
/* identify end of subRE */
|
|
es = ss;
|
|
switch (OP(m->g->strip[es])) {
|
|
case OPLUS_:
|
|
case OQUEST_:
|
|
es += OPND(m->g->strip[es]);
|
|
break;
|
|
case OCH_:
|
|
while (OP(m->g->strip[es]) != O_CH)
|
|
es += OPND(m->g->strip[es]);
|
|
break;
|
|
}
|
|
es++;
|
|
|
|
/* figure out what it matched */
|
|
switch (OP(m->g->strip[ss])) {
|
|
case OEND:
|
|
assert(nope);
|
|
break;
|
|
case OCHAR:
|
|
sp++;
|
|
break;
|
|
case OBOL:
|
|
case OEOL:
|
|
case OBOW:
|
|
case OEOW:
|
|
break;
|
|
case OANY:
|
|
case OANYOF:
|
|
sp++;
|
|
break;
|
|
case OBACK_:
|
|
case O_BACK:
|
|
assert(nope);
|
|
break;
|
|
/* cases where length of match is hard to find */
|
|
case OQUEST_:
|
|
stp = stop;
|
|
for (;;) {
|
|
/* how long could this one be? */
|
|
rest = slow(m, sp, stp, ss, es);
|
|
assert(rest != NULL); /* it did match */
|
|
/* could the rest match the rest? */
|
|
tail = slow(m, rest, stop, es, stopst);
|
|
if (tail == stop)
|
|
break; /* yes! */
|
|
/* no -- try a shorter match for this one */
|
|
stp = rest - 1;
|
|
assert(stp >= sp); /* it did work */
|
|
}
|
|
ssub = ss + 1;
|
|
esub = es - 1;
|
|
/* did innards match? */
|
|
if (slow(m, sp, rest, ssub, esub) != NULL) {
|
|
dp = dissect(m, sp, rest, ssub, esub);
|
|
assert(dp == rest);
|
|
} else /* no */
|
|
assert(sp == rest);
|
|
sp = rest;
|
|
break;
|
|
case OPLUS_:
|
|
stp = stop;
|
|
for (;;) {
|
|
/* how long could this one be? */
|
|
rest = slow(m, sp, stp, ss, es);
|
|
assert(rest != NULL); /* it did match */
|
|
/* could the rest match the rest? */
|
|
tail = slow(m, rest, stop, es, stopst);
|
|
if (tail == stop)
|
|
break; /* yes! */
|
|
/* no -- try a shorter match for this one */
|
|
stp = rest - 1;
|
|
assert(stp >= sp); /* it did work */
|
|
}
|
|
ssub = ss + 1;
|
|
esub = es - 1;
|
|
ssp = sp;
|
|
oldssp = ssp;
|
|
for (;;) { /* find last match of innards */
|
|
sep = slow(m, ssp, rest, ssub, esub);
|
|
if (sep == NULL || sep == ssp)
|
|
break; /* failed or matched null */
|
|
oldssp = ssp; /* on to next try */
|
|
ssp = sep;
|
|
}
|
|
if (sep == NULL) {
|
|
/* last successful match */
|
|
sep = ssp;
|
|
ssp = oldssp;
|
|
}
|
|
assert(sep == rest); /* must exhaust substring */
|
|
assert(slow(m, ssp, sep, ssub, esub) == rest);
|
|
dp = dissect(m, ssp, sep, ssub, esub);
|
|
assert(dp == sep);
|
|
sp = rest;
|
|
break;
|
|
case OCH_:
|
|
stp = stop;
|
|
for (;;) {
|
|
/* how long could this one be? */
|
|
rest = slow(m, sp, stp, ss, es);
|
|
assert(rest != NULL); /* it did match */
|
|
/* could the rest match the rest? */
|
|
tail = slow(m, rest, stop, es, stopst);
|
|
if (tail == stop)
|
|
break; /* yes! */
|
|
/* no -- try a shorter match for this one */
|
|
stp = rest - 1;
|
|
assert(stp >= sp); /* it did work */
|
|
}
|
|
ssub = ss + 1;
|
|
esub = ss + OPND(m->g->strip[ss]) - 1;
|
|
assert(OP(m->g->strip[esub]) == OOR1);
|
|
for (;;) { /* find first matching branch */
|
|
if (slow(m, sp, rest, ssub, esub) == rest)
|
|
break; /* it matched all of it */
|
|
/* that one missed, try next one */
|
|
assert(OP(m->g->strip[esub]) == OOR1);
|
|
esub++;
|
|
assert(OP(m->g->strip[esub]) == OOR2);
|
|
ssub = esub + 1;
|
|
esub += OPND(m->g->strip[esub]);
|
|
if (OP(m->g->strip[esub]) == OOR2)
|
|
esub--;
|
|
else
|
|
assert(OP(m->g->strip[esub]) == O_CH);
|
|
}
|
|
dp = dissect(m, sp, rest, ssub, esub);
|
|
assert(dp == rest);
|
|
sp = rest;
|
|
break;
|
|
case O_PLUS:
|
|
case O_QUEST:
|
|
case OOR1:
|
|
case OOR2:
|
|
case O_CH:
|
|
assert(nope);
|
|
break;
|
|
case OLPAREN:
|
|
i = OPND(m->g->strip[ss]);
|
|
assert(0 < i && i <= m->g->nsub);
|
|
m->pmatch[i].rm_so = sp - m->offp;
|
|
break;
|
|
case ORPAREN:
|
|
i = OPND(m->g->strip[ss]);
|
|
assert(0 < i && i <= m->g->nsub);
|
|
m->pmatch[i].rm_eo = sp - m->offp;
|
|
break;
|
|
default: /* uh oh */
|
|
assert(nope);
|
|
break;
|
|
}
|
|
}
|
|
|
|
assert(sp == stop);
|
|
return(sp);
|
|
}
|
|
|
|
/*
|
|
- backref - figure out what matched what, figuring in back references
|
|
== static char *backref(register struct match *m, char *start, \
|
|
== char *stop, sopno startst, sopno stopst, sopno lev);
|
|
*/
|
|
static char * /* == stop (success) or NULL (failure) */
|
|
backref(m, start, stop, startst, stopst, lev)
|
|
register struct match *m;
|
|
char *start;
|
|
char *stop;
|
|
sopno startst;
|
|
sopno stopst;
|
|
sopno lev; /* PLUS nesting level */
|
|
{
|
|
register int i;
|
|
register sopno ss; /* start sop of current subRE */
|
|
register char *sp; /* start of string matched by it */
|
|
register sopno ssub; /* start sop of subsubRE */
|
|
register sopno esub; /* end sop of subsubRE */
|
|
register char *ssp; /* start of string matched by subsubRE */
|
|
register char *dp;
|
|
register size_t len;
|
|
register int hard;
|
|
register sop s;
|
|
register regoff_t offsave;
|
|
register cset *cs;
|
|
|
|
AT("back", start, stop, startst, stopst);
|
|
sp = start;
|
|
|
|
/* get as far as we can with easy stuff */
|
|
hard = 0;
|
|
for (ss = startst; !hard && ss < stopst; ss++)
|
|
switch (OP(s = m->g->strip[ss])) {
|
|
case OCHAR:
|
|
if (sp == stop || *sp++ != (char)OPND(s))
|
|
return(NULL);
|
|
break;
|
|
case OANY:
|
|
if (sp == stop)
|
|
return(NULL);
|
|
sp++;
|
|
break;
|
|
case OANYOF:
|
|
cs = &m->g->sets[OPND(s)];
|
|
if (sp == stop || !CHIN(cs, *sp++))
|
|
return(NULL);
|
|
break;
|
|
case OBOL:
|
|
if ( (sp == m->beginp && !(m->eflags®_NOTBOL)) ||
|
|
(sp < m->endp && *(sp-1) == '\n' &&
|
|
(m->g->cflags®_NEWLINE)) )
|
|
{ /* yes */ }
|
|
else
|
|
return(NULL);
|
|
break;
|
|
case OEOL:
|
|
if ( (sp == m->endp && !(m->eflags®_NOTEOL)) ||
|
|
(sp < m->endp && *sp == '\n' &&
|
|
(m->g->cflags®_NEWLINE)) )
|
|
{ /* yes */ }
|
|
else
|
|
return(NULL);
|
|
break;
|
|
case OBOW:
|
|
if (( (sp == m->beginp && !(m->eflags®_NOTBOL)) ||
|
|
(sp < m->endp && *(sp-1) == '\n' &&
|
|
(m->g->cflags®_NEWLINE)) ||
|
|
(sp > m->beginp &&
|
|
!ISWORD(*(sp-1))) ) &&
|
|
(sp < m->endp && ISWORD(*sp)) )
|
|
{ /* yes */ }
|
|
else
|
|
return(NULL);
|
|
break;
|
|
case OEOW:
|
|
if (( (sp == m->endp && !(m->eflags®_NOTEOL)) ||
|
|
(sp < m->endp && *sp == '\n' &&
|
|
(m->g->cflags®_NEWLINE)) ||
|
|
(sp < m->endp && !ISWORD(*sp)) ) &&
|
|
(sp > m->beginp && ISWORD(*(sp-1))) )
|
|
{ /* yes */ }
|
|
else
|
|
return(NULL);
|
|
break;
|
|
case O_QUEST:
|
|
break;
|
|
case OOR1: /* matches null but needs to skip */
|
|
ss++;
|
|
s = m->g->strip[ss];
|
|
do {
|
|
assert(OP(s) == OOR2);
|
|
ss += OPND(s);
|
|
} while (OP(s = m->g->strip[ss]) != O_CH);
|
|
/* note that the ss++ gets us past the O_CH */
|
|
break;
|
|
default: /* have to make a choice */
|
|
hard = 1;
|
|
break;
|
|
}
|
|
if (!hard) { /* that was it! */
|
|
if (sp != stop)
|
|
return(NULL);
|
|
return(sp);
|
|
}
|
|
ss--; /* adjust for the for's final increment */
|
|
|
|
/* the hard stuff */
|
|
AT("hard", sp, stop, ss, stopst);
|
|
s = m->g->strip[ss];
|
|
switch (OP(s)) {
|
|
case OBACK_: /* the vilest depths */
|
|
i = OPND(s);
|
|
assert(0 < i && i <= m->g->nsub);
|
|
if (m->pmatch[i].rm_eo == -1)
|
|
return(NULL);
|
|
assert(m->pmatch[i].rm_so != -1);
|
|
len = m->pmatch[i].rm_eo - m->pmatch[i].rm_so;
|
|
assert(stop - m->beginp >= len);
|
|
if (sp > stop - len)
|
|
return(NULL); /* not enough left to match */
|
|
ssp = m->offp + m->pmatch[i].rm_so;
|
|
if (memcmp(sp, ssp, len) != 0)
|
|
return(NULL);
|
|
while (m->g->strip[ss] != SOP(O_BACK, i))
|
|
ss++;
|
|
return(backref(m, sp+len, stop, ss+1, stopst, lev));
|
|
break;
|
|
case OQUEST_: /* to null or not */
|
|
dp = backref(m, sp, stop, ss+1, stopst, lev);
|
|
if (dp != NULL)
|
|
return(dp); /* not */
|
|
return(backref(m, sp, stop, ss+OPND(s)+1, stopst, lev));
|
|
break;
|
|
case OPLUS_:
|
|
assert(m->lastpos != NULL);
|
|
assert(lev+1 <= m->g->nplus);
|
|
m->lastpos[lev+1] = sp;
|
|
return(backref(m, sp, stop, ss+1, stopst, lev+1));
|
|
break;
|
|
case O_PLUS:
|
|
if (sp == m->lastpos[lev]) /* last pass matched null */
|
|
return(backref(m, sp, stop, ss+1, stopst, lev-1));
|
|
/* try another pass */
|
|
m->lastpos[lev] = sp;
|
|
dp = backref(m, sp, stop, ss-OPND(s)+1, stopst, lev);
|
|
if (dp == NULL)
|
|
return(backref(m, sp, stop, ss+1, stopst, lev-1));
|
|
else
|
|
return(dp);
|
|
break;
|
|
case OCH_: /* find the right one, if any */
|
|
ssub = ss + 1;
|
|
esub = ss + OPND(s) - 1;
|
|
assert(OP(m->g->strip[esub]) == OOR1);
|
|
for (;;) { /* find first matching branch */
|
|
dp = backref(m, sp, stop, ssub, esub, lev);
|
|
if (dp != NULL)
|
|
return(dp);
|
|
/* that one missed, try next one */
|
|
if (OP(m->g->strip[esub]) == O_CH)
|
|
return(NULL); /* there is none */
|
|
esub++;
|
|
assert(OP(m->g->strip[esub]) == OOR2);
|
|
ssub = esub + 1;
|
|
esub += OPND(m->g->strip[esub]);
|
|
if (OP(m->g->strip[esub]) == OOR2)
|
|
esub--;
|
|
else
|
|
assert(OP(m->g->strip[esub]) == O_CH);
|
|
}
|
|
break;
|
|
case OLPAREN: /* must undo assignment if rest fails */
|
|
i = OPND(s);
|
|
assert(0 < i && i <= m->g->nsub);
|
|
offsave = m->pmatch[i].rm_so;
|
|
m->pmatch[i].rm_so = sp - m->offp;
|
|
dp = backref(m, sp, stop, ss+1, stopst, lev);
|
|
if (dp != NULL)
|
|
return(dp);
|
|
m->pmatch[i].rm_so = offsave;
|
|
return(NULL);
|
|
break;
|
|
case ORPAREN: /* must undo assignment if rest fails */
|
|
i = OPND(s);
|
|
assert(0 < i && i <= m->g->nsub);
|
|
offsave = m->pmatch[i].rm_eo;
|
|
m->pmatch[i].rm_eo = sp - m->offp;
|
|
dp = backref(m, sp, stop, ss+1, stopst, lev);
|
|
if (dp != NULL)
|
|
return(dp);
|
|
m->pmatch[i].rm_eo = offsave;
|
|
return(NULL);
|
|
break;
|
|
default: /* uh oh */
|
|
assert(nope);
|
|
break;
|
|
}
|
|
|
|
/* "can't happen" */
|
|
assert(nope);
|
|
/* NOTREACHED */
|
|
return((char *)NULL); /* dummy */
|
|
}
|
|
|
|
/*
|
|
- fast - step through the string at top speed
|
|
== static char *fast(register struct match *m, char *start, \
|
|
== char *stop, sopno startst, sopno stopst);
|
|
*/
|
|
static char * /* where tentative match ended, or NULL */
|
|
fast(m, start, stop, startst, stopst)
|
|
register struct match *m;
|
|
char *start;
|
|
char *stop;
|
|
sopno startst;
|
|
sopno stopst;
|
|
{
|
|
register states st = m->st;
|
|
register states fresh = m->fresh;
|
|
register states tmp = m->tmp;
|
|
register char *p = start;
|
|
register int c = (start == m->beginp) ? OUT : *(start-1);
|
|
register int lastc; /* previous c */
|
|
register int flagch;
|
|
register int i;
|
|
register char *coldp; /* last p after which no match was underway */
|
|
|
|
CLEAR(st);
|
|
SET1(st, startst);
|
|
st = step(m->g, startst, stopst, st, NOTHING, st);
|
|
ASSIGN(fresh, st);
|
|
SP("start", st, *p);
|
|
coldp = NULL;
|
|
for (;;) {
|
|
/* next character */
|
|
lastc = c;
|
|
c = (p == m->endp) ? OUT : *p;
|
|
if (EQ(st, fresh))
|
|
coldp = p;
|
|
|
|
/* is there an EOL and/or BOL between lastc and c? */
|
|
flagch = '\0';
|
|
i = 0;
|
|
if ( (lastc == '\n' && m->g->cflags®_NEWLINE) ||
|
|
(lastc == OUT && !(m->eflags®_NOTBOL)) ) {
|
|
flagch = BOL;
|
|
i = m->g->nbol;
|
|
}
|
|
if ( (c == '\n' && m->g->cflags®_NEWLINE) ||
|
|
(c == OUT && !(m->eflags®_NOTEOL)) ) {
|
|
flagch = (flagch == BOL) ? BOLEOL : EOL;
|
|
i += m->g->neol;
|
|
}
|
|
if (i != 0) {
|
|
for (; i > 0; i--)
|
|
st = step(m->g, startst, stopst, st, flagch, st);
|
|
SP("boleol", st, c);
|
|
}
|
|
|
|
/* how about a word boundary? */
|
|
if ( (flagch == BOL || (lastc != OUT && !ISWORD(lastc))) &&
|
|
(c != OUT && ISWORD(c)) ) {
|
|
flagch = BOW;
|
|
}
|
|
if ( (lastc != OUT && ISWORD(lastc)) &&
|
|
(flagch == EOL || (c != OUT && !ISWORD(c))) ) {
|
|
flagch = EOW;
|
|
}
|
|
if (flagch == BOW || flagch == EOW) {
|
|
st = step(m->g, startst, stopst, st, flagch, st);
|
|
SP("boweow", st, c);
|
|
}
|
|
|
|
/* are we done? */
|
|
if (ISSET(st, stopst) || p == stop)
|
|
break; /* NOTE BREAK OUT */
|
|
|
|
/* no, we must deal with this character */
|
|
ASSIGN(tmp, st);
|
|
ASSIGN(st, fresh);
|
|
assert(c != OUT);
|
|
st = step(m->g, startst, stopst, tmp, c, st);
|
|
SP("aft", st, c);
|
|
assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st));
|
|
p++;
|
|
}
|
|
|
|
assert(coldp != NULL);
|
|
m->coldp = coldp;
|
|
if (ISSET(st, stopst))
|
|
return(p+1);
|
|
else
|
|
return(NULL);
|
|
}
|
|
|
|
/*
|
|
- slow - step through the string more deliberately
|
|
== static char *slow(register struct match *m, char *start, \
|
|
== char *stop, sopno startst, sopno stopst);
|
|
*/
|
|
static char * /* where it ended */
|
|
slow(m, start, stop, startst, stopst)
|
|
register struct match *m;
|
|
char *start;
|
|
char *stop;
|
|
sopno startst;
|
|
sopno stopst;
|
|
{
|
|
register states st = m->st;
|
|
register states empty = m->empty;
|
|
register states tmp = m->tmp;
|
|
register char *p = start;
|
|
register int c = (start == m->beginp) ? OUT : *(start-1);
|
|
register int lastc; /* previous c */
|
|
register int flagch;
|
|
register int i;
|
|
register char *matchp; /* last p at which a match ended */
|
|
|
|
AT("slow", start, stop, startst, stopst);
|
|
CLEAR(st);
|
|
SET1(st, startst);
|
|
SP("sstart", st, *p);
|
|
st = step(m->g, startst, stopst, st, NOTHING, st);
|
|
matchp = NULL;
|
|
for (;;) {
|
|
/* next character */
|
|
lastc = c;
|
|
c = (p == m->endp) ? OUT : *p;
|
|
|
|
/* is there an EOL and/or BOL between lastc and c? */
|
|
flagch = '\0';
|
|
i = 0;
|
|
if ( (lastc == '\n' && m->g->cflags®_NEWLINE) ||
|
|
(lastc == OUT && !(m->eflags®_NOTBOL)) ) {
|
|
flagch = BOL;
|
|
i = m->g->nbol;
|
|
}
|
|
if ( (c == '\n' && m->g->cflags®_NEWLINE) ||
|
|
(c == OUT && !(m->eflags®_NOTEOL)) ) {
|
|
flagch = (flagch == BOL) ? BOLEOL : EOL;
|
|
i += m->g->neol;
|
|
}
|
|
if (i != 0) {
|
|
for (; i > 0; i--)
|
|
st = step(m->g, startst, stopst, st, flagch, st);
|
|
SP("sboleol", st, c);
|
|
}
|
|
|
|
/* how about a word boundary? */
|
|
if ( (flagch == BOL || (lastc != OUT && !ISWORD(lastc))) &&
|
|
(c != OUT && ISWORD(c)) ) {
|
|
flagch = BOW;
|
|
}
|
|
if ( (lastc != OUT && ISWORD(lastc)) &&
|
|
(flagch == EOL || (c != OUT && !ISWORD(c))) ) {
|
|
flagch = EOW;
|
|
}
|
|
if (flagch == BOW || flagch == EOW) {
|
|
st = step(m->g, startst, stopst, st, flagch, st);
|
|
SP("sboweow", st, c);
|
|
}
|
|
|
|
/* are we done? */
|
|
if (ISSET(st, stopst))
|
|
matchp = p;
|
|
if (EQ(st, empty) || p == stop)
|
|
break; /* NOTE BREAK OUT */
|
|
|
|
/* no, we must deal with this character */
|
|
ASSIGN(tmp, st);
|
|
ASSIGN(st, empty);
|
|
assert(c != OUT);
|
|
st = step(m->g, startst, stopst, tmp, c, st);
|
|
SP("saft", st, c);
|
|
assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st));
|
|
p++;
|
|
}
|
|
|
|
return(matchp);
|
|
}
|
|
|
|
|
|
static states
|
|
step(g, start, stop, bef, ch, aft)
|
|
register struct re_guts *g;
|
|
sopno start; /* start state within strip */
|
|
sopno stop; /* state after stop state within strip */
|
|
register states bef; /* states reachable before */
|
|
int ch; /* character or NONCHAR code */
|
|
register states aft; /* states already known reachable after */
|
|
{
|
|
register cset *cs;
|
|
register sop s;
|
|
register sopno pc;
|
|
register onestate here; /* note, macros know this name */
|
|
register sopno look;
|
|
register long i;
|
|
|
|
for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) {
|
|
s = g->strip[pc];
|
|
switch (OP(s)) {
|
|
case OEND:
|
|
assert(pc == stop-1);
|
|
break;
|
|
case OCHAR:
|
|
/* only characters can match */
|
|
assert(!NONCHAR(ch) || ch != (char)OPND(s));
|
|
if (ch == (char)OPND(s))
|
|
FWD(aft, bef, 1);
|
|
break;
|
|
case OBOL:
|
|
if (ch == BOL || ch == BOLEOL)
|
|
FWD(aft, bef, 1);
|
|
break;
|
|
case OEOL:
|
|
if (ch == EOL || ch == BOLEOL)
|
|
FWD(aft, bef, 1);
|
|
break;
|
|
case OBOW:
|
|
if (ch == BOW)
|
|
FWD(aft, bef, 1);
|
|
break;
|
|
case OEOW:
|
|
if (ch == EOW)
|
|
FWD(aft, bef, 1);
|
|
break;
|
|
case OANY:
|
|
if (!NONCHAR(ch))
|
|
FWD(aft, bef, 1);
|
|
break;
|
|
case OANYOF:
|
|
cs = &g->sets[OPND(s)];
|
|
if (!NONCHAR(ch) && CHIN(cs, ch))
|
|
FWD(aft, bef, 1);
|
|
break;
|
|
case OBACK_: /* ignored here */
|
|
case O_BACK:
|
|
FWD(aft, aft, 1);
|
|
break;
|
|
case OPLUS_: /* forward, this is just an empty */
|
|
FWD(aft, aft, 1);
|
|
break;
|
|
case O_PLUS: /* both forward and back */
|
|
FWD(aft, aft, 1);
|
|
i = ISSETBACK(aft, OPND(s));
|
|
BACK(aft, aft, OPND(s));
|
|
if (!i && ISSETBACK(aft, OPND(s))) {
|
|
/* oho, must reconsider loop body */
|
|
pc -= OPND(s) + 1;
|
|
INIT(here, pc);
|
|
}
|
|
break;
|
|
case OQUEST_: /* two branches, both forward */
|
|
FWD(aft, aft, 1);
|
|
FWD(aft, aft, OPND(s));
|
|
break;
|
|
case O_QUEST: /* just an empty */
|
|
FWD(aft, aft, 1);
|
|
break;
|
|
case OLPAREN: /* not significant here */
|
|
case ORPAREN:
|
|
FWD(aft, aft, 1);
|
|
break;
|
|
case OCH_: /* mark the first two branches */
|
|
FWD(aft, aft, 1);
|
|
assert(OP(g->strip[pc+OPND(s)]) == OOR2);
|
|
FWD(aft, aft, OPND(s));
|
|
break;
|
|
case OOR1: /* done a branch, find the O_CH */
|
|
if (ISSTATEIN(aft, here)) {
|
|
for (look = 1;
|
|
OP(s = g->strip[pc+look]) != O_CH;
|
|
look += OPND(s))
|
|
assert(OP(s) == OOR2);
|
|
FWD(aft, aft, look);
|
|
}
|
|
break;
|
|
case OOR2: /* propagate OCH_'s marking */
|
|
FWD(aft, aft, 1);
|
|
if (OP(g->strip[pc+OPND(s)]) != O_CH) {
|
|
assert(OP(g->strip[pc+OPND(s)]) == OOR2);
|
|
FWD(aft, aft, OPND(s));
|
|
}
|
|
break;
|
|
case O_CH: /* just empty */
|
|
FWD(aft, aft, 1);
|
|
break;
|
|
default: /* ooooops... */
|
|
assert(nope);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return(aft);
|
|
}
|
|
|
|
#undef matcher
|
|
#undef fast
|
|
#undef slow
|
|
#undef dissect
|
|
#undef backref
|
|
#undef step
|
|
#undef print
|
|
#undef at
|
|
#undef match
|
|
|
|
int /* 0 success, REG_NOMATCH failure */
|
|
regexec(preg, string, nmatch, pmatch, eflags)
|
|
const regex_t *preg;
|
|
const char *string;
|
|
size_t nmatch;
|
|
regmatch_t pmatch[];
|
|
int eflags;
|
|
{
|
|
register struct re_guts *g = preg->re_g;
|
|
#define GOODFLAGS(f) ((f)&(REG_NOTBOL|REG_NOTEOL|REG_STARTEND))
|
|
|
|
if (preg->re_magic != MAGIC1 || g->magic != MAGIC2)
|
|
return(REG_BADPAT);
|
|
assert(!(g->iflags&BAD));
|
|
if (g->iflags&BAD) /* backstop for no-debug case */
|
|
return(REG_BADPAT);
|
|
eflags = GOODFLAGS(eflags);
|
|
|
|
if (g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags®_LARGE))
|
|
return(smatcher(g, (char *)string, nmatch, pmatch, eflags));
|
|
else
|
|
return(lmatcher(g, (char *)string, nmatch, pmatch, eflags));
|
|
#undef GOODFLAGS
|
|
}
|
|
/*
|
|
- regfree - free everything
|
|
= extern void regfree(regex_t *);
|
|
*/
|
|
void
|
|
regfree(preg)
|
|
regex_t *preg;
|
|
{
|
|
register struct re_guts *g;
|
|
|
|
if (preg->re_magic != MAGIC1) /* oops */
|
|
return; /* nice to complain, but hard */
|
|
|
|
g = preg->re_g;
|
|
if (g == NULL || g->magic != MAGIC2) /* oops again */
|
|
return;
|
|
preg->re_magic = 0; /* mark it invalid */
|
|
g->magic = 0; /* mark it invalid */
|
|
|
|
if (g->strip != NULL)
|
|
free((char *)g->strip);
|
|
if (g->sets != NULL)
|
|
free((char *)g->sets);
|
|
if (g->setbits != NULL)
|
|
free((char *)g->setbits);
|
|
if (g->must != NULL)
|
|
free(g->must);
|
|
free((char *)g);
|
|
}
|
|
|
|
#ifdef WITH_MAIN
|
|
int main(int argc, char* argv[]){
|
|
regex_t preg;
|
|
int i, s;
|
|
if(argc<2) return 1;
|
|
if (regcomp(&preg, argv[1], REG_NOSUB)) {
|
|
fprintf(stderr, "Failed to compile regex\n");
|
|
return 2;
|
|
}
|
|
for (i = 2; i<argc; i++){
|
|
s = regexec(&preg, argv[i], 0, NULL, 0);
|
|
fprintf(stdout, "String[%d]: ", i-1);
|
|
switch(s){
|
|
case 0:
|
|
printf("match\n");
|
|
break;
|
|
case REG_NOMATCH:
|
|
printf("not match\n");
|
|
break;
|
|
default:
|
|
printf("failed (%d)\n", s);
|
|
}
|
|
}
|
|
regfree(&preg);
|
|
return 0;
|
|
}
|
|
#endif
|