1N/A#pragma prototyped

1N/A

1N/A

1N/A#include "reglib.h"

1N/A

1N/Astatic const regflags_t submap[] =

1N/A{

1N/A 'g', REG_SUB_ALL,

1N/A 'l', REG_SUB_LOWER,

1N/A 'n', REG_SUB_NUMBER,

1N/A 'p', REG_SUB_PRINT,

1N/A 's', REG_SUB_STOP,

1N/A 'u', REG_SUB_UPPER,

1N/A 'w', REG_SUB_WRITE|REG_SUB_LAST,

1N/A 0, 0

1N/A};

1N/A

1N/Aregsubflags(regex_t* p, register const char* s, char** e, int delim, register const regflags_t* map, int* pm, regflags_t* pf)

1N/A{

1N/A register int c;

1N/A register const regflags_t* m;

1N/A regflags_t flags;

1N/A int minmatch;

1N/A regdisc_t* disc;

1N/A

1N/A flags = pf ? *pf : 0;

1N/A minmatch = pm ? *pm : 0;

1N/A if (!map)

1N/A map = submap;

1N/A while (!(flags & REG_SUB_LAST))

1N/A {

1N/A if (!(c = *s++) || c == delim)

1N/A {

1N/A s--;

1N/A break;

1N/A }

1N/A else if (c >= '0' && c <= '9')

1N/A {

1N/A if (minmatch)

1N/A {

1N/A disc = p->env->disc;

1N/A regfree(p);

1N/A return fatal(disc, REG_EFLAGS, s - 1);

1N/A }

1N/A minmatch = c - '0';

1N/A while (*s >= '0' && *s <= '9')

1N/A minmatch = minmatch * 10 + *s++ - '0';

1N/A }

1N/A else

1N/A {

1N/A for (m = map; *m; m++)

1N/A if (*m++ == c)

1N/A {

1N/A if (flags & *m)

1N/A {

1N/A disc = p->env->disc;

1N/A regfree(p);

1N/A return fatal(disc, REG_EFLAGS, s - 1);

1N/A }

1N/A flags |= *m--;

1N/A break;

1N/A }

1N/A if (!*m)

1N/A {

1N/A s--;

1N/A break;

1N/A }

1N/A }

1N/A }

1N/A if (pf)

1N/A *pf = flags;

1N/A if (pm)

1N/A *pm = minmatch;

1N/A if (e)

1N/A *e = (char*)s;

1N/A return 0;

1N/A}

1N/A

1N/A

1N/Aregsubcomp(regex_t* p, register const char* s, const regflags_t* map, int minmatch, regflags_t flags)

1N/A{

1N/A register regsub_t* sub;

1N/A register int c;

1N/A register int d;

1N/A register char* t;

1N/A register regsubop_t* op;

1N/A char* e;

1N/A const char* r;

1N/A int sre;

1N/A int f;

1N/A int g;

1N/A int n;

1N/A int nops;

1N/A const char* o;

1N/A regdisc_t* disc;

1N/A

1N/A disc = p->env->disc;

1N/A if (p->env->flags & REG_NOSUB)

1N/A {

1N/A regfree(p);

1N/A return fatal(disc, REG_BADPAT, NiL);

1N/A }

1N/A if (!(sub = (regsub_t*)alloc(p->env->disc, 0, sizeof(regsub_t) + strlen(s))) || !(sub->re_ops = (regsubop_t*)alloc(p->env->disc, 0, (nops = 8) * sizeof(regsubop_t))))

1N/A {

1N/A if (sub)

1N/A alloc(p->env->disc, sub, 0);

1N/A regfree(p);

1N/A return fatal(disc, REG_ESPACE, s);

1N/A }

1N/A sub->re_buf = sub->re_end = 0;

1N/A p->re_sub = sub;

1N/A p->env->sub = 1;

1N/A op = sub->re_ops;

1N/A o = s;

1N/A if (!(p->env->flags & REG_DELIMITED))

1N/A d = 0;

1N/A else

1N/A switch (d = *(s - 1))

1N/A {

1N/A case '\\':

1N/A case '\n':

1N/A case '\r':

1N/A regfree(p);

1N/A return fatal(disc, REG_EDELIM, s);

1N/A }

1N/A sre = p->env->flags & REG_SHELL;

1N/A t = sub->re_rhs;

1N/A if (d)

1N/A {

1N/A r = s;

1N/A for (;;)

1N/A {

1N/A if (!*s)

1N/A {

1N/A if (p->env->flags & REG_MUSTDELIM)

1N/A {

1N/A regfree(p);

1N/A return fatal(disc, REG_EDELIM, r);

1N/A }

1N/A break;

1N/A }

1N/A else if (*s == d)

1N/A {

1N/A flags |= REG_SUB_FULL;

1N/A s++;

1N/A break;

1N/A }

1N/A else if (*s++ == '\\' && !*s++)

1N/A {

1N/A regfree(p);

1N/A return fatal(disc, REG_EESCAPE, r);

1N/A }

1N/A }

1N/A if (*s)

1N/A {

1N/A if (n = regsubflags(p, s, &e, d, map, &minmatch, &flags))

1N/A return n;

1N/A s = (const char*)e;

1N/A }

1N/A p->re_npat = s - o;

1N/A s = r;

1N/A }

1N/A else

1N/A p->re_npat = 0;

1N/A op->op = f = g = flags & (REG_SUB_LOWER|REG_SUB_UPPER);

1N/A op->off = 0;

1N/A while ((c = *s++) != d)

1N/A {

1N/A again:

1N/A if (!c)

1N/A {

1N/A p->re_npat = s - o - 1;

1N/A break;

1N/A }

1N/A else if (c == '\\')

1N/A {

1N/A if (*s == c)

1N/A {

1N/A *t++ = *s++;

1N/A continue;

1N/A }

1N/A if ((c = *s++) == d)

1N/A goto again;

1N/A if (!c)

1N/A {

1N/A regfree(p);

1N/A return fatal(disc, REG_EESCAPE, s - 2);

1N/A }

1N/A if (c == '&')

1N/A {

1N/A *t++ = c;

1N/A continue;

1N/A }

1N/A }

1N/A else if (c == '&')

1N/A {

1N/A if (sre)

1N/A {

1N/A *t++ = c;

1N/A continue;

1N/A }

1N/A }

1N/A else

1N/A {

1N/A switch (op->op)

1N/A {

1N/A case REG_SUB_UPPER:

1N/A if (islower(c))

1N/A c = toupper(c);

1N/A break;

1N/A case REG_SUB_LOWER:

1N/A if (isupper(c))

1N/A c = tolower(c);

1N/A break;

1N/A case REG_SUB_UPPER|REG_SUB_LOWER:

1N/A if (isupper(c))

1N/A c = tolower(c);

1N/A else if (islower(c))

1N/A c = toupper(c);

1N/A break;

1N/A }

1N/A *t++ = c;

1N/A continue;

1N/A }

1N/A switch (c)

1N/A {

1N/A case 0:

1N/A s--;

1N/A continue;

1N/A case '&':

1N/A c = 0;

1N/A break;

1N/A case '0': case '1': case '2': case '3': case '4':

1N/A case '5': case '6': case '7': case '8': case '9':

1N/A c -= '0';

1N/A if (isdigit(*s) && (p->env->flags & REG_MULTIREF))

1N/A c = c * 10 + *s++ - '0';

1N/A break;

1N/A case 'l':

1N/A if (c = *s)

1N/A {

1N/A s++;

1N/A if (isupper(c))

1N/A c = tolower(c);

1N/A *t++ = c;

1N/A }

1N/A continue;

1N/A case 'u':

1N/A if (c = *s)

1N/A {

1N/A s++;

1N/A if (islower(c))

1N/A c = toupper(c);

1N/A *t++ = c;

1N/A }

1N/A continue;

1N/A case 'E':

1N/A f = g;

1N/A set:

1N/A if ((op->len = (t - sub->re_rhs) - op->off) && (n = ++op - sub->re_ops) >= nops)

1N/A {

1N/A if (!(sub->re_ops = (regsubop_t*)alloc(p->env->disc, sub->re_ops, (nops *= 2) * sizeof(regsubop_t))))

1N/A {

1N/A regfree(p);

1N/A return fatal(disc, REG_ESPACE, NiL);

1N/A }

1N/A op = sub->re_ops + n;

1N/A }

1N/A op->op = f;

1N/A op->off = t - sub->re_rhs;

1N/A continue;

1N/A case 'L':

1N/A g = f;

1N/A f = REG_SUB_LOWER;

1N/A goto set;

1N/A case 'U':

1N/A g = f;

1N/A f = REG_SUB_UPPER;

1N/A goto set;

1N/A default:

1N/A if (!sre)

1N/A {

1N/A *t++ = chresc(s - 2, &e);

1N/A s = (const char*)e;

1N/A continue;

1N/A }

1N/A s--;

1N/A c = -1;

1N/A break;

1N/A }

1N/A if (c > p->re_nsub)

1N/A {

1N/A regfree(p);

1N/A return fatal(disc, REG_ESUBREG, s - 1);

1N/A }

1N/A if ((n = op - sub->re_ops) >= (nops - 2))

1N/A {

1N/A if (!(sub->re_ops = (regsubop_t*)alloc(p->env->disc, sub->re_ops, (nops *= 2) * sizeof(regsubop_t))))

1N/A {

1N/A regfree(p);

1N/A return fatal(disc, REG_ESPACE, NiL);

1N/A }

1N/A op = sub->re_ops + n;

1N/A }

1N/A if (op->len = (t - sub->re_rhs) - op->off)

1N/A op++;

1N/A op->op = f;

1N/A op->off = c;

1N/A op->len = 0;

1N/A op++;

1N/A op->op = f;

1N/A op->off = t - sub->re_rhs;

1N/A }

1N/A if ((op->len = (t - sub->re_rhs) - op->off) && (n = ++op - sub->re_ops) >= nops)

1N/A {

1N/A if (!(sub->re_ops = (regsubop_t*)alloc(p->env->disc, sub->re_ops, (nops *= 2) * sizeof(regsubop_t))))

1N/A {

1N/A regfree(p);

1N/A return fatal(disc, REG_ESPACE, NiL);

1N/A }

1N/A op = sub->re_ops + n;

1N/A }

1N/A op->len = -1;

1N/A sub->re_flags = flags;

1N/A sub->re_min = minmatch;

1N/A return 0;

1N/A}

1N/A

1N/Aregsubfree(regex_t* p)

1N/A{

1N/A Env_t* env;

1N/A regsub_t* sub;

1N/A

1N/A if (p && (env = p->env) && env->sub && (sub = p->re_sub))

1N/A {

1N/A env->sub = 0;

1N/A p->re_sub = 0;

1N/A if (!(env->disc->re_flags & REG_NOFREE))

1N/A {

1N/A if (sub->re_buf)

1N/A alloc(env->disc, sub->re_buf, 0);

1N/A if (sub->re_ops)

1N/A alloc(env->disc, sub->re_ops, 0);

1N/A alloc(env->disc, sub, 0);

1N/A }

1N/A }

1N/A}