#include <my_global.h>

#include <m_string.h>

#include <m_ctype.h>

#ifdef __WIN__

#include <limits.h>

#include "my_regex.h"

#include "utils.h"

#include "regex2.h"

#include "cclass.h"

#include "cname.h"

struct parse {

};

my_regex_stack_check_t my_regex_enough_mem_in_stack= NULL;

#include "regcomp.ih"

static char nuls[10]; /* place to point scanner in event of error */

struct cclass cclasses[CCLASS_LAST+1]= {

{ "alnum", "","", _MY_U | _MY_L | _MY_NMR},

{ "alpha", "","", _MY_U | _MY_L },

{ "blank", "","", _MY_B },

{ "cntrl", "","", _MY_CTR },

{ "digit", "","", _MY_NMR },

{ "graph", "","", _MY_PNT | _MY_U | _MY_L | _MY_NMR},

{ "lower", "","", _MY_L },

{ "print", "","", _MY_PNT | _MY_U | _MY_L | _MY_NMR | _MY_B },

{ "punct", "","", _MY_PNT },

{ "space", "","", _MY_SPC },

{ "upper", "","", _MY_U },

{ "xdigit", "","", _MY_X },

{ NULL,NULL,NULL, 0 }

};

#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))

#ifndef NDEBUG

static int never = 0; /* for use in asserts; shuts lint up */

#define never 0 /* some <assert.h>s have bugs too */

int /* 0 success, otherwise MY_REG_something */

my_regcomp(preg, pattern, cflags, charset)

my_regex_t *preg;

const char *pattern;

int cflags;

const CHARSET_INFO *charset;

{

struct parse pa;

register struct re_guts *g;

register struct parse *p = &pa;

register int i;

register size_t len;

#ifdef REDEBUG

# define GOODFLAGS(f) (f)

# define GOODFLAGS(f) ((f)&~MY_REG_DUMP)

my_regex_init(charset, NULL); /* Init cclass if neaded */

preg->charset=charset;

cflags = GOODFLAGS(cflags);

if ((cflags&MY_REG_EXTENDED) && (cflags&MY_REG_NOSPEC))

return(MY_REG_INVARG);

if (cflags&MY_REG_PEND) {

if (preg->re_endp < pattern)

return(MY_REG_INVARG);

len = preg->re_endp - pattern;

} else

len = strlen((char *)pattern);

/*

{

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(MY_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(MY_REG_ESPACE);

p->strip = (sop *)malloc(p->ssize * sizeof(sop));

p->slen = 0;

if (p->strip == NULL) {

free((char *)g);

return(MY_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;

p->charset = preg->charset;

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&MY_REG_EXTENDED)

p_ere(p, OUT);

else if (cflags&MY_REG_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;

#ifndef REDEBUG

/* not debugging, so can't rely on the assert() in regexec() */

if (g->iflags&BAD)

SETERROR(MY_REG_ASSERT);

/* win or lose, we're done */

if (p->error != 0) /* lose */

my_regfree(preg);

return(p->error);

}

static void

p_ere(p, stop)

register struct parse *p;

int stop; /* character this ERE should end at */

{

register char c;

register sopno UNINIT_VAR(prevback);

register sopno UNINIT_VAR(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)

{

if (my_regex_enough_mem_in_stack &&

my_regex_enough_mem_in_stack(0))

{

SETERROR(MY_REG_ESPACE);

return;

}

p_ere_exp(p);

}

if(REQUIRE(HERE() != conc, MY_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));

}

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 '(':

if(REQUIRE(MORE(), MY_REG_EPAREN)) {}

p->g->nsub++;

subno = (sopno) 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);

