#include "tclInt.h"
#include "tclPort.h"
static char *errMsg = NULL;
#define END 0
#define BOL 1
#define EOL 2
#define ANY 3
#define ANYOF 4
#define ANYBUT 5
#define BRANCH 6
#define BACK 7
#define EXACTLY 8
#define NOTHING 9
#define STAR 10
#define PLUS 11
#define OPEN 20
#define CLOSE (OPEN+NSUBEXP)
#define OP(p) (*(p))
#define NEXT(p) (((*((p)+1)&0377)<<8) + (*((p)+2)&0377))
#define OPERAND(p) ((p) + 3)
#ifndef CHARBITS
#define UCHARAT(p) ((int)*(unsigned char *)(p))
#else
#define UCHARAT(p) ((int)*(p)&CHARBITS)
#endif
#define FAIL(m) { TclRegError(m); return(NULL); }
#define ISMULT(c) ((c) == '*' || (c) == '+' || (c) == '?')
#define META "^$.[()|?+*\\"
#define HASWIDTH 01
#define SIMPLE 02
#define SPSTART 04
#define WORST 0
struct regcomp_state {
char *regparse;
int regnpar;
char *regcode;
long regsize;
};
static char regdummy;
#define MAGIC 0234
static char * reg _ANSI_ARGS_((int paren, int *flagp,
struct regcomp_state *rcstate));
static char * regatom _ANSI_ARGS_((int *flagp,
struct regcomp_state *rcstate));
static char * regbranch _ANSI_ARGS_((int *flagp,
struct regcomp_state *rcstate));
static void regc _ANSI_ARGS_((int b,
struct regcomp_state *rcstate));
static void reginsert _ANSI_ARGS_((int op, char *opnd,
struct regcomp_state *rcstate));
static char * regnext _ANSI_ARGS_((char *p));
static char * regnode _ANSI_ARGS_((int op,
struct regcomp_state *rcstate));
static void regoptail _ANSI_ARGS_((char *p, char *val));
static char * regpiece _ANSI_ARGS_((int *flagp,
struct regcomp_state *rcstate));
static void regtail _ANSI_ARGS_((char *p, char *val));
#ifdef STRCSPN
static int strcspn _ANSI_ARGS_((char *s1, char *s2));
#endif
regexp *
TclRegComp(exp)
char *exp;
{
register regexp *r;
register char *scan;
register char *longest;
register int len;
int flags;
struct regcomp_state state;
struct regcomp_state *rcstate= &state;
if (exp == NULL)
FAIL("NULL argument");
rcstate->regparse = exp;
rcstate->regnpar = 1;
rcstate->regsize = 0L;
rcstate->regcode = ®dummy;
regc(MAGIC, rcstate);
if (reg(0, &flags, rcstate) == NULL)
return(NULL);
if (rcstate->regsize >= 32767L)
FAIL("regexp too big");
r = (regexp *)ckalloc(sizeof(regexp) + (unsigned)rcstate->regsize);
if (r == NULL)
FAIL("out of space");
rcstate->regparse = exp;
rcstate->regnpar = 1;
rcstate->regcode = r->program;
regc(MAGIC, rcstate);
if (reg(0, &flags, rcstate) == NULL)
return(NULL);
r->regstart = '\0';
r->reganch = 0;
r->regmust = NULL;
r->regmlen = 0;
scan = r->program+1;
if (OP(regnext(scan)) == END) {
scan = OPERAND(scan);
if (OP(scan) == EXACTLY)
r->regstart = *OPERAND(scan);
else if (OP(scan) == BOL)
r->reganch++;
if (flags&SPSTART) {
longest = NULL;
len = 0;
for (; scan != NULL; scan = regnext(scan))
if (OP(scan) == EXACTLY && ((int) strlen(OPERAND(scan))) >= len) {
longest = OPERAND(scan);
len = strlen(OPERAND(scan));
}
r->regmust = longest;
r->regmlen = len;
}
}
return(r);
}
static char *
reg(paren, flagp, rcstate)
int paren;
int *flagp;
struct regcomp_state *rcstate;
{
register char *ret;
register char *br;
register char *ender;
register int parno = 0;
int flags;
*flagp = HASWIDTH;
if (paren) {
if (rcstate->regnpar >= NSUBEXP)
FAIL("too many ()");
parno = rcstate->regnpar;
rcstate->regnpar++;
ret = regnode(OPEN+parno,rcstate);
} else
ret = NULL;
br = regbranch(&flags,rcstate);
if (br == NULL)
return(NULL);
if (ret != NULL)
regtail(ret, br);
else
ret = br;
if (!(flags&HASWIDTH))
*flagp &= ~HASWIDTH;
*flagp |= flags&SPSTART;
while (*rcstate->regparse == '|') {
rcstate->regparse++;
br = regbranch(&flags,rcstate);
if (br == NULL)
return(NULL);
regtail(ret, br);
if (!(flags&HASWIDTH))
*flagp &= ~HASWIDTH;
*flagp |= flags&SPSTART;
}
ender = regnode((paren) ? CLOSE+parno : END,rcstate);
regtail(ret, ender);
for (br = ret; br != NULL; br = regnext(br))
regoptail(br, ender);
if (paren && *rcstate->regparse++ != ')') {
FAIL("unmatched ()");
} else if (!paren && *rcstate->regparse != '\0') {
if (*rcstate->regparse == ')') {
FAIL("unmatched ()");
} else
FAIL("junk on end");
}
return(ret);
}
static char *
regbranch(flagp, rcstate)
int *flagp;
struct regcomp_state *rcstate;
{
register char *ret;
register char *chain;
register char *latest;
int flags;
*flagp = WORST;
ret = regnode(BRANCH,rcstate);
chain = NULL;
while (*rcstate->regparse != '\0' && *rcstate->regparse != '|' &&
*rcstate->regparse != ')') {
latest = regpiece(&flags, rcstate);
if (latest == NULL)
return(NULL);
*flagp |= flags&HASWIDTH;
if (chain == NULL)
*flagp |= flags&SPSTART;
else
regtail(chain, latest);
chain = latest;
}
if (chain == NULL)
(void) regnode(NOTHING,rcstate);
return(ret);
}
static char *
regpiece(flagp, rcstate)
int *flagp;
struct regcomp_state *rcstate;
{
register char *ret;
register char op;
register char *next;
int flags;
ret = regatom(&flags,rcstate);
if (ret == NULL)
return(NULL);
op = *rcstate->regparse;
if (!ISMULT(op)) {
*flagp = flags;
return(ret);
}
if (!(flags&HASWIDTH) && op != '?')
FAIL("*+ operand could be empty");
*flagp = (op != '+') ? (WORST|SPSTART) : (WORST|HASWIDTH);
if (op == '*' && (flags&SIMPLE))
reginsert(STAR, ret, rcstate);
else if (op == '*') {
reginsert(BRANCH, ret, rcstate);
regoptail(ret, regnode(BACK,rcstate));
regoptail(ret, ret);
regtail(ret, regnode(BRANCH,rcstate));
regtail(ret, regnode(NOTHING,rcstate));
} else if (op == '+' && (flags&SIMPLE))
reginsert(PLUS, ret, rcstate);
else if (op == '+') {
next = regnode(BRANCH,rcstate);
regtail(ret, next);
regtail(regnode(BACK,rcstate), ret);
regtail(next, regnode(BRANCH,rcstate));
regtail(ret, regnode(NOTHING,rcstate));
} else if (op == '?') {
reginsert(BRANCH, ret, rcstate);
regtail(ret, regnode(BRANCH,rcstate));
next = regnode(NOTHING,rcstate);
regtail(ret, next);
regoptail(ret, next);
}
rcstate->regparse++;
if (ISMULT(*rcstate->regparse))
FAIL("nested *?+");
return(ret);
}
static char *
regatom(flagp, rcstate)
int *flagp;
struct regcomp_state *rcstate;
{
register char *ret;
int flags;
*flagp = WORST;
switch (*rcstate->regparse++) {
case '^':
ret = regnode(BOL,rcstate);
break;
case '$':
ret = regnode(EOL,rcstate);
break;
case '.':
ret = regnode(ANY,rcstate);
*flagp |= HASWIDTH|SIMPLE;
break;
case '[': {
register int clss;
register int classend;
if(rcstate->regparse[0] != '\\' &&
rcstate->regparse[0] != '^' &&
rcstate->regparse[1] == ']') {
ret = regnode(EXACTLY,rcstate);
regc(*rcstate->regparse++,rcstate);
regc('\0',rcstate);
rcstate->regparse++;
*flagp |= HASWIDTH|SIMPLE;
break;
}
if (*rcstate->regparse == '^') {
ret = regnode(ANYBUT,rcstate);
rcstate->regparse++;
} else
ret = regnode(ANYOF,rcstate);
if (*rcstate->regparse == ']' || *rcstate->regparse == '-')
regc(*rcstate->regparse++,rcstate);
while (*rcstate->regparse != '\0' && *rcstate->regparse != ']') {
if (*rcstate->regparse == '-') {
rcstate->regparse++;
if (*rcstate->regparse == ']' || *rcstate->regparse == '\0')
regc('-',rcstate);
else {
clss = UCHARAT(rcstate->regparse-2)+1;
classend = UCHARAT(rcstate->regparse);
if (clss > classend+1)
FAIL("invalid [] range");
for (; clss <= classend; clss++)
regc((char)clss,rcstate);
rcstate->regparse++;
}
} else
regc(*rcstate->regparse++,rcstate);
}
regc('\0',rcstate);
if (*rcstate->regparse != ']')
FAIL("unmatched []");
rcstate->regparse++;
*flagp |= HASWIDTH|SIMPLE;
}
break;
case '(':
ret = reg(1, &flags, rcstate);
if (ret == NULL)
return(NULL);
*flagp |= flags&(HASWIDTH|SPSTART);
break;
case '\0':
case '|':
case ')':
FAIL("internal urp");
case '?':
case '+':
case '*':
FAIL("?+* follows nothing");
case '\\':
if (*rcstate->regparse == '\0')
FAIL("trailing \\");
ret = regnode(EXACTLY,rcstate);
regc(*rcstate->regparse++,rcstate);
regc('\0',rcstate);
*flagp |= HASWIDTH|SIMPLE;
break;
default: {
register int len;
register char ender;
rcstate->regparse--;
len = strcspn(rcstate->regparse, META);
if (len <= 0)
FAIL("internal disaster");
ender = *(rcstate->regparse+len);
if (len > 1 && ISMULT(ender))
len--;
*flagp |= HASWIDTH;
if (len == 1)
*flagp |= SIMPLE;
ret = regnode(EXACTLY,rcstate);
while (len > 0) {
regc(*rcstate->regparse++,rcstate);
len--;
}
regc('\0',rcstate);
}
break;
}
return(ret);
}
static char *
regnode(op, rcstate)
int op;
struct regcomp_state *rcstate;
{
register char *ret;
register char *ptr;
ret = rcstate->regcode;
if (ret == ®dummy) {
rcstate->regsize += 3;
return(ret);
}
ptr = ret;
*ptr++ = (char)op;
*ptr++ = '\0';
*ptr++ = '\0';
rcstate->regcode = ptr;
return(ret);
}
static void
regc(b, rcstate)
int b;
struct regcomp_state *rcstate;
{
if (rcstate->regcode != ®dummy)
*rcstate->regcode++ = (char)b;
else
rcstate->regsize++;
}
static void
reginsert(op, opnd, rcstate)
int op;
char *opnd;
struct regcomp_state *rcstate;
{
register char *src;
register char *dst;
register char *place;
if (rcstate->regcode == ®dummy) {
rcstate->regsize += 3;
return;
}
src = rcstate->regcode;
rcstate->regcode += 3;
dst = rcstate->regcode;
while (src > opnd)
*--dst = *--src;
place = opnd;
*place++ = (char)op;
*place++ = '\0';
*place = '\0';
}
static void
regtail(p, val)
char *p;
char *val;
{
register char *scan;
register char *temp;
register int offset;
if (p == ®dummy)
return;
scan = p;
for (;;) {
temp = regnext(scan);
if (temp == NULL)
break;
scan = temp;
}
if (OP(scan) == BACK)
offset = scan - val;
else
offset = val - scan;
*(scan+1) = (char)((offset>>8)&0377);
*(scan+2) = (char)(offset&0377);
}
static void
regoptail(p, val)
char *p;
char *val;
{
if (p == NULL || p == ®dummy || OP(p) != BRANCH)
return;
regtail(OPERAND(p), val);
}
struct regexec_state {
char *reginput;
char *regbol;
char **regstartp;
char **regendp;
};
static int regtry _ANSI_ARGS_((regexp *prog, char *string,
struct regexec_state *restate));
static int regmatch _ANSI_ARGS_((char *prog,
struct regexec_state *restate));
static int regrepeat _ANSI_ARGS_((char *p,
struct regexec_state *restate));
#ifdef DEBUG
int regnarrate = 0;
void regdump _ANSI_ARGS_((regexp *r));
static char *regprop _ANSI_ARGS_((char *op));
#endif
int
TclRegExec(prog, string, start)
register regexp *prog;
register char *string;
char *start;
{
register char *s;
struct regexec_state state;
struct regexec_state *restate= &state;
if (prog == NULL || string == NULL) {
TclRegError("NULL parameter");
return(0);
}
if (UCHARAT(prog->program) != MAGIC) {
TclRegError("corrupted program");
return(0);
}
if (prog->regmust != NULL) {
s = string;
while ((s = strchr(s, prog->regmust[0])) != NULL) {
if (strncmp(s, prog->regmust, (size_t) prog->regmlen)
== 0)
break;
s++;
}
if (s == NULL)
return(0);
}
restate->regbol = start;
if (prog->reganch)
return(regtry(prog, string, restate));
s = string;
if (prog->regstart != '\0')
while ((s = strchr(s, prog->regstart)) != NULL) {
if (regtry(prog, s, restate))
return(1);
s++;
}
else
do {
if (regtry(prog, s, restate))
return(1);
} while (*s++ != '\0');
return(0);
}
static int
regtry(prog, string, restate)
regexp *prog;
char *string;
struct regexec_state *restate;
{
register int i;
register char **sp;
register char **ep;
restate->reginput = string;
restate->regstartp = prog->startp;
restate->regendp = prog->endp;
sp = prog->startp;
ep = prog->endp;
for (i = NSUBEXP; i > 0; i--) {
*sp++ = NULL;
*ep++ = NULL;
}
if (regmatch(prog->program + 1,restate)) {
prog->startp[0] = string;
prog->endp[0] = restate->reginput;
return(1);
} else
return(0);
}
static int
regmatch(prog, restate)
char *prog;
struct regexec_state *restate;
{
register char *scan;
char *next;
scan = prog;
#ifdef DEBUG
if (scan != NULL && regnarrate)
fprintf(stderr, "%s(\n", regprop(scan));
#endif
while (scan != NULL) {
#ifdef DEBUG
if (regnarrate)
fprintf(stderr, "%s...\n", regprop(scan));
#endif
next = regnext(scan);
switch (OP(scan)) {
case BOL:
if (restate->reginput != restate->regbol) {
return 0;
}
break;
case EOL:
if (*restate->reginput != '\0') {
return 0;
}
break;
case ANY:
if (*restate->reginput == '\0') {
return 0;
}
restate->reginput++;
break;
case EXACTLY: {
register int len;
register char *opnd;
opnd = OPERAND(scan);
if (*opnd != *restate->reginput) {
return 0 ;
}
len = strlen(opnd);
if (len > 1 && strncmp(opnd, restate->reginput, (size_t) len)
!= 0) {
return 0;
}
restate->reginput += len;
break;
}
case ANYOF:
if (*restate->reginput == '\0'
|| strchr(OPERAND(scan), *restate->reginput) == NULL) {
return 0;
}
restate->reginput++;
break;
case ANYBUT:
if (*restate->reginput == '\0'
|| strchr(OPERAND(scan), *restate->reginput) != NULL) {
return 0;
}
restate->reginput++;
break;
case NOTHING:
break;
case BACK:
break;
case OPEN+1:
case OPEN+2:
case OPEN+3:
case OPEN+4:
case OPEN+5:
case OPEN+6:
case OPEN+7:
case OPEN+8:
case OPEN+9: {
register int no;
register char *save;
doOpen:
no = OP(scan) - OPEN;
save = restate->reginput;
if (regmatch(next,restate)) {
if (restate->regstartp[no] == NULL) {
restate->regstartp[no] = save;
}
return 1;
} else {
return 0;
}
}
case CLOSE+1:
case CLOSE+2:
case CLOSE+3:
case CLOSE+4:
case CLOSE+5:
case CLOSE+6:
case CLOSE+7:
case CLOSE+8:
case CLOSE+9: {
register int no;
register char *save;
doClose:
no = OP(scan) - CLOSE;
save = restate->reginput;
if (regmatch(next,restate)) {
if (restate->regendp[no] == NULL)
restate->regendp[no] = save;
return 1;
} else {
return 0;
}
}
case BRANCH: {
register char *save;
if (OP(next) != BRANCH) {
next = OPERAND(scan);
} else {
do {
save = restate->reginput;
if (regmatch(OPERAND(scan),restate))
return(1);
restate->reginput = save;
scan = regnext(scan);
} while (scan != NULL && OP(scan) == BRANCH);
return 0;
}
break;
}
case STAR:
case PLUS: {
register char nextch;
register int no;
register char *save;
register int min;
nextch = '\0';
if (OP(next) == EXACTLY)
nextch = *OPERAND(next);
min = (OP(scan) == STAR) ? 0 : 1;
save = restate->reginput;
no = regrepeat(OPERAND(scan),restate);
while (no >= min) {
if (nextch == '\0' || *restate->reginput == nextch)
if (regmatch(next,restate))
return(1);
if (nextch != '\0' && no > (min + 1)) {
char tmp = *(save + no);
char *p;
*(save + no) = 0;
p = strrchr(save, nextch);
*(save + no) = tmp;
if (p != NULL)
no = p - save + 1;
else
no = 0;
}
no--;
restate->reginput = save + no;
}
return(0);
}
case END:
return(1);
default:
if (OP(scan) > OPEN && OP(scan) < OPEN+NSUBEXP) {
goto doOpen;
} else if (OP(scan) > CLOSE && OP(scan) < CLOSE+NSUBEXP) {
goto doClose;
}
TclRegError("memory corruption");
return 0;
}
scan = next;
}
TclRegError("corrupted pointers");
return(0);
}
static int
regrepeat(p, restate)
char *p;
struct regexec_state *restate;
{
register int count = 0;
register char *scan;
register char *opnd;
scan = restate->reginput;
opnd = OPERAND(p);
switch (OP(p)) {
case ANY:
count = strlen(scan);
scan += count;
break;
case EXACTLY:
while (*opnd == *scan) {
count++;
scan++;
}
break;
case ANYOF:
while (*scan != '\0' && strchr(opnd, *scan) != NULL) {
count++;
scan++;
}
break;
case ANYBUT:
while (*scan != '\0' && strchr(opnd, *scan) == NULL) {
count++;
scan++;
}
break;
default:
TclRegError("internal foulup");
count = 0;
break;
}
restate->reginput = scan;
return(count);
}
static char *
regnext(p)
register char *p;
{
register int offset;
if (p == ®dummy)
return(NULL);
offset = NEXT(p);
if (offset == 0)
return(NULL);
if (OP(p) == BACK)
return(p-offset);
else
return(p+offset);
}
#ifdef DEBUG
static char *regprop();
void
regdump(r)
regexp *r;
{
register char *s;
register char op = EXACTLY;
register char *next;
s = r->program + 1;
while (op != END) {
op = OP(s);
printf("%2d%s", s-r->program, regprop(s));
next = regnext(s);
if (next == NULL)
printf("(0)");
else
printf("(%d)", (s-r->program)+(next-s));
s += 3;
if (op == ANYOF || op == ANYBUT || op == EXACTLY) {
while (*s != '\0') {
putchar(*s);
s++;
}
s++;
}
putchar('\n');
}
if (r->regstart != '\0')
printf("start `%c' ", r->regstart);
if (r->reganch)
printf("anchored ");
if (r->regmust != NULL)
printf("must have \"%s\"", r->regmust);
printf("\n");
}
static char *
regprop(op)
char *op;
{
register char *p;
static char buf[50];
(void) strcpy(buf, ":");
switch (OP(op)) {
case BOL:
p = "BOL";
break;
case EOL:
p = "EOL";
break;
case ANY:
p = "ANY";
break;
case ANYOF:
p = "ANYOF";
break;
case ANYBUT:
p = "ANYBUT";
break;
case BRANCH:
p = "BRANCH";
break;
case EXACTLY:
p = "EXACTLY";
break;
case NOTHING:
p = "NOTHING";
break;
case BACK:
p = "BACK";
break;
case END:
p = "END";
break;
case OPEN+1:
case OPEN+2:
case OPEN+3:
case OPEN+4:
case OPEN+5:
case OPEN+6:
case OPEN+7:
case OPEN+8:
case OPEN+9:
sprintf(buf+strlen(buf), "OPEN%d", OP(op)-OPEN);
p = NULL;
break;
case CLOSE+1:
case CLOSE+2:
case CLOSE+3:
case CLOSE+4:
case CLOSE+5:
case CLOSE+6:
case CLOSE+7:
case CLOSE+8:
case CLOSE+9:
sprintf(buf+strlen(buf), "CLOSE%d", OP(op)-CLOSE);
p = NULL;
break;
case STAR:
p = "STAR";
break;
case PLUS:
p = "PLUS";
break;
default:
if (OP(op) > OPEN && OP(op) < OPEN+NSUBEXP) {
sprintf(buf+strlen(buf), "OPEN%d", OP(op)-OPEN);
p = NULL;
break;
} else if (OP(op) > CLOSE && OP(op) < CLOSE+NSUBEXP) {
sprintf(buf+strlen(buf), "CLOSE%d", OP(op)-CLOSE);
p = NULL;
} else {
TclRegError("corrupted opcode");
}
break;
}
if (p != NULL)
(void) strcat(buf, p);
return(buf);
}
#endif
#ifdef STRCSPN
static int
strcspn(s1, s2)
char *s1;
char *s2;
{
register char *scan1;
register char *scan2;
register int count;
count = 0;
for (scan1 = s1; *scan1 != '\0'; scan1++) {
for (scan2 = s2; *scan2 != '\0';)
if (*scan1 == *scan2++)
return(count);
count++;
}
return(count);
}
#endif
void
TclRegError(string)
char *string;
{
errMsg = string;
}
char *
TclGetRegError()
{
return errMsg;
}