if(MUSTEAT(')', MY_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(MY_REG_EMPTY);

break;

case '*':

case '+':

case '?':

SETERROR(MY_REG_BADRPT);

break;

case '.':

if (p->g->cflags&MY_REG_NEWLINE)

nonnewline(p);

else

EMIT(OANY, 0);

break;

case '[':

p_bracket(p);

break;

case '\\':

if(REQUIRE(MORE(), MY_REG_EESCAPE)) {}

c = GETNEXT();

ordinary(p, c);

break;

case '{': /* okay as ordinary except if digit follows */

if(REQUIRE(!MORE() || !my_isdigit(p->charset,PEEK()), MY_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() &&

my_isdigit(p->charset,PEEK2())) ))

return; /* no repetition, we're done */

NEXT();

if(REQUIRE(!wascaret, MY_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 (my_isdigit(p->charset,PEEK())) {

count2 = p_count(p);

if(REQUIRE(count <= count2, MY_REG_BADBR)) {}

} else /* single number with comma */

count2 = RE_INFINITY;

} else /* just a single number */

count2 = count;

repeat(p, pos, count, count2);

if (!EAT('}')) { /* error heuristics */

while (MORE() && PEEK() != '}')

NEXT();

if(REQUIRE(MORE(), MY_REG_EBRACE)) {}

SETERROR(MY_REG_BADBR);

}

break;

}

if (!MORE())

return;

c = PEEK();

if (!( c == '*' || c == '+' || c == '?' ||

(c == '{' && MORE2() &&

my_isdigit(p->charset,PEEK2())) ) )

return;

SETERROR(MY_REG_BADRPT);

}

static void

p_str(p)

register struct parse *p;

{

if(REQUIRE(MORE(), MY_REG_EMPTY)) {}

while (MORE())

ordinary(p, GETNEXT());

}

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++;

}

if(REQUIRE(HERE() != start, MY_REG_EMPTY)) {} /* require nonempty */

}

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 == '\\') {

if(REQUIRE(MORE(), MY_REG_EESCAPE)) {}

c = BACKSL | (unsigned char)GETNEXT();

}

switch (c) {

case '.':

if (p->g->cflags&MY_REG_NEWLINE)

nonnewline(p);

else

EMIT(OANY, 0);

break;

case '[':

p_bracket(p);

break;

case BACKSL|'{':

SETERROR(MY_REG_BADRPT);

break;

case BACKSL|'(':

p->g->nsub++;

subno = (sopno) 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);

if(REQUIRE(EATTWO('\\', ')'), MY_REG_EPAREN)) {}

break;

case BACKSL|')': /* should not get here -- must be user */

case BACKSL|'}':

SETERROR(MY_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((uint) 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(MY_REG_ESUBREG);

p->g->backrefs = 1;

break;

case '*':

if(REQUIRE(starordinary, MY_REG_BADRPT)) {}

/* FALLTHROUGH */

default:

ordinary(p, c &~ BACKSL);

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() && my_isdigit(p->charset,PEEK())) {

count2 = p_count(p);

if(REQUIRE(count <= count2, MY_REG_BADBR)) {}

} else /* single number with comma */

count2 = RE_INFINITY;

} else /* just a single number */

count2 = count;

repeat(p, pos, count, count2);

if (!EATTWO('\\', '}')) { /* error heuristics */

while (MORE() && !SEETWO('\\', '}'))

NEXT();

if(REQUIRE(MORE(), MY_REG_EBRACE)) {}

SETERROR(MY_REG_BADBR);

}

} else if (c == (unsigned char)'$') /* $ (but not \$) ends it */

return(1);

return(0);

}

static int /* the value */

p_count(p)

register struct parse *p;

{

register int count = 0;

register int ndigits = 0;

while (MORE() && my_isdigit(p->charset,PEEK()) && count <= DUPMAX) {

count = count*10 + (GETNEXT() - '0');

ndigits++;

}

if(REQUIRE(ndigits > 0 && count <= DUPMAX, MY_REG_BADBR)) {}

return(count);

}

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, '-');

if(MUSTEAT(']', MY_REG_EBRACK)) {}

if (p->error != 0) /* don't mess things up further */

return;

if (p->g->cflags&MY_REG_ICASE) {

register int i;

register int ci;

for (i = p->g->csetsize - 1; i >= 0; i--)

if (CHIN(cs, i) && my_isalpha(p->charset,i)) {

ci = othercase(p->charset,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&MY_REG_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));

}

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(MY_REG_ERANGE);

return; /* NOTE RETURN */

default:

c = '\0';

break;

}

switch (c) {

case ':': /* character class */

NEXT2();

if(REQUIRE(MORE(), MY_REG_EBRACK)) {}

c = PEEK();

if(REQUIRE(c != '-' && c != ']', MY_REG_ECTYPE)) {}

p_b_cclass(p, cs);

if(REQUIRE(MORE(), MY_REG_EBRACK)) {}

if(REQUIRE(EATTWO(':', ']'), MY_REG_ECTYPE)) {}

break;

case '=': /* equivalence class */

NEXT2();

if(REQUIRE(MORE(), MY_REG_EBRACK)) {}

c = PEEK();

if(REQUIRE(c != '-' && c != ']', MY_REG_ECOLLATE)) {}

p_b_eclass(p, cs);

if(REQUIRE(MORE(), MY_REG_EBRACK)) {}

if(REQUIRE(EATTWO('=', ']'), MY_REG_ECOLLATE)) {}

break;

default: /* symbol, ordinary character, or range */

start = p_b_symbol(p);

if (SEE('-') && MORE2() && PEEK2() != ']') {

/* range */

NEXT();

if (EAT('-'))

finish = '-';

else

finish = p_b_symbol(p);

} else

finish = start;

if(REQUIRE(start <= finish, MY_REG_ERANGE)) {}

for (i = start; i <= finish; i++)

CHadd(cs, i);

break;

}

}

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;

while (MORE() && my_isalpha(p->charset,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(MY_REG_ECTYPE);

return;

}

#ifndef USE_ORIG_REGEX_CODE

{

register size_t i;

for (i=1 ; i<256 ; i++)

if (p->charset->ctype[i+1] & cp->mask)

CHadd(cs, i);

}

#else

{

register char *u = (char*) cp->chars;

register char c;

while ((c = *u++) != '\0')

CHadd(cs, c);

for (u = (char*) cp->multis; *u != '\0'; u += strlen(u) + 1)

MCadd(p, cs, u);

}

}

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);

}

static char /* value of symbol */

p_b_symbol(p)

register struct parse *p;

{

register char value;

if(REQUIRE(MORE(), MY_REG_EBRACK)) {}

if (!EATTWO('[', '.'))

return(GETNEXT());

/* collating symbol */

value = p_b_coll_elem(p, '.');

if(REQUIRE(EATTWO('.', ']'), MY_REG_ECOLLATE)) {}

return(value);

}

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;

#ifdef _WIN64

register __int64 len;

register int len;

while (MORE() && !SEETWO(endc, ']'))

NEXT();

if (!MORE()) {

SETERROR(MY_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(MY_REG_ECOLLATE); /* neither */

return(0);

}

static char /* if no counterpart, return ch */

othercase(charset,ch)

const CHARSET_INFO *charset;

int ch;

{

/*

assert(my_isalpha(charset,ch));

if (my_isupper(charset,ch))

{

return(charset->to_lower ? my_tolower(charset,ch) :

ch - 'A' + 'a');

}

else if (my_islower(charset,ch))

{

return(charset->to_upper ? my_toupper(charset,ch) :

ch - 'a' + 'A');

}

else /* peculiar, but could happen */

return(ch);

}

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(p->charset, 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;

}

static void

ordinary(p, ch)

register struct parse *p;

register int ch;

{

register cat_t *cap = p->g->categories;

if ((p->g->cflags&MY_REG_ICASE) && my_isalpha(p->charset,ch) &&

othercase(p->charset,ch) != ch)

bothcases(p, ch);

else {

EMIT(OCHAR, (unsigned char)ch);

if (cap[ch] == 0)

cap[ch] = p->g->ncategories++;

}

}

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;

}

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 RE_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) == RE_INFINITY) ? INF : N)

register sopno copy;