Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions 8 Packages Projects Releases Wiki Activity

reverted to TCL version of regex library

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@25865 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Václav Slavík
2004-02-19 16:47:02 +00:00
parent bf25c88b6a
commit 3ca4086b22
14 changed files with 4958 additions and 4879 deletions
Download Patch File Download Diff File Expand all files Collapse all files

378
src/regex/regc_color.c
View File

@@ -28,7 +28,6 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* $Header$
* *
* *
* Note that there are some incestuous relationships between this code and * Note that there are some incestuous relationships between this code and
@@ -43,11 +42,13 @@
/* /*
* initcm - set up new colormap - initcm - set up new colormap
^ static VOID initcm(struct vars *, struct colormap *);
*/ */
static void static VOID
initcm(struct vars * v, initcm(v, cm)
struct colormap * cm) struct vars *v;
struct colormap *cm;
{ {
int i; int i;
int j; int j;
@@ -70,8 +71,7 @@ initcm(struct vars * v,
cd->nchrs = CHR_MAX - CHR_MIN + 1; cd->nchrs = CHR_MAX - CHR_MIN + 1;
/* upper levels of tree */ /* upper levels of tree */
for (t = &cm->tree[0], j = NBYTS - 1; j > 0; t = nextt, j--) for (t = &cm->tree[0], j = NBYTS-1; j > 0; t = nextt, j--) {
{
nextt = t + 1; nextt = t + 1;
for (i = BYTTAB-1; i >= 0; i--) for (i = BYTTAB-1; i >= 0; i--)
t->tptr[i] = nextt; t->tptr[i] = nextt;
@@ -84,10 +84,12 @@ initcm(struct vars * v,
} }
/* /*
* freecm - free dynamically-allocated things in a colormap - freecm - free dynamically-allocated things in a colormap
^ static VOID freecm(struct colormap *);
*/ */
static void static VOID
freecm(struct colormap * cm) freecm(cm)
struct colormap *cm;
{ {
size_t i; size_t i;
union tree *cb; union tree *cb;
@@ -96,8 +98,7 @@ freecm(struct colormap * cm)
if (NBYTS > 1) if (NBYTS > 1)
cmtreefree(cm, cm->tree, 0); cmtreefree(cm, cm->tree, 0);
for (i = 1; i <= cm->max; i++) /* skip WHITE */ for (i = 1; i <= cm->max; i++) /* skip WHITE */
if (!UNUSEDCOLOR(&cm->cd[i])) if (!UNUSEDCOLOR(&cm->cd[i])) {
{
cb = cm->cd[i].block; cb = cm->cd[i].block;
if (cb != NULL) if (cb != NULL)
FREE(cb); FREE(cb);
@@ -107,12 +108,14 @@ freecm(struct colormap * cm)
} }
/* /*
* cmtreefree - free a non-terminal part of a colormap tree - cmtreefree - free a non-terminal part of a colormap tree
^ static VOID cmtreefree(struct colormap *, union tree *, int);
*/ */
static void static VOID
cmtreefree(struct colormap * cm, cmtreefree(cm, tree, level)
union tree * tree, struct colormap *cm;
int level) /* level number (top == 0) of this block */ union tree *tree;
int level; /* level number (top == 0) of this block */
{ {
int i; int i;
union tree *t; union tree *t;
@@ -120,19 +123,14 @@ cmtreefree(struct colormap * cm,
union tree *cb; union tree *cb;
assert(level < NBYTS-1); /* this level has pointers */ assert(level < NBYTS-1); /* this level has pointers */
for (i = BYTTAB - 1; i >= 0; i--) for (i = BYTTAB-1; i >= 0; i--) {
{
t = tree->tptr[i]; t = tree->tptr[i];
assert(t != NULL); assert(t != NULL);
if (t != fillt) if (t != fillt) {
{ if (level < NBYTS-2) { /* more pointer blocks below */
if (level < NBYTS - 2)
{ /* more pointer blocks below */
cmtreefree(cm, t, level+1); cmtreefree(cm, t, level+1);
FREE(t); FREE(t);
} } else { /* color block below */
else
{ /* color block below */
cb = cm->cd[t->tcolor[0]].block; cb = cm->cd[t->tcolor[0]].block;
if (t != cb) /* not a solid block */ if (t != cb) /* not a solid block */
FREE(t); FREE(t);
@@ -142,12 +140,14 @@ cmtreefree(struct colormap * cm,
} }
/* /*
* setcolor - set the color of a character in a colormap - setcolor - set the color of a character in a colormap
^ static color setcolor(struct colormap *, pchr, pcolor);
*/ */
static color /* previous color */ static color /* previous color */
setcolor(struct colormap * cm, setcolor(cm, c, co)
chr c, struct colormap *cm;
pcolor co) pchr c;
pcolor co;
{ {
uchr uc = c; uchr uc = c;
int shift; int shift;
@@ -167,8 +167,7 @@ setcolor(struct colormap * cm,
t = cm->tree; t = cm->tree;
for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0; for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0;
level++, shift -= BYTBITS) level++, shift -= BYTBITS) {
{
b = (uc >> shift) & BYTMASK; b = (uc >> shift) & BYTMASK;
lastt = t; lastt = t;
t = lastt->tptr[b]; t = lastt->tptr[b];
@@ -176,12 +175,10 @@ setcolor(struct colormap * cm,
fillt = &cm->tree[level+1]; fillt = &cm->tree[level+1];
bottom = (shift <= BYTBITS) ? 1 : 0; bottom = (shift <= BYTBITS) ? 1 : 0;
cb = (bottom) ? cm->cd[t->tcolor[0]].block : fillt; cb = (bottom) ? cm->cd[t->tcolor[0]].block : fillt;
if (t == fillt || t == cb) if (t == fillt || t == cb) { /* must allocate a new block */
{ /* must allocate a new block */
newt = (union tree *)MALLOC((bottom) ? newt = (union tree *)MALLOC((bottom) ?
sizeof(struct colors) : sizeof(struct ptrs)); sizeof(struct colors) : sizeof(struct ptrs));
if (newt == NULL) if (newt == NULL) {
{
CERR(REG_ESPACE); CERR(REG_ESPACE);
return COLORLESS; return COLORLESS;
} }
@@ -203,10 +200,12 @@ setcolor(struct colormap * cm,
} }
/* /*
* maxcolor - report largest color number in use - maxcolor - report largest color number in use
^ static color maxcolor(struct colormap *);
*/ */
static color static color
maxcolor(struct colormap * cm) maxcolor(cm)
struct colormap *cm;
{ {
if (CISERR()) if (CISERR())
return COLORLESS; return COLORLESS;
@@ -215,11 +214,13 @@ maxcolor(struct colormap * cm)
} }
/* /*
* newcolor - find a new color (must be subject of setcolor at once) - newcolor - find a new color (must be subject of setcolor at once)
* Beware: may relocate the colordescs. * Beware: may relocate the colordescs.
^ static color newcolor(struct colormap *);
*/ */
static color /* COLORLESS for error */ static color /* COLORLESS for error */
newcolor(struct colormap * cm) newcolor(cm)
struct colormap *cm;
{ {
struct colordesc *cd; struct colordesc *cd;
struct colordesc *new; struct colordesc *new;
@@ -228,37 +229,29 @@ newcolor(struct colormap * cm)
if (CISERR()) if (CISERR())
return COLORLESS; return COLORLESS;
if (cm->free != 0) if (cm->free != 0) {
{
assert(cm->free > 0); assert(cm->free > 0);
assert((size_t)cm->free < cm->ncds); assert((size_t)cm->free < cm->ncds);
cd = &cm->cd[cm->free]; cd = &cm->cd[cm->free];
assert(UNUSEDCOLOR(cd)); assert(UNUSEDCOLOR(cd));
assert(cd->arcs == NULL); assert(cd->arcs == NULL);
cm->free = cd->sub; cm->free = cd->sub;
} } else if (cm->max < cm->ncds - 1) {
else if (cm->max < cm->ncds - 1)
{
cm->max++; cm->max++;
cd = &cm->cd[cm->max]; cd = &cm->cd[cm->max];
} } else {
else
{
/* oops, must allocate more */ /* oops, must allocate more */
n = cm->ncds * 2; n = cm->ncds * 2;
if (cm->cd == cm->cdspace) if (cm->cd == cm->cdspace) {
{
new = (struct colordesc *)MALLOC(n * new = (struct colordesc *)MALLOC(n *
sizeof(struct colordesc)); sizeof(struct colordesc));
if (new != NULL) if (new != NULL)
memcpy(VS(new), VS(cm->cdspace), cm->ncds * memcpy(VS(new), VS(cm->cdspace), cm->ncds *
sizeof(struct colordesc)); sizeof(struct colordesc));
} } else
else
new = (struct colordesc *)REALLOC(cm->cd, new = (struct colordesc *)REALLOC(cm->cd,
n * sizeof(struct colordesc)); n * sizeof(struct colordesc));
if (new == NULL) if (new == NULL) {
{
CERR(REG_ESPACE); CERR(REG_ESPACE);
return COLORLESS; return COLORLESS;
} }
@@ -279,15 +272,16 @@ newcolor(struct colormap * cm)
} }
/* /*
* freecolor - free a color (must have no arcs or subcolor) - freecolor - free a color (must have no arcs or subcolor)
^ static VOID freecolor(struct colormap *, pcolor);
*/ */
static void static VOID
freecolor(struct colormap * cm, freecolor(cm, co)
pcolor co) struct colormap *cm;
pcolor co;
{ {
struct colordesc *cd = &cm->cd[co]; struct colordesc *cd = &cm->cd[co];
color pco, color pco, nco; /* for freelist scan */
nco; /* for freelist scan */
assert(co >= 0); assert(co >= 0);
if (co == WHITE) if (co == WHITE)
@@ -297,51 +291,45 @@ freecolor(struct colormap * cm,
assert(cd->sub == NOSUB); assert(cd->sub == NOSUB);
assert(cd->nchrs == 0); assert(cd->nchrs == 0);
cd->flags = FREECOL; cd->flags = FREECOL;
if (cd->block != NULL) if (cd->block != NULL) {
{
FREE(cd->block); FREE(cd->block);
cd->block = NULL; /* just paranoia */ cd->block = NULL; /* just paranoia */
} }
if ((size_t) co == cm->max) if ((size_t)co == cm->max) {
{
while (cm->max > WHITE && UNUSEDCOLOR(&cm->cd[cm->max])) while (cm->max > WHITE && UNUSEDCOLOR(&cm->cd[cm->max]))
cm->max--; cm->max--;
assert(cm->free >= 0); assert(cm->free >= 0);
while ((size_t)cm->free > cm->max) while ((size_t)cm->free > cm->max)
cm->free = cm->cd[cm->free].sub; cm->free = cm->cd[cm->free].sub;
if (cm->free > 0) if (cm->free > 0) {
{
assert(cm->free < cm->max); assert(cm->free < cm->max);
pco = cm->free; pco = cm->free;
nco = cm->cd[pco].sub; nco = cm->cd[pco].sub;
while (nco > 0) while (nco > 0)
if ((size_t) nco > cm->max) if ((size_t)nco > cm->max) {
{
/* take this one out of freelist */ /* take this one out of freelist */
nco = cm->cd[nco].sub; nco = cm->cd[nco].sub;
cm->cd[pco].sub = nco; cm->cd[pco].sub = nco;
} } else {
else
{
assert(nco < cm->max); assert(nco < cm->max);
pco = nco; pco = nco;
nco = cm->cd[pco].sub; nco = cm->cd[pco].sub;
} }
} }
} } else {
else
{
cd->sub = cm->free; cd->sub = cm->free;
cm->free = (color)(cd - cm->cd); cm->free = (color)(cd - cm->cd);
} }
} }
/* /*
* pseudocolor - allocate a false color, to be managed by other means - pseudocolor - allocate a false color, to be managed by other means
^ static color pseudocolor(struct colormap *);
*/ */
static color static color
pseudocolor(struct colormap * cm) pseudocolor(cm)
struct colormap *cm;
{ {
color co; color co;
@@ -354,10 +342,13 @@ pseudocolor(struct colormap * cm)
} }
/* /*
* subcolor - allocate a new subcolor (if necessary) to this chr - subcolor - allocate a new subcolor (if necessary) to this chr
^ static color subcolor(struct colormap *, pchr c);
*/ */
static color static color
subcolor(struct colormap * cm, chr c) subcolor(cm, c)
struct colormap *cm;
pchr c;
{ {
color co; /* current color of c */ color co; /* current color of c */
color sco; /* new subcolor */ color sco; /* new subcolor */
@@ -377,22 +368,22 @@ subcolor(struct colormap * cm, chr c)
} }
/* /*
* newsub - allocate a new subcolor (if necessary) for a color - newsub - allocate a new subcolor (if necessary) for a color
^ static color newsub(struct colormap *, pcolor);
*/ */
static color static color
newsub(struct colormap * cm, newsub(cm, co)
pcolor co) struct colormap *cm;
pcolor co;
{ {
color sco; /* new subcolor */ color sco; /* new subcolor */
sco = cm->cd[co].sub; sco = cm->cd[co].sub;
if (sco == NOSUB) if (sco == NOSUB) { /* color has no open subcolor */
{ /* color has no open subcolor */
if (cm->cd[co].nchrs == 1) /* optimization */ if (cm->cd[co].nchrs == 1) /* optimization */
return co; return co;
sco = newcolor(cm); /* must create subcolor */ sco = newcolor(cm); /* must create subcolor */
if (sco == COLORLESS) if (sco == COLORLESS) {
{
assert(CISERR()); assert(CISERR());
return COLORLESS; return COLORLESS;
} }
@@ -405,14 +396,17 @@ newsub(struct colormap * cm,
} }
/* /*
* subrange - allocate new subcolors to this range of chrs, fill in arcs - subrange - allocate new subcolors to this range of chrs, fill in arcs
^ static VOID subrange(struct vars *, pchr, pchr, struct state *,
^ struct state *);
*/ */
static void static VOID
subrange(struct vars * v, subrange(v, from, to, lp, rp)
chr from, struct vars *v;
chr to, pchr from;
struct state * lp, pchr to;
struct state * rp) struct state *lp;
struct state *rp;
{ {
uchr uf; uchr uf;
int i; int i;
@@ -437,13 +431,15 @@ subrange(struct vars * v,
} }
/* /*
* subblock - allocate new subcolors for one tree block of chrs, fill in arcs - subblock - allocate new subcolors for one tree block of chrs, fill in arcs
^ static VOID subblock(struct vars *, pchr, struct state *, struct state *);
*/ */
static void static VOID
subblock(struct vars * v, subblock(v, start, lp, rp)
chr start, /* first of BYTTAB chrs */ struct vars *v;
struct state * lp, pchr start; /* first of BYTTAB chrs */
struct state * rp) struct state *lp;
struct state *rp;
{ {
uchr uc = start; uchr uc = start;
struct colormap *cm = v->cm; struct colormap *cm = v->cm;
@@ -466,18 +462,15 @@ subblock(struct vars * v,
t = cm->tree; t = cm->tree;
fillt = NULL; fillt = NULL;
for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0; for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0;
level++, shift -= BYTBITS) level++, shift -= BYTBITS) {
{
b = (uc >> shift) & BYTMASK; b = (uc >> shift) & BYTMASK;
lastt = t; lastt = t;
t = lastt->tptr[b]; t = lastt->tptr[b];
assert(t != NULL); assert(t != NULL);
fillt = &cm->tree[level+1]; fillt = &cm->tree[level+1];
if (t == fillt && shift > BYTBITS) if (t == fillt && shift > BYTBITS) { /* need new ptr block */
{ /* need new ptr block */
t = (union tree *)MALLOC(sizeof(struct ptrs)); t = (union tree *)MALLOC(sizeof(struct ptrs));
if (t == NULL) if (t == NULL) {
{
CERR(REG_ESPACE); CERR(REG_ESPACE);
return; return;
} }
@@ -490,16 +483,13 @@ subblock(struct vars * v,
/* special cases: fill block or solid block */ /* special cases: fill block or solid block */
co = t->tcolor[0]; co = t->tcolor[0];
cb = cm->cd[co].block; cb = cm->cd[co].block;
if (t == fillt || t == cb) if (t == fillt || t == cb) {
{
/* either way, we want a subcolor solid block */ /* either way, we want a subcolor solid block */
sco = newsub(cm, co); sco = newsub(cm, co);
t = cm->cd[sco].block; t = cm->cd[sco].block;
if (t == NULL) if (t == NULL) { /* must set it up */
{ /* must set it up */
t = (union tree *)MALLOC(sizeof(struct colors)); t = (union tree *)MALLOC(sizeof(struct colors));
if (t == NULL) if (t == NULL) {
{
CERR(REG_ESPACE); CERR(REG_ESPACE);
return; return;
} }
@@ -517,14 +507,12 @@ subblock(struct vars * v,
/* general case, a mixed block to be altered */ /* general case, a mixed block to be altered */
i = 0; i = 0;
while (i < BYTTAB) while (i < BYTTAB) {
{
co = t->tcolor[i]; co = t->tcolor[i];
sco = newsub(cm, co); sco = newsub(cm, co);
newarc(v->nfa, PLAIN, sco, lp, rp); newarc(v->nfa, PLAIN, sco, lp, rp);
previ = i; previ = i;
do do {
{
t->tcolor[i++] = sco; t->tcolor[i++] = sco;
} while (i < BYTTAB && t->tcolor[i] == co); } while (i < BYTTAB && t->tcolor[i] == co);
ndone = i - previ; ndone = i - previ;
@@ -534,11 +522,13 @@ subblock(struct vars * v,
} }
/* /*
* okcolors - promote subcolors to full colors - okcolors - promote subcolors to full colors
^ static VOID okcolors(struct nfa *, struct colormap *);
*/ */
static void static VOID
okcolors(struct nfa * nfa, okcolors(nfa, cm)
struct colormap * cm) struct nfa *nfa;
struct colormap *cm;
{ {
struct colordesc *cd; struct colordesc *cd;
struct colordesc *end = CDEND(cm); struct colordesc *end = CDEND(cm);
@@ -547,27 +537,20 @@ okcolors(struct nfa * nfa,
color co; color co;
color sco; color sco;
for (cd = cm->cd, co = 0; cd < end; cd++, co++) for (cd = cm->cd, co = 0; cd < end; cd++, co++) {
{
sco = cd->sub; sco = cd->sub;
if (UNUSEDCOLOR(cd) || sco == NOSUB) if (UNUSEDCOLOR(cd) || sco == NOSUB) {
{
/* has no subcolor, no further action */ /* has no subcolor, no further action */
} } else if (sco == co) {
else if (sco == co)
{
/* is subcolor, let parent deal with it */ /* is subcolor, let parent deal with it */
} } else if (cd->nchrs == 0) {
else if (cd->nchrs == 0)
{
/* parent empty, its arcs change color to subcolor */ /* parent empty, its arcs change color to subcolor */
cd->sub = NOSUB; cd->sub = NOSUB;
scd = &cm->cd[sco]; scd = &cm->cd[sco];
assert(scd->nchrs > 0); assert(scd->nchrs > 0);
assert(scd->sub == sco); assert(scd->sub == sco);
scd->sub = NOSUB; scd->sub = NOSUB;
while ((a = cd->arcs) != NULL) while ((a = cd->arcs) != NULL) {
{
assert(a->co == co); assert(a->co == co);
/* uncolorchain(cm, a); */ /* uncolorchain(cm, a); */
cd->arcs = a->colorchain; cd->arcs = a->colorchain;
@@ -577,17 +560,14 @@ okcolors(struct nfa * nfa,
scd->arcs = a; scd->arcs = a;
} }
freecolor(cm, co); freecolor(cm, co);
} } else {
else
{
/* parent's arcs must gain parallel subcolor arcs */ /* parent's arcs must gain parallel subcolor arcs */
cd->sub = NOSUB; cd->sub = NOSUB;
scd = &cm->cd[sco]; scd = &cm->cd[sco];
assert(scd->nchrs > 0); assert(scd->nchrs > 0);
assert(scd->sub == sco); assert(scd->sub == sco);
scd->sub = NOSUB; scd->sub = NOSUB;
for (a = cd->arcs; a != NULL; a = a->colorchain) for (a = cd->arcs; a != NULL; a = a->colorchain) {
{
assert(a->co == co); assert(a->co == co);
newarc(nfa, a->type, sco, a->from, a->to); newarc(nfa, a->type, sco, a->from, a->to);
} }
@@ -596,11 +576,13 @@ okcolors(struct nfa * nfa,
} }
/* /*
* colorchain - add this arc to the color chain of its color - colorchain - add this arc to the color chain of its color
^ static VOID colorchain(struct colormap *, struct arc *);
*/ */
static void static VOID
colorchain(struct colormap * cm, colorchain(cm, a)
struct arc * a) struct colormap *cm;
struct arc *a;
{ {
struct colordesc *cd = &cm->cd[a->co]; struct colordesc *cd = &cm->cd[a->co];
@@ -609,11 +591,13 @@ colorchain(struct colormap * cm,
} }
/* /*
* uncolorchain - delete this arc from the color chain of its color - uncolorchain - delete this arc from the color chain of its color
^ static VOID uncolorchain(struct colormap *, struct arc *);
*/ */
static void static VOID
uncolorchain(struct colormap * cm, uncolorchain(cm, a)
struct arc * a) struct colormap *cm;
struct arc *a;
{ {
struct colordesc *cd = &cm->cd[a->co]; struct colordesc *cd = &cm->cd[a->co];
struct arc *aa; struct arc *aa;
@@ -621,8 +605,7 @@ uncolorchain(struct colormap * cm,
aa = cd->arcs; aa = cd->arcs;
if (aa == a) /* easy case */ if (aa == a) /* easy case */
cd->arcs = a->colorchain; cd->arcs = a->colorchain;
else else {
{
for (; aa != NULL && aa->colorchain != a; aa = aa->colorchain) for (; aa != NULL && aa->colorchain != a; aa = aa->colorchain)
continue; continue;
assert(aa != NULL); assert(aa != NULL);
@@ -632,11 +615,13 @@ uncolorchain(struct colormap * cm,
} }
/* /*
* singleton - is this character in its own color? - singleton - is this character in its own color?
^ static int singleton(struct colormap *, pchr c);
*/ */
static int /* predicate */ static int /* predicate */
singleton(struct colormap * cm, singleton(cm, c)
chr c) struct colormap *cm;
pchr c;
{ {
color co; /* color of c */ color co; /* color of c */
@@ -647,15 +632,18 @@ singleton(struct colormap * cm,
} }
/* /*
* rainbow - add arcs of all full colors (but one) between specified states - rainbow - add arcs of all full colors (but one) between specified states
^ static VOID rainbow(struct nfa *, struct colormap *, int, pcolor,
^ struct state *, struct state *);
*/ */
static void static VOID
rainbow(struct nfa * nfa, rainbow(nfa, cm, type, but, from, to)
struct colormap * cm, struct nfa *nfa;
int type, struct colormap *cm;
pcolor but, /* COLORLESS if no exceptions */ int type;
struct state * from, pcolor but; /* COLORLESS if no exceptions */
struct state * to) struct state *from;
struct state *to;
{ {
struct colordesc *cd; struct colordesc *cd;
struct colordesc *end = CDEND(cm); struct colordesc *end = CDEND(cm);
@@ -668,18 +656,19 @@ rainbow(struct nfa * nfa,
} }
/* /*
* colorcomplement - add arcs of complementary colors - colorcomplement - add arcs of complementary colors
*
* The calling sequence ought to be reconciled with cloneouts(). * The calling sequence ought to be reconciled with cloneouts().
^ static VOID colorcomplement(struct nfa *, struct colormap *, int,
^ struct state *, struct state *, struct state *);
*/ */
static void static VOID
colorcomplement(struct nfa * nfa, colorcomplement(nfa, cm, type, of, from, to)
struct colormap * cm, struct nfa *nfa;
int type, struct colormap *cm;
struct state * of, /* complements of this guy's PLAIN int type;
* outarcs */ struct state *of; /* complements of this guy's PLAIN outarcs */
struct state * from, struct state *from;
struct state * to) struct state *to;
{ {
struct colordesc *cd; struct colordesc *cd;
struct colordesc *end = CDEND(cm); struct colordesc *end = CDEND(cm);
@@ -693,14 +682,20 @@ colorcomplement(struct nfa * nfa,
} }
#ifdef REG_DEBUG #ifdef REG_DEBUG
/*
^ #ifdef REG_DEBUG
*/
/* /*
* dumpcolors - debugging output - dumpcolors - debugging output
^ static VOID dumpcolors(struct colormap *, FILE *);
*/ */
static void static VOID
dumpcolors(struct colormap * cm, dumpcolors(cm, f)
FILE *f) struct colormap *cm;
FILE *f;
{ {
struct colordesc *cd; struct colordesc *cd;
struct colordesc *end; struct colordesc *end;
@@ -713,8 +708,7 @@ dumpcolors(struct colormap * cm,
fillcheck(cm, cm->tree, 0, f); fillcheck(cm, cm->tree, 0, f);
end = CDEND(cm); end = CDEND(cm);
for (cd = cm->cd + 1, co = 1; cd < end; cd++, co++) /* skip 0 */ for (cd = cm->cd + 1, co = 1; cd < end; cd++, co++) /* skip 0 */
if (!UNUSEDCOLOR(cd)) if (!UNUSEDCOLOR(cd)) {
{
assert(cd->nchrs > 0); assert(cd->nchrs > 0);
has = (cd->block != NULL) ? "#" : ""; has = (cd->block != NULL) ? "#" : "";
if (cd->flags&PSEUDO) if (cd->flags&PSEUDO)
@@ -734,51 +728,51 @@ dumpcolors(struct colormap * cm,
} }
/* /*
* fillcheck - check proper filling of a tree - fillcheck - check proper filling of a tree
^ static VOID fillcheck(struct colormap *, union tree *, int, FILE *);
*/ */
static void static VOID
fillcheck(struct colormap * cm, fillcheck(cm, tree, level, f)
union tree * tree, struct colormap *cm;
int level, /* level number (top == 0) of this block */ union tree *tree;
FILE *f) int level; /* level number (top == 0) of this block */
FILE *f;
{ {
int i; int i;
union tree *t; union tree *t;
union tree *fillt = &cm->tree[level+1]; union tree *fillt = &cm->tree[level+1];
assert(level < NBYTS-1); /* this level has pointers */ assert(level < NBYTS-1); /* this level has pointers */
for (i = BYTTAB - 1; i >= 0; i--) for (i = BYTTAB-1; i >= 0; i--) {
{
t = tree->tptr[i]; t = tree->tptr[i];
if (t == NULL) if (t == NULL)
fprintf(f, "NULL found in filled tree!\n"); fprintf(f, "NULL found in filled tree!\n");
else if (t == fillt) else if (t == fillt)
{ {}
}
else if (level < NBYTS-2) /* more pointer blocks below */ else if (level < NBYTS-2) /* more pointer blocks below */
fillcheck(cm, t, level+1, f); fillcheck(cm, t, level+1, f);
} }
} }
/* /*
* dumpchr - print a chr - dumpchr - print a chr
*
* Kind of char-centric but works well enough for debug use. * Kind of char-centric but works well enough for debug use.
^ static VOID dumpchr(pchr, FILE *);
*/ */
static void static VOID
dumpchr(chr c, dumpchr(c, f)
FILE *f) pchr c;
FILE *f;
{ {
#if wxUSE_UNICODE
fprintf(f, "Debugging not implemented in unicode mode");
#else
if (c == '\\') if (c == '\\')
fprintf(f, "\\\\"); fprintf(f, "\\\\");
else if (c > ' ' && c <= '~') else if (c > ' ' && c <= '~')
putc((char)c, f); putc((char)c, f);
else else
fprintf(f, "\\u%04lx", (long)c); fprintf(f, "\\u%04lx", (long)c);
#endif
} }
#endif /* REG_DEBUG */ /*
^ #endif
*/
#endif /* ifdef REG_DEBUG */

117
src/regex/regc_cvec.c
View File

@@ -28,32 +28,31 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* $Header$
*
*/ */
/* /*
* newcvec - allocate a new cvec - newcvec - allocate a new cvec
^ static struct cvec *newcvec(int, int, int);
*/ */
static struct cvec * static struct cvec *
newcvec(int nchrs, /* to hold this many chrs... */ newcvec(nchrs, nranges, nmcces)
int nranges, /* ... and this many ranges... */ int nchrs; /* to hold this many chrs... */
int nmcces) /* ... and this many MCCEs */ int nranges; /* ... and this many ranges... */
int nmcces; /* ... and this many MCCEs */
{ {
size_t n; size_t n;
size_t nc; size_t nc;
struct cvec *cv; struct cvec *cv;
nc = (size_t)nchrs + (size_t)nmcces*(MAXMCCE+1) + (size_t)nranges*2; nc = (size_t)nchrs + (size_t)nmcces*(MAXMCCE+1) + (size_t)nranges*2;
n = sizeof(struct cvec) + (size_t)(nmcces-1)*sizeof(chr *) n = sizeof(struct cvec) + (size_t)(nmcces-1)*sizeof(chr *)
+ nc*sizeof(chr); + nc*sizeof(chr);
cv = (struct cvec *)MALLOC(n); cv = (struct cvec *)MALLOC(n);
if (cv == NULL) if (cv == NULL) {
return NULL; return NULL;
}
cv->chrspace = nchrs; cv->chrspace = nchrs;
cv->chrs = (chr *) &cv->mcces[nmcces]; /* chrs just after MCCE cv->chrs = (chr *)&cv->mcces[nmcces]; /* chrs just after MCCE ptrs */
* ptrs */
cv->mccespace = nmcces; cv->mccespace = nmcces;
cv->ranges = cv->chrs + nchrs + nmcces*(MAXMCCE+1); cv->ranges = cv->chrs + nchrs + nmcces*(MAXMCCE+1);
cv->rangespace = nranges; cv->rangespace = nranges;
@@ -61,11 +60,13 @@ newcvec(int nchrs, /* to hold this many chrs... */
} }
/* /*
* clearcvec - clear a possibly-new cvec - clearcvec - clear a possibly-new cvec
* Returns pointer as convenience. * Returns pointer as convenience.
^ static struct cvec *clearcvec(struct cvec *);
*/ */
static struct cvec * static struct cvec *
clearcvec(struct cvec * cv) clearcvec(cv)
struct cvec *cv; /* character vector */
{ {
int i; int i;
@@ -75,30 +76,35 @@ clearcvec(struct cvec * cv)
cv->nmcces = 0; cv->nmcces = 0;
cv->nmccechrs = 0; cv->nmccechrs = 0;
cv->nranges = 0; cv->nranges = 0;
for (i = 0; i < cv->mccespace; i++) for (i = 0; i < cv->mccespace; i++) {
cv->mcces[i] = NULL; cv->mcces[i] = NULL;
}
return cv; return cv;
} }
/* /*
* addchr - add a chr to a cvec - addchr - add a chr to a cvec
^ static VOID addchr(struct cvec *, pchr);
*/ */
static void static VOID
addchr(struct cvec * cv, /* character vector */ addchr(cv, c)
chr c) /* character to add */ struct cvec *cv; /* character vector */
pchr c; /* character to add */
{ {
assert(cv->nchrs < cv->chrspace - cv->nmccechrs); assert(cv->nchrs < cv->chrspace - cv->nmccechrs);
cv->chrs[cv->nchrs++] = (chr)c; cv->chrs[cv->nchrs++] = (chr)c;
} }
/* /*
* addrange - add a range to a cvec - addrange - add a range to a cvec
^ static VOID addrange(struct cvec *, pchr, pchr);
*/ */
static void static VOID
addrange(struct cvec * cv, /* character vector */ addrange(cv, from, to)
chr from, /* first character of range */ struct cvec *cv; /* character vector */
chr to) /* last character of range */ pchr from; /* first character of range */
pchr to; /* last character of range */
{ {
assert(cv->nranges < cv->rangespace); assert(cv->nranges < cv->rangespace);
cv->ranges[cv->nranges*2] = (chr)from; cv->ranges[cv->nranges*2] = (chr)from;
@@ -107,83 +113,96 @@ addrange(struct cvec * cv, /* character vector */
} }
/* /*
* addmcce - add an MCCE to a cvec - addmcce - add an MCCE to a cvec
^ static VOID addmcce(struct cvec *, chr *, chr *);
*/ */
static void static VOID
addmcce(struct cvec * cv, /* character vector */ addmcce(cv, startp, endp)
chr *startp, /* beginning of text */ struct cvec *cv; /* character vector */
chr *endp) /* just past end of text */ chr *startp; /* beginning of text */
chr *endp; /* just past end of text */
{ {
int len; int len;
int i; int i;
chr *s; chr *s;
chr *d; chr *d;
if (startp == NULL && endp == NULL) if (startp == NULL && endp == NULL) {
return; return;
}
len = endp - startp; len = endp - startp;
assert(len > 0); assert(len > 0);
assert(cv->nchrs + len < cv->chrspace - cv->nmccechrs); assert(cv->nchrs + len < cv->chrspace - cv->nmccechrs);
assert(cv->nmcces < cv->mccespace); assert(cv->nmcces < cv->mccespace);
d = &cv->chrs[cv->chrspace - cv->nmccechrs - len - 1]; d = &cv->chrs[cv->chrspace - cv->nmccechrs - len - 1];
cv->mcces[cv->nmcces++] = d; cv->mcces[cv->nmcces++] = d;
for (s = startp, i = len; i > 0; s++, i--) for (s = startp, i = len; i > 0; s++, i--) {
*d++ = *s; *d++ = *s;
}
*d++ = 0; /* endmarker */ *d++ = 0; /* endmarker */
assert(d == &cv->chrs[cv->chrspace - cv->nmccechrs]); assert(d == &cv->chrs[cv->chrspace - cv->nmccechrs]);
cv->nmccechrs += len + 1; cv->nmccechrs += len + 1;
} }
/* /*
* haschr - does a cvec contain this chr? - haschr - does a cvec contain this chr?
^ static int haschr(struct cvec *, pchr);
*/ */
static int /* predicate */ static int /* predicate */
haschr(struct cvec * cv, /* character vector */ haschr(cv, c)
chr c) /* character to test for */ struct cvec *cv; /* character vector */
pchr c; /* character to test for */
{ {
int i; int i;
chr *p; chr *p;
for (p = cv->chrs, i = cv->nchrs; i > 0; p++, i--) for (p = cv->chrs, i = cv->nchrs; i > 0; p++, i--) {
{ if (*p == c) {
if (*p == c)
return 1; return 1;
} }
for (p = cv->ranges, i = cv->nranges; i > 0; p += 2, i--) }
{ for (p = cv->ranges, i = cv->nranges; i > 0; p += 2, i--) {
if ((*p <= c) && (c <= *(p + 1))) if ((*p <= c) && (c <= *(p+1))) {
return 1; return 1;
} }
}
return 0; return 0;
} }
/* /*
* getcvec - get a cvec, remembering it as v->cv - getcvec - get a cvec, remembering it as v->cv
^ static struct cvec *getcvec(struct vars *, int, int, int);
*/ */
static struct cvec * static struct cvec *
getcvec(struct vars * v, /* context */ getcvec(v, nchrs, nranges, nmcces)
int nchrs, /* to hold this many chrs... */ struct vars *v; /* context */
int nranges, /* ... and this many ranges... */ int nchrs; /* to hold this many chrs... */
int nmcces) /* ... and this many MCCEs */ int nranges; /* ... and this many ranges... */
int nmcces; /* ... and this many MCCEs */
{ {
if (v->cv != NULL && nchrs <= v->cv->chrspace && if (v->cv != NULL && nchrs <= v->cv->chrspace &&
nranges <= v->cv->rangespace && nmcces <= v->cv->mccespace) nranges <= v->cv->rangespace && nmcces <= v->cv->mccespace) {
return clearcvec(v->cv); return clearcvec(v->cv);
}
if (v->cv != NULL) if (v->cv != NULL) {
freecvec(v->cv); freecvec(v->cv);
}
v->cv = newcvec(nchrs, nranges, nmcces); v->cv = newcvec(nchrs, nranges, nmcces);
if (v->cv == NULL) if (v->cv == NULL) {
ERR(REG_ESPACE); ERR(REG_ESPACE);
}
return v->cv; return v->cv;
} }
/* /*
* freecvec - free a cvec - freecvec - free a cvec
^ static VOID freecvec(struct cvec *);
*/ */
static void static VOID
freecvec(struct cvec * cv) freecvec(cv)
struct cvec *cv; /* character vector */
{ {
FREE(cv); FREE(cv);
} }

405
src/regex/regc_lex.c
View File

@@ -28,8 +28,6 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* $Header$
*
*/ */
/* scanning macros (know about v) */ /* scanning macros (know about v) */
@@ -64,26 +62,23 @@
#define ENDOF(array) ((array) + sizeof(array)/sizeof(chr)) #define ENDOF(array) ((array) + sizeof(array)/sizeof(chr))
/* /*
* lexstart - set up lexical stuff, scan leading options - lexstart - set up lexical stuff, scan leading options
^ static VOID lexstart(struct vars *);
*/ */
static void static VOID
lexstart(struct vars * v) lexstart(v)
struct vars *v;
{ {
prefixes(v); /* may turn on new type bits etc. */ prefixes(v); /* may turn on new type bits etc. */
NOERR(); NOERR();
if (v->cflags & REG_QUOTE) if (v->cflags&REG_QUOTE) {
{
assert(!(v->cflags&(REG_ADVANCED|REG_EXPANDED|REG_NEWLINE))); assert(!(v->cflags&(REG_ADVANCED|REG_EXPANDED|REG_NEWLINE)));
INTOCON(L_Q); INTOCON(L_Q);
} } else if (v->cflags&REG_EXTENDED) {
else if (v->cflags & REG_EXTENDED)
{
assert(!(v->cflags&REG_QUOTE)); assert(!(v->cflags&REG_QUOTE));
INTOCON(L_ERE); INTOCON(L_ERE);
} } else {
else
{
assert(!(v->cflags&(REG_QUOTE|REG_ADVF))); assert(!(v->cflags&(REG_QUOTE|REG_ADVF)));
INTOCON(L_BRE); INTOCON(L_BRE);
} }
@@ -93,10 +88,12 @@ lexstart(struct vars * v)
} }
/* /*
* prefixes - implement various special prefixes - prefixes - implement various special prefixes
^ static VOID prefixes(struct vars *);
*/ */
static void static VOID
prefixes(struct vars * v) prefixes(v)
struct vars *v;
{ {
/* literal string doesn't get any of this stuff */ /* literal string doesn't get any of this stuff */
if (v->cflags&REG_QUOTE) if (v->cflags&REG_QUOTE)
@@ -104,8 +101,7 @@ prefixes(struct vars * v)
/* initial "***" gets special things */ /* initial "***" gets special things */
if (HAVE(4) && NEXT3('*', '*', '*')) if (HAVE(4) && NEXT3('*', '*', '*'))
switch (*(v->now + 3)) switch (*(v->now + 3)) {
{
case CHR('?'): /* "***?" error, msg shows version */ case CHR('?'): /* "***?" error, msg shows version */
ERR(REG_BADPAT); ERR(REG_BADPAT);
return; /* proceed no further */ return; /* proceed no further */
@@ -133,13 +129,11 @@ prefixes(struct vars * v)
return; return;
/* embedded options (AREs only) */ /* embedded options (AREs only) */
if (HAVE(3) && NEXT2('(', '?') && iscalpha(*(v->now + 2))) if (HAVE(3) && NEXT2('(', '?') && iscalpha(*(v->now + 2))) {
{
NOTE(REG_UNONPOSIX); NOTE(REG_UNONPOSIX);
v->now += 2; v->now += 2;
for (; !ATEOS() && iscalpha(*v->now); v->now++) for (; !ATEOS() && iscalpha(*v->now); v->now++)
switch (*v->now) switch (*v->now) {
{
case CHR('b'): /* BREs (but why???) */ case CHR('b'): /* BREs (but why???) */
v->cflags &= ~(REG_ADVANCED|REG_QUOTE); v->cflags &= ~(REG_ADVANCED|REG_QUOTE);
break; break;
@@ -182,8 +176,7 @@ prefixes(struct vars * v)
ERR(REG_BADOPT); ERR(REG_BADOPT);
return; return;
} }
if (!NEXT1(')')) if (!NEXT1(')')) {
{
ERR(REG_BADOPT); ERR(REG_BADOPT);
return; return;
} }
@@ -194,15 +187,16 @@ prefixes(struct vars * v)
} }
/* /*
* lexnest - "call a subroutine", interpolating string at the lexical level - lexnest - "call a subroutine", interpolating string at the lexical level
*
* Note, this is not a very general facility. There are a number of * Note, this is not a very general facility. There are a number of
* implicit assumptions about what sorts of strings can be subroutines. * implicit assumptions about what sorts of strings can be subroutines.
^ static VOID lexnest(struct vars *, chr *, chr *);
*/ */
static void static VOID
lexnest(struct vars * v, lexnest(v, beginp, endp)
chr *beginp, /* start of interpolation */ struct vars *v;
chr *endp) /* one past end of interpolation */ chr *beginp; /* start of interpolation */
chr *endp; /* one past end of interpolation */
{ {
assert(v->savenow == NULL); /* only one level of nesting */ assert(v->savenow == NULL); /* only one level of nesting */
v->savenow = v->now; v->savenow = v->now;
@@ -261,20 +255,24 @@ static chr brbackw[] = { /* \w within brackets */
}; };
/* /*
* lexword - interpolate a bracket expression for word characters - lexword - interpolate a bracket expression for word characters
* Possibly ought to inquire whether there is a "word" character class. * Possibly ought to inquire whether there is a "word" character class.
^ static VOID lexword(struct vars *);
*/ */
static void static VOID
lexword(struct vars * v) lexword(v)
struct vars *v;
{ {
lexnest(v, backw, ENDOF(backw)); lexnest(v, backw, ENDOF(backw));
} }
/* /*
* next - get next token - next - get next token
^ static int next(struct vars *);
*/ */
static int /* 1 normal, 0 failure */ static int /* 1 normal, 0 failure */
next(struct vars * v) next(v)
struct vars *v;
{ {
chr c; chr c;
@@ -286,15 +284,13 @@ next(struct vars * v)
v->lasttype = v->nexttype; v->lasttype = v->nexttype;
/* REG_BOSONLY */ /* REG_BOSONLY */
if (v->nexttype == EMPTY && (v->cflags & REG_BOSONLY)) if (v->nexttype == EMPTY && (v->cflags&REG_BOSONLY)) {
{
/* at start of a REG_BOSONLY RE */ /* at start of a REG_BOSONLY RE */
RETV(SBEGIN, 0); /* same as \A */ RETV(SBEGIN, 0); /* same as \A */
} }
/* if we're nested and we've hit end, return to outer level */ /* if we're nested and we've hit end, return to outer level */
if (v->savenow != NULL && ATEOS()) if (v->savenow != NULL && ATEOS()) {
{
v->now = v->savenow; v->now = v->savenow;
v->stop = v->savestop; v->stop = v->savestop;
v->savenow = v->savestop = NULL; v->savenow = v->savestop = NULL;
@@ -302,8 +298,7 @@ next(struct vars * v)
/* skip white space etc. if appropriate (not in literal or []) */ /* skip white space etc. if appropriate (not in literal or []) */
if (v->cflags&REG_EXPANDED) if (v->cflags&REG_EXPANDED)
switch (v->lexcon) switch (v->lexcon) {
{
case L_ERE: case L_ERE:
case L_BRE: case L_BRE:
case L_EBND: case L_EBND:
@@ -313,10 +308,8 @@ next(struct vars * v)
} }
/* handle EOS, depending on context */ /* handle EOS, depending on context */
if (ATEOS()) if (ATEOS()) {
{ switch (v->lexcon) {
switch (v->lexcon)
{
case L_ERE: case L_ERE:
case L_BRE: case L_BRE:
case L_Q: case L_Q:
@@ -340,8 +333,7 @@ next(struct vars * v)
c = *v->now++; c = *v->now++;
/* deal with the easy contexts, punt EREs to code below */ /* deal with the easy contexts, punt EREs to code below */
switch (v->lexcon) switch (v->lexcon) {
{
case L_BRE: /* punt BREs to separate function */ case L_BRE: /* punt BREs to separate function */
return brenext(v, c); return brenext(v, c);
break; break;
@@ -352,46 +344,33 @@ next(struct vars * v)
break; break;
case L_BBND: /* bounds are fairly simple */ case L_BBND: /* bounds are fairly simple */
case L_EBND: case L_EBND:
switch (c) switch (c) {
{ case CHR('0'): case CHR('1'): case CHR('2'): case CHR('3'):
case CHR('0'): case CHR('4'): case CHR('5'): case CHR('6'): case CHR('7'):
case CHR('1'): case CHR('8'): case CHR('9'):
case CHR('2'):
case CHR('3'):
case CHR('4'):
case CHR('5'):
case CHR('6'):
case CHR('7'):
case CHR('8'):
case CHR('9'):
RETV(DIGIT, (chr)DIGITVAL(c)); RETV(DIGIT, (chr)DIGITVAL(c));
break; break;
case CHR(','): case CHR(','):
RET(','); RET(',');
break; break;
case CHR('}'): /* ERE bound ends with } */ case CHR('}'): /* ERE bound ends with } */
if (INCON(L_EBND)) if (INCON(L_EBND)) {
{
INTOCON(L_ERE); INTOCON(L_ERE);
if ((v->cflags & REG_ADVF) && NEXT1('?')) if ((v->cflags&REG_ADVF) && NEXT1('?')) {
{
v->now++; v->now++;
NOTE(REG_UNONPOSIX); NOTE(REG_UNONPOSIX);
RETV('}', 0); RETV('}', 0);
} }
RETV('}', 1); RETV('}', 1);
} } else
else
FAILW(REG_BADBR); FAILW(REG_BADBR);
break; break;
case CHR('\\'): /* BRE bound ends with \} */ case CHR('\\'): /* BRE bound ends with \} */
if (INCON(L_BBND) && NEXT1('}')) if (INCON(L_BBND) && NEXT1('}')) {
{
v->now++; v->now++;
INTOCON(L_BRE); INTOCON(L_BRE);
RET('}'); RET('}');
} } else
else
FAILW(REG_BADBR); FAILW(REG_BADBR);
break; break;
default: default:
@@ -401,13 +380,11 @@ next(struct vars * v)
assert(NOTREACHED); assert(NOTREACHED);
break; break;
case L_BRACK: /* brackets are not too hard */ case L_BRACK: /* brackets are not too hard */
switch (c) switch (c) {
{
case CHR(']'): case CHR(']'):
if (LASTTYPE('[')) if (LASTTYPE('['))
RETV(PLAIN, c); RETV(PLAIN, c);
else else {
{
INTOCON((v->cflags&REG_EXTENDED) ? INTOCON((v->cflags&REG_EXTENDED) ?
L_ERE : L_BRE); L_ERE : L_BRE);
RET(']'); RET(']');
@@ -421,14 +398,12 @@ next(struct vars * v)
if (ATEOS()) if (ATEOS())
FAILW(REG_EESCAPE); FAILW(REG_EESCAPE);
(DISCARD)lexescape(v); (DISCARD)lexescape(v);
switch (v->nexttype) switch (v->nexttype) { /* not all escapes okay here */
{ /* not all escapes okay here */
case PLAIN: case PLAIN:
return 1; return 1;
break; break;
case CCLASS: case CCLASS:
switch (v->nextvalue) switch (v->nextvalue) {
{
case 'd': case 'd':
lexnest(v, brbackd, ENDOF(brbackd)); lexnest(v, brbackd, ENDOF(brbackd));
break; break;
@@ -459,8 +434,7 @@ next(struct vars * v)
case CHR('['): case CHR('['):
if (ATEOS()) if (ATEOS())
FAILW(REG_EBRACK); FAILW(REG_EBRACK);
switch (*v->now++) switch (*v->now++) {
{
case CHR('.'): case CHR('.'):
INTOCON(L_CEL); INTOCON(L_CEL);
/* might or might not be locale-specific */ /* might or might not be locale-specific */
@@ -490,33 +464,27 @@ next(struct vars * v)
assert(NOTREACHED); assert(NOTREACHED);
break; break;
case L_CEL: /* collating elements are easy */ case L_CEL: /* collating elements are easy */
if (c == CHR('.') && NEXT1(']')) if (c == CHR('.') && NEXT1(']')) {
{
v->now++; v->now++;
INTOCON(L_BRACK); INTOCON(L_BRACK);
RETV(END, '.'); RETV(END, '.');
} } else
else
RETV(PLAIN, c); RETV(PLAIN, c);
break; break;
case L_ECL: /* ditto equivalence classes */ case L_ECL: /* ditto equivalence classes */
if (c == CHR('=') && NEXT1(']')) if (c == CHR('=') && NEXT1(']')) {
{
v->now++; v->now++;
INTOCON(L_BRACK); INTOCON(L_BRACK);
RETV(END, '='); RETV(END, '=');
} } else
else
RETV(PLAIN, c); RETV(PLAIN, c);
break; break;
case L_CCL: /* ditto character classes */ case L_CCL: /* ditto character classes */
if (c == CHR(':') && NEXT1(']')) if (c == CHR(':') && NEXT1(']')) {
{
v->now++; v->now++;
INTOCON(L_BRACK); INTOCON(L_BRACK);
RETV(END, ':'); RETV(END, ':');
} } else
else
RETV(PLAIN, c); RETV(PLAIN, c);
break; break;
default: default:
@@ -528,14 +496,12 @@ next(struct vars * v)
assert(INCON(L_ERE)); assert(INCON(L_ERE));
/* deal with EREs and AREs, except for backslashes */ /* deal with EREs and AREs, except for backslashes */
switch (c) switch (c) {
{
case CHR('|'): case CHR('|'):
RET('|'); RET('|');
break; break;
case CHR('*'): case CHR('*'):
if ((v->cflags & REG_ADVF) && NEXT1('?')) if ((v->cflags&REG_ADVF) && NEXT1('?')) {
{
v->now++; v->now++;
NOTE(REG_UNONPOSIX); NOTE(REG_UNONPOSIX);
RETV('*', 0); RETV('*', 0);
@@ -543,8 +509,7 @@ next(struct vars * v)
RETV('*', 1); RETV('*', 1);
break; break;
case CHR('+'): case CHR('+'):
if ((v->cflags & REG_ADVF) && NEXT1('?')) if ((v->cflags&REG_ADVF) && NEXT1('?')) {
{
v->now++; v->now++;
NOTE(REG_UNONPOSIX); NOTE(REG_UNONPOSIX);
RETV('+', 0); RETV('+', 0);
@@ -552,8 +517,7 @@ next(struct vars * v)
RETV('+', 1); RETV('+', 1);
break; break;
case CHR('?'): case CHR('?'):
if ((v->cflags & REG_ADVF) && NEXT1('?')) if ((v->cflags&REG_ADVF) && NEXT1('?')) {
{
v->now++; v->now++;
NOTE(REG_UNONPOSIX); NOTE(REG_UNONPOSIX);
RETV('?', 0); RETV('?', 0);
@@ -563,14 +527,11 @@ next(struct vars * v)
case CHR('{'): /* bounds start or plain character */ case CHR('{'): /* bounds start or plain character */
if (v->cflags&REG_EXPANDED) if (v->cflags&REG_EXPANDED)
skip(v); skip(v);
if (ATEOS() || !iscdigit(*v->now)) if (ATEOS() || !iscdigit(*v->now)) {
{
NOTE(REG_UBRACES); NOTE(REG_UBRACES);
NOTE(REG_UUNSPEC); NOTE(REG_UUNSPEC);
RETV(PLAIN, c); RETV(PLAIN, c);
} } else {
else
{
NOTE(REG_UBOUNDS); NOTE(REG_UBOUNDS);
INTOCON(L_EBND); INTOCON(L_EBND);
RET('{'); RET('{');
@@ -578,12 +539,10 @@ next(struct vars * v)
assert(NOTREACHED); assert(NOTREACHED);
break; break;
case CHR('('): /* parenthesis, or advanced extension */ case CHR('('): /* parenthesis, or advanced extension */
if ((v->cflags & REG_ADVF) && NEXT1('?')) if ((v->cflags&REG_ADVF) && NEXT1('?')) {
{
NOTE(REG_UNONPOSIX); NOTE(REG_UNONPOSIX);
v->now++; v->now++;
switch (*v->now++) switch (*v->now++) {
{
case CHR(':'): /* non-capturing paren */ case CHR(':'): /* non-capturing paren */
RETV('(', 0); RETV('(', 0);
break; break;
@@ -615,8 +574,9 @@ next(struct vars * v)
RETV('(', 1); RETV('(', 1);
break; break;
case CHR(')'): case CHR(')'):
if (LASTTYPE('(')) if (LASTTYPE('(')) {
NOTE(REG_UUNSPEC); NOTE(REG_UUNSPEC);
}
RETV(')', c); RETV(')', c);
break; break;
case CHR('['): /* easy except for [[:<:]] and [[:>:]] */ case CHR('['): /* easy except for [[:<:]] and [[:>:]] */
@@ -626,16 +586,14 @@ next(struct vars * v)
*(v->now+2) == CHR('>')) && *(v->now+2) == CHR('>')) &&
*(v->now+3) == CHR(':') && *(v->now+3) == CHR(':') &&
*(v->now+4) == CHR(']') && *(v->now+4) == CHR(']') &&
*(v->now + 5) == CHR(']')) *(v->now+5) == CHR(']')) {
{
c = *(v->now+2); c = *(v->now+2);
v->now += 6; v->now += 6;
NOTE(REG_UNONPOSIX); NOTE(REG_UNONPOSIX);
RET((c == CHR('<')) ? '<' : '>'); RET((c == CHR('<')) ? '<' : '>');
} }
INTOCON(L_BRACK); INTOCON(L_BRACK);
if (NEXT1('^')) if (NEXT1('^')) {
{
v->now++; v->now++;
RETV('[', 0); RETV('[', 0);
} }
@@ -661,10 +619,8 @@ next(struct vars * v)
/* ERE/ARE backslash handling; backslash already eaten */ /* ERE/ARE backslash handling; backslash already eaten */
assert(!ATEOS()); assert(!ATEOS());
if (!(v->cflags & REG_ADVF)) if (!(v->cflags&REG_ADVF)) { /* only AREs have non-trivial escapes */
{ /* only AREs have non-trivial escapes */ if (iscalnum(*v->now)) {
if (iscalnum(*v->now))
{
NOTE(REG_UBSALNUM); NOTE(REG_UBSALNUM);
NOTE(REG_UUNSPEC); NOTE(REG_UUNSPEC);
} }
@@ -673,28 +629,14 @@ next(struct vars * v)
(DISCARD)lexescape(v); (DISCARD)lexescape(v);
if (ISERR()) if (ISERR())
FAILW(REG_EESCAPE); FAILW(REG_EESCAPE);
if (v->nexttype == CCLASS) if (v->nexttype == CCLASS) { /* fudge at lexical level */
{ /* fudge at lexical level */ switch (v->nextvalue) {
switch (v->nextvalue) case 'd': lexnest(v, backd, ENDOF(backd)); break;
{ case 'D': lexnest(v, backD, ENDOF(backD)); break;
case 'd': case 's': lexnest(v, backs, ENDOF(backs)); break;
lexnest(v, backd, ENDOF(backd)); case 'S': lexnest(v, backS, ENDOF(backS)); break;
break; case 'w': lexnest(v, backw, ENDOF(backw)); break;
case 'D': case 'W': lexnest(v, backW, ENDOF(backW)); break;
lexnest(v, backD, ENDOF(backD));
break;
case 's':
lexnest(v, backs, ENDOF(backs));
break;
case 'S':
lexnest(v, backS, ENDOF(backS));
break;
case 'w':
lexnest(v, backw, ENDOF(backw));
break;
case 'W':
lexnest(v, backW, ENDOF(backW));
break;
default: default:
assert(NOTREACHED); assert(NOTREACHED);
FAILW(REG_ASSERT); FAILW(REG_ASSERT);
@@ -709,12 +651,13 @@ next(struct vars * v)
} }
/* /*
* lexescape - parse an ARE backslash escape (backslash already eaten) - lexescape - parse an ARE backslash escape (backslash already eaten)
* Note slightly nonstandard use of the CCLASS type code. * Note slightly nonstandard use of the CCLASS type code.
^ static int lexescape(struct vars *);
*/ */
static int /* not actually used, but convenient for static int /* not actually used, but convenient for RETV */
* RETV */ lexescape(v)
lexescape(struct vars * v) struct vars *v;
{ {
chr c; chr c;
static chr alert[] = { static chr alert[] = {
@@ -733,8 +676,7 @@ lexescape(struct vars * v)
RETV(PLAIN, c); RETV(PLAIN, c);
NOTE(REG_UNONPOSIX); NOTE(REG_UNONPOSIX);
switch (c) switch (c) {
{
case CHR('a'): case CHR('a'):
RETV(PLAIN, chrnamed(v, alert, ENDOF(alert), CHR('\007'))); RETV(PLAIN, chrnamed(v, alert, ENDOF(alert), CHR('\007')));
break; break;
@@ -816,8 +758,7 @@ lexescape(struct vars * v)
break; break;
case CHR('x'): case CHR('x'):
NOTE(REG_UUNPORT); NOTE(REG_UUNPORT);
c = lexdigits(v, 16, 1, 255); /* REs >255 long outside c = lexdigits(v, 16, 1, 255); /* REs >255 long outside spec */
* spec */
if (ISERR()) if (ISERR())
FAILW(REG_EESCAPE); FAILW(REG_EESCAPE);
RETV(PLAIN, c); RETV(PLAIN, c);
@@ -833,24 +774,16 @@ lexescape(struct vars * v)
case CHR('Z'): case CHR('Z'):
RETV(SEND, 0); RETV(SEND, 0);
break; break;
case CHR('1'): case CHR('1'): case CHR('2'): case CHR('3'): case CHR('4'):
case CHR('2'): case CHR('5'): case CHR('6'): case CHR('7'): case CHR('8'):
case CHR('3'):
case CHR('4'):
case CHR('5'):
case CHR('6'):
case CHR('7'):
case CHR('8'):
case CHR('9'): case CHR('9'):
save = v->now; save = v->now;
v->now--; /* put first digit back */ v->now--; /* put first digit back */
c = lexdigits(v, 10, 1, 255); /* REs >255 long outside c = lexdigits(v, 10, 1, 255); /* REs >255 long outside spec */
* spec */
if (ISERR()) if (ISERR())
FAILW(REG_EESCAPE); FAILW(REG_EESCAPE);
/* ugly heuristic (first test is "exactly 1 digit?") */ /* ugly heuristic (first test is "exactly 1 digit?") */
if (v->now - save == 0 || (int) c <= v->nsubexp) if (v->now - save == 0 || (int)c <= v->nsubexp) {
{
NOTE(REG_UBACKREF); NOTE(REG_UBACKREF);
RETV(BACKREF, (chr)c); RETV(BACKREF, (chr)c);
} }
@@ -874,70 +807,44 @@ lexescape(struct vars * v)
} }
/* /*
* lexdigits - slurp up digits and return chr value - lexdigits - slurp up digits and return chr value
^ static chr lexdigits(struct vars *, int, int, int);
*/ */
static chr /* chr value; errors signalled via ERR */ static chr /* chr value; errors signalled via ERR */
lexdigits(struct vars * v, lexdigits(v, base, minlen, maxlen)
int base, struct vars *v;
int minlen, int base;
int maxlen) int minlen;
int maxlen;
{ {
uchr n; /* unsigned to avoid overflow misbehavior */ uchr n; /* unsigned to avoid overflow misbehavior */
int len; int len;
chr c; chr c;
int d; int d;
const uchr ub = (uchr) base; CONST uchr ub = (uchr) base;
n = 0; n = 0;
for (len = 0; len < maxlen && !ATEOS(); len++) for (len = 0; len < maxlen && !ATEOS(); len++) {
{
c = *v->now++; c = *v->now++;
switch (c) switch (c) {
{ case CHR('0'): case CHR('1'): case CHR('2'): case CHR('3'):
case CHR('0'): case CHR('4'): case CHR('5'): case CHR('6'): case CHR('7'):
case CHR('1'): case CHR('8'): case CHR('9'):
case CHR('2'):
case CHR('3'):
case CHR('4'):
case CHR('5'):
case CHR('6'):
case CHR('7'):
case CHR('8'):
case CHR('9'):
d = DIGITVAL(c); d = DIGITVAL(c);
break; break;
case CHR('a'): case CHR('a'): case CHR('A'): d = 10; break;
case CHR('A'): case CHR('b'): case CHR('B'): d = 11; break;
d = 10; case CHR('c'): case CHR('C'): d = 12; break;
break; case CHR('d'): case CHR('D'): d = 13; break;
case CHR('b'): case CHR('e'): case CHR('E'): d = 14; break;
case CHR('B'): case CHR('f'): case CHR('F'): d = 15; break;
d = 11;
break;
case CHR('c'):
case CHR('C'):
d = 12;
break;
case CHR('d'):
case CHR('D'):
d = 13;
break;
case CHR('e'):
case CHR('E'):
d = 14;
break;
case CHR('f'):
case CHR('F'):
d = 15;
break;
default: default:
v->now--; /* oops, not a digit at all */ v->now--; /* oops, not a digit at all */
d = -1; d = -1;
break; break;
} }
if (d >= base) if (d >= base) { /* not a plausible digit */
{ /* not a plausible digit */
v->now--; v->now--;
d = -1; d = -1;
} }
@@ -952,19 +859,19 @@ lexdigits(struct vars * v,
} }
/* /*
* brenext - get next BRE token - brenext - get next BRE token
*
* This is much like EREs except for all the stupid backslashes and the * This is much like EREs except for all the stupid backslashes and the
* context-dependency of some things. * context-dependency of some things.
^ static int brenext(struct vars *, pchr);
*/ */
static int /* 1 normal, 0 failure */ static int /* 1 normal, 0 failure */
brenext(struct vars * v, brenext(v, pc)
chr pc) struct vars *v;
pchr pc;
{ {
chr c = (chr)pc; chr c = (chr)pc;
switch (c) switch (c) {
{
case CHR('*'): case CHR('*'):
if (LASTTYPE(EMPTY) || LASTTYPE('(') || LASTTYPE('^')) if (LASTTYPE(EMPTY) || LASTTYPE('(') || LASTTYPE('^'))
RETV(PLAIN, c); RETV(PLAIN, c);
@@ -977,16 +884,14 @@ brenext(struct vars * v,
*(v->now+2) == CHR('>')) && *(v->now+2) == CHR('>')) &&
*(v->now+3) == CHR(':') && *(v->now+3) == CHR(':') &&
*(v->now+4) == CHR(']') && *(v->now+4) == CHR(']') &&
*(v->now + 5) == CHR(']')) *(v->now+5) == CHR(']')) {
{
c = *(v->now+2); c = *(v->now+2);
v->now += 6; v->now += 6;
NOTE(REG_UNONPOSIX); NOTE(REG_UNONPOSIX);
RET((c == CHR('<')) ? '<' : '>'); RET((c == CHR('<')) ? '<' : '>');
} }
INTOCON(L_BRACK); INTOCON(L_BRACK);
if (NEXT1('^')) if (NEXT1('^')) {
{
v->now++; v->now++;
RETV('[', 0); RETV('[', 0);
} }
@@ -998,8 +903,7 @@ brenext(struct vars * v,
case CHR('^'): case CHR('^'):
if (LASTTYPE(EMPTY)) if (LASTTYPE(EMPTY))
RET('^'); RET('^');
if (LASTTYPE('(')) if (LASTTYPE('(')) {
{
NOTE(REG_UUNSPEC); NOTE(REG_UUNSPEC);
RET('^'); RET('^');
} }
@@ -1010,8 +914,7 @@ brenext(struct vars * v,
skip(v); skip(v);
if (ATEOS()) if (ATEOS())
RET('$'); RET('$');
if (NEXT2('\\', ')')) if (NEXT2('\\', ')')) {
{
NOTE(REG_UUNSPEC); NOTE(REG_UUNSPEC);
RET('$'); RET('$');
} }
@@ -1030,8 +933,7 @@ brenext(struct vars * v,
FAILW(REG_EESCAPE); FAILW(REG_EESCAPE);
c = *v->now++; c = *v->now++;
switch (c) switch (c) {
{
case CHR('{'): case CHR('{'):
INTOCON(L_BBND); INTOCON(L_BBND);
NOTE(REG_UBOUNDS); NOTE(REG_UBOUNDS);
@@ -1051,21 +953,14 @@ brenext(struct vars * v,
NOTE(REG_UNONPOSIX); NOTE(REG_UNONPOSIX);
RET('>'); RET('>');
break; break;
case CHR('1'): case CHR('1'): case CHR('2'): case CHR('3'): case CHR('4'):
case CHR('2'): case CHR('5'): case CHR('6'): case CHR('7'): case CHR('8'):
case CHR('3'):
case CHR('4'):
case CHR('5'):
case CHR('6'):
case CHR('7'):
case CHR('8'):
case CHR('9'): case CHR('9'):
NOTE(REG_UBACKREF); NOTE(REG_UBACKREF);
RETV(BACKREF, (chr)DIGITVAL(c)); RETV(BACKREF, (chr)DIGITVAL(c));
break; break;
default: default:
if (iscalnum(c)) if (iscalnum(c)) {
{
NOTE(REG_UBSALNUM); NOTE(REG_UBSALNUM);
NOTE(REG_UUNSPEC); NOTE(REG_UUNSPEC);
} }
@@ -1077,17 +972,18 @@ brenext(struct vars * v,
} }
/* /*
* skip - skip white space and comments in expanded form - skip - skip white space and comments in expanded form
^ static VOID skip(struct vars *);
*/ */
static void static VOID
skip(struct vars * v) skip(v)
struct vars *v;
{ {
chr *start = v->now; chr *start = v->now;
assert(v->cflags&REG_EXPANDED); assert(v->cflags&REG_EXPANDED);
for (;;) for (;;) {
{
while (!ATEOS() && iscspace(*v->now)) while (!ATEOS() && iscspace(*v->now))
v->now++; v->now++;
if (ATEOS() || *v->now != CHR('#')) if (ATEOS() || *v->now != CHR('#'))
@@ -1103,27 +999,46 @@ skip(struct vars * v)
} }
/* /*
* newline - return the chr for a newline - newline - return the chr for a newline
*
* This helps confine use of CHR to this source file. * This helps confine use of CHR to this source file.
^ static chr newline(NOPARMS);
*/ */
static chr static chr
newline(void) newline()
{ {
return CHR('\n'); return CHR('\n');
} }
/* /*
* chrnamed - return the chr known by a given (chr string) name - ch - return the chr sequence for regc_locale.c's fake collating element ch
* * This helps confine use of CHR to this source file. Beware that the caller
* knows how long the sequence is.
^ #ifdef REG_DEBUG
^ static chr *ch(NOPARMS);
^ #endif
*/
#ifdef REG_DEBUG
static chr *
ch()
{
static chr chstr[] = { CHR('c'), CHR('h'), CHR('\0') };
return chstr;
}
#endif
/*
- chrnamed - return the chr known by a given (chr string) name
* The code is a bit clumsy, but this routine gets only such specialized * The code is a bit clumsy, but this routine gets only such specialized
* use that it hardly matters. * use that it hardly matters.
^ static chr chrnamed(struct vars *, chr *, chr *, pchr);
*/ */
static chr static chr
chrnamed(struct vars * v, chrnamed(v, startp, endp, lastresort)
chr *startp, /* start of name */ struct vars *v;
chr *endp, /* just past end of name */ chr *startp; /* start of name */
chr lastresort) /* what to return if name lookup fails */ chr *endp; /* just past end of name */
pchr lastresort; /* what to return if name lookup fails */
{ {
celt c; celt c;
int errsave; int errsave;

1257
src/regex/regc_locale.c
View File

File diff suppressed because it is too large Load Diff

750
src/regex/regc_nfa.c
View File

File diff suppressed because it is too large Load Diff

1079
src/regex/regcomp.c
View File

File diff suppressed because it is too large Load Diff

136
src/regex/regcustom.h
View File

@@ -1,6 +1,3 @@
#ifndef _REGEX_CUSTOM_H_
#define _REGEX_CUSTOM_H_
/* /*
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved. * Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
* *
@@ -27,72 +24,97 @@
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Id$
*/ */
/* headers if any */ /* headers if any */
#include "tclInt.h"
/* FreeBSD, Watcom and DMars require this, CW doesn't have nor need it. */
/* Others also don't seem to need it. If you have an error related to */
/* (not) including <sys/types.h> please report details to */
/* wx-dev@lists.wxwindows.org */
#if defined(__UNIX__) || defined(__WATCOMC__) || defined(__DIGITALMARS__)
# include <sys/types.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include "wx/wxchar.h"
/**
*
* wx_wchar == wxChar
*
*/
#define wx_wchar wxChar
/* overrides for regguts.h definitions, if any */ /* overrides for regguts.h definitions, if any */
#define FUNCPTR(name, args) (*name) args #define FUNCPTR(name, args) (*name) _ANSI_ARGS_(args)
#define MALLOC(n) malloc(n) #define MALLOC(n) ckalloc(n)
#define FREE(p) free(VS(p)) #define FREE(p) ckfree(VS(p))
#define REALLOC(p,n) realloc(VS(p),n) #define REALLOC(p,n) ckrealloc(VS(p),n)
/*
* Do not insert extras between the "begin" and "end" lines -- this
* chunk is automatically extracted to be fitted into regex.h.
*/
/* --- begin --- */
/* ensure certain things don't sneak in from system headers */
#ifdef __REG_WIDE_T
#undef __REG_WIDE_T
#endif
#ifdef __REG_WIDE_COMPILE
#undef __REG_WIDE_COMPILE
#endif
#ifdef __REG_WIDE_EXEC
#undef __REG_WIDE_EXEC
#endif
#ifdef __REG_REGOFF_T
#undef __REG_REGOFF_T
#endif
#ifdef __REG_VOID_T
#undef __REG_VOID_T
#endif
#ifdef __REG_CONST
#undef __REG_CONST
#endif
#ifdef __REG_NOFRONT
#undef __REG_NOFRONT
#endif
#ifdef __REG_NOCHAR
#undef __REG_NOCHAR
#endif
/* interface types */
#define __REG_WIDE_T Tcl_UniChar
#define __REG_REGOFF_T long /* not really right, but good enough... */
#define __REG_VOID_T VOID
#define __REG_CONST CONST
/* names and declarations */
#define __REG_WIDE_COMPILE TclReComp
#define __REG_WIDE_EXEC TclReExec
#define __REG_NOFRONT /* don't want regcomp() and regexec() */
#define __REG_NOCHAR /* or the char versions */
#define regfree TclReFree
#define regerror TclReError
/* --- end --- */
/* internal character type and related */ /* internal character type and related */
typedef wx_wchar chr; /* the type itself */ typedef Tcl_UniChar chr; /* the type itself */
typedef unsigned long uchr; /* unsigned type that will hold a chr */ typedef int pchr; /* what it promotes to */
typedef long celt; /* type to hold chr, MCCE number, or typedef unsigned uchr; /* unsigned type that will hold a chr */
* NOCELT */ typedef int celt; /* type to hold chr, MCCE number, or NOCELT */
#define NOCELT (-1) /* celt value which is not valid chr or MCCE */
#define NOCELT (-1) /* celt value which is not valid chr or #define CHR(c) (UCHAR(c)) /* turn char literal into chr literal */
* MCCE */
#define CHR(c) ((unsigned char) (c)) /* turn char literal into chr
* literal */
#define DIGITVAL(c) ((c)-'0') /* turn chr digit into its value */ #define DIGITVAL(c) ((c)-'0') /* turn chr digit into its value */
#if TCL_UTF_MAX > 3
#if wxUSE_WCHAR_T #define CHRBITS 32 /* bits in a chr; must not use sizeof */
# define CHRBITS (SIZEOF_WCHAR_T << 3) /* bits in a chr; must not use sizeof */
# define CHR_MAX ((1 << CHRBITS) - 1)
#define CHR_MIN 0x00000000 /* smallest and largest chr; the value */ #define CHR_MIN 0x00000000 /* smallest and largest chr; the value */
#else /*ANSI*/ #define CHR_MAX 0xffffffff /* CHR_MAX-CHR_MIN+1 should fit in uchr */
# define CHRBITS 8 #else
# define CHR_MAX 0xFF #define CHRBITS 16 /* bits in a chr; must not use sizeof */
# define CHR_MIN 0x00 #define CHR_MIN 0x0000 /* smallest and largest chr; the value */
#endif /*wxUSE_WCHAR_T*/ #define CHR_MAX 0xffff /* CHR_MAX-CHR_MIN+1 should fit in uchr */
#endif
/* functions operating on chr */ /* functions operating on chr */
#define iscalnum(x) wx_isalnum(x) #define iscalnum(x) Tcl_UniCharIsAlnum(x)
#define iscalpha(x) wx_isalpha(x) #define iscalpha(x) Tcl_UniCharIsAlpha(x)
#define iscdigit(x) wx_isdigit(x) #define iscdigit(x) Tcl_UniCharIsDigit(x)
#define iscspace(x) wx_isspace(x) #define iscspace(x) Tcl_UniCharIsSpace(x)
extern int wx_strlen(const wx_wchar* szString); /* name the external functions */
#define compile TclReComp
#define exec TclReExec
/* enable/disable debugging code (by whether REG_DEBUG is defined or not) */
#if 0 /* no debug unless requested by makefile */
#define REG_DEBUG /* */
#endif
/* and pick up the standard header */ /* and pick up the standard header */
#include "regex.h" #include "regex.h"
#endif /* _REGEX_CUSTOM_H_ */

258
src/regex/rege_dfa.c
View File

@@ -28,19 +28,19 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* $Header$
*
*/ */
/* /*
* longest - longest-preferred matching engine - longest - longest-preferred matching engine
^ static chr *longest(struct vars *, struct dfa *, chr *, chr *, int *);
*/ */
static chr * /* endpoint, or NULL */ static chr * /* endpoint, or NULL */
longest(struct vars * v, /* used only for debug and exec flags */ longest(v, d, start, stop, hitstopp)
struct dfa * d, struct vars *v; /* used only for debug and exec flags */
chr *start, /* where the match should start */ struct dfa *d;
chr *stop, /* match must end at or before here */ chr *start; /* where the match should start */
int *hitstopp) /* record whether hit v->stop, if non-NULL */ chr *stop; /* match must end at or before here */
int *hitstopp; /* record whether hit v->stop, if non-NULL */
{ {
chr *cp; chr *cp;
chr *realstop = (stop == v->stop) ? stop : stop + 1; chr *realstop = (stop == v->stop) ? stop : stop + 1;
@@ -59,13 +59,10 @@ longest(struct vars * v, /* used only for debug and exec flags */
/* startup */ /* startup */
FDEBUG(("+++ startup +++\n")); FDEBUG(("+++ startup +++\n"));
if (cp == v->start) if (cp == v->start) {
{
co = d->cnfa->bos[(v->eflags&REG_NOTBOL) ? 0 : 1]; co = d->cnfa->bos[(v->eflags&REG_NOTBOL) ? 0 : 1];
FDEBUG(("color %ld\n", (long)co)); FDEBUG(("color %ld\n", (long)co));
} } else {
else
{
co = GETCOLOR(cm, *(cp - 1)); co = GETCOLOR(cm, *(cp - 1));
FDEBUG(("char %c, color %ld\n", (char)*(cp-1), (long)co)); FDEBUG(("char %c, color %ld\n", (char)*(cp-1), (long)co));
} }
@@ -76,14 +73,12 @@ longest(struct vars * v, /* used only for debug and exec flags */
/* main loop */ /* main loop */
if (v->eflags&REG_FTRACE) if (v->eflags&REG_FTRACE)
while (cp < realstop) while (cp < realstop) {
{
FDEBUG(("+++ at c%d +++\n", css - d->ssets)); FDEBUG(("+++ at c%d +++\n", css - d->ssets));
co = GETCOLOR(cm, *cp); co = GETCOLOR(cm, *cp);
FDEBUG(("char %c, color %ld\n", (char)*cp, (long)co)); FDEBUG(("char %c, color %ld\n", (char)*cp, (long)co));
ss = css->outs[co]; ss = css->outs[co];
if (ss == NULL) if (ss == NULL) {
{
ss = miss(v, d, css, co, cp+1, start); ss = miss(v, d, css, co, cp+1, start);
if (ss == NULL) if (ss == NULL)
break; /* NOTE BREAK OUT */ break; /* NOTE BREAK OUT */
@@ -93,12 +88,10 @@ longest(struct vars * v, /* used only for debug and exec flags */
css = ss; css = ss;
} }
else else
while (cp < realstop) while (cp < realstop) {
{
co = GETCOLOR(cm, *cp); co = GETCOLOR(cm, *cp);
ss = css->outs[co]; ss = css->outs[co];
if (ss == NULL) if (ss == NULL) {
{
ss = miss(v, d, css, co, cp+1, start); ss = miss(v, d, css, co, cp+1, start);
if (ss == NULL) if (ss == NULL)
break; /* NOTE BREAK OUT */ break; /* NOTE BREAK OUT */
@@ -110,8 +103,7 @@ longest(struct vars * v, /* used only for debug and exec flags */
/* shutdown */ /* shutdown */
FDEBUG(("+++ shutdown at c%d +++\n", css - d->ssets)); FDEBUG(("+++ shutdown at c%d +++\n", css - d->ssets));
if (cp == v->stop && stop == v->stop) if (cp == v->stop && stop == v->stop) {
{
if (hitstopp != NULL) if (hitstopp != NULL)
*hitstopp = 1; *hitstopp = 1;
co = d->cnfa->eos[(v->eflags&REG_NOTEOL) ? 0 : 1]; co = d->cnfa->eos[(v->eflags&REG_NOTEOL) ? 0 : 1];
@@ -137,17 +129,19 @@ longest(struct vars * v, /* used only for debug and exec flags */
} }
/* /*
* shortest - shortest-preferred matching engine - shortest - shortest-preferred matching engine
^ static chr *shortest(struct vars *, struct dfa *, chr *, chr *, chr *,
^ chr **, int *);
*/ */
static chr * /* endpoint, or NULL */ static chr * /* endpoint, or NULL */
shortest(struct vars * v, shortest(v, d, start, min, max, coldp, hitstopp)
struct dfa * d, struct vars *v;
chr *start, /* where the match should start */ struct dfa *d;
chr *min, /* match must end at or after here */ chr *start; /* where the match should start */
chr *max, /* match must end at or before here */ chr *min; /* match must end at or after here */
chr **coldp, /* store coldstart pointer here, if chr *max; /* match must end at or before here */
* nonNULL */ chr **coldp; /* store coldstart pointer here, if nonNULL */
int *hitstopp) /* record whether hit v->stop, if non-NULL */ int *hitstopp; /* record whether hit v->stop, if non-NULL */
{ {
chr *cp; chr *cp;
chr *realmin = (min == v->stop) ? min : min + 1; chr *realmin = (min == v->stop) ? min : min + 1;
@@ -165,13 +159,10 @@ shortest(struct vars * v,
/* startup */ /* startup */
FDEBUG(("--- startup ---\n")); FDEBUG(("--- startup ---\n"));
if (cp == v->start) if (cp == v->start) {
{
co = d->cnfa->bos[(v->eflags&REG_NOTBOL) ? 0 : 1]; co = d->cnfa->bos[(v->eflags&REG_NOTBOL) ? 0 : 1];
FDEBUG(("color %ld\n", (long)co)); FDEBUG(("color %ld\n", (long)co));
} } else {
else
{
co = GETCOLOR(cm, *(cp - 1)); co = GETCOLOR(cm, *(cp - 1));
FDEBUG(("char %c, color %ld\n", (char)*(cp-1), (long)co)); FDEBUG(("char %c, color %ld\n", (char)*(cp-1), (long)co));
} }
@@ -183,14 +174,12 @@ shortest(struct vars * v,
/* main loop */ /* main loop */
if (v->eflags&REG_FTRACE) if (v->eflags&REG_FTRACE)
while (cp < realmax) while (cp < realmax) {
{
FDEBUG(("--- at c%d ---\n", css - d->ssets)); FDEBUG(("--- at c%d ---\n", css - d->ssets));
co = GETCOLOR(cm, *cp); co = GETCOLOR(cm, *cp);
FDEBUG(("char %c, color %ld\n", (char)*cp, (long)co)); FDEBUG(("char %c, color %ld\n", (char)*cp, (long)co));
ss = css->outs[co]; ss = css->outs[co];
if (ss == NULL) if (ss == NULL) {
{
ss = miss(v, d, css, co, cp+1, start); ss = miss(v, d, css, co, cp+1, start);
if (ss == NULL) if (ss == NULL)
break; /* NOTE BREAK OUT */ break; /* NOTE BREAK OUT */
@@ -202,12 +191,10 @@ shortest(struct vars * v,
break; /* NOTE BREAK OUT */ break; /* NOTE BREAK OUT */
} }
else else
while (cp < realmax) while (cp < realmax) {
{
co = GETCOLOR(cm, *cp); co = GETCOLOR(cm, *cp);
ss = css->outs[co]; ss = css->outs[co];
if (ss == NULL) if (ss == NULL) {
{
ss = miss(v, d, css, co, cp+1, start); ss = miss(v, d, css, co, cp+1, start);
if (ss == NULL) if (ss == NULL)
break; /* NOTE BREAK OUT */ break; /* NOTE BREAK OUT */
@@ -222,17 +209,13 @@ shortest(struct vars * v,
if (ss == NULL) if (ss == NULL)
return NULL; return NULL;
if (coldp != NULL) /* report last no-progress state set, if if (coldp != NULL) /* report last no-progress state set, if any */
* any */
*coldp = lastcold(v, d); *coldp = lastcold(v, d);
if ((ss->flags & POSTSTATE) && cp > min) if ((ss->flags&POSTSTATE) && cp > min) {
{
assert(cp >= realmin); assert(cp >= realmin);
cp--; cp--;
} } else if (cp == v->stop && max == v->stop) {
else if (cp == v->stop && max == v->stop)
{
co = d->cnfa->eos[(v->eflags&REG_NOTEOL) ? 0 : 1]; co = d->cnfa->eos[(v->eflags&REG_NOTEOL) ? 0 : 1];
FDEBUG(("color %ld\n", (long)co)); FDEBUG(("color %ld\n", (long)co));
ss = miss(v, d, css, co, cp, start); ss = miss(v, d, css, co, cp, start);
@@ -248,11 +231,13 @@ shortest(struct vars * v,
} }
/* /*
* lastcold - determine last point at which no progress had been made - lastcold - determine last point at which no progress had been made
^ static chr *lastcold(struct vars *, struct dfa *);
*/ */
static chr * /* endpoint, or NULL */ static chr * /* endpoint, or NULL */
lastcold(struct vars * v, lastcold(v, d)
struct dfa * d) struct vars *v;
struct dfa *d;
{ {
struct sset *ss; struct sset *ss;
chr *nopr; chr *nopr;
@@ -268,13 +253,16 @@ lastcold(struct vars * v,
} }
/* /*
* newdfa - set up a fresh DFA - newdfa - set up a fresh DFA
^ static struct dfa *newdfa(struct vars *, struct cnfa *,
^ struct colormap *, struct smalldfa *);
*/ */
static struct dfa * static struct dfa *
newdfa(struct vars * v, newdfa(v, cnfa, cm, small)
struct cnfa * cnfa, struct vars *v;
struct colormap * cm, struct cnfa *cnfa;
struct smalldfa * small) /* preallocated space, may be NULL */ struct colormap *cm;
struct smalldfa *small; /* preallocated space, may be NULL */
{ {
struct dfa *d; struct dfa *d;
size_t nss = cnfa->nstates * 2; size_t nss = cnfa->nstates * 2;
@@ -283,15 +271,12 @@ newdfa(struct vars * v,
assert(cnfa != NULL && cnfa->nstates != 0); assert(cnfa != NULL && cnfa->nstates != 0);
if (nss <= FEWSTATES && cnfa->ncolors <= FEWCOLORS) if (nss <= FEWSTATES && cnfa->ncolors <= FEWCOLORS) {
{
assert(wordsper == 1); assert(wordsper == 1);
if (small == NULL) if (small == NULL) {
{
small = (struct smalldfa *)MALLOC( small = (struct smalldfa *)MALLOC(
sizeof(struct smalldfa)); sizeof(struct smalldfa));
if (small == NULL) if (small == NULL) {
{
ERR(REG_ESPACE); ERR(REG_ESPACE);
return NULL; return NULL;
} }
@@ -304,12 +289,9 @@ newdfa(struct vars * v,
d->incarea = small->incarea; d->incarea = small->incarea;
d->cptsmalloced = 0; d->cptsmalloced = 0;
d->mallocarea = (smallwas == NULL) ? (char *)small : NULL; d->mallocarea = (smallwas == NULL) ? (char *)small : NULL;
} } else {
else
{
d = (struct dfa *)MALLOC(sizeof(struct dfa)); d = (struct dfa *)MALLOC(sizeof(struct dfa));
if (d == NULL) if (d == NULL) {
{
ERR(REG_ESPACE); ERR(REG_ESPACE);
return NULL; return NULL;
} }
@@ -324,8 +306,7 @@ newdfa(struct vars * v,
d->cptsmalloced = 1; d->cptsmalloced = 1;
d->mallocarea = (char *)d; d->mallocarea = (char *)d;
if (d->ssets == NULL || d->statesarea == NULL || if (d->ssets == NULL || d->statesarea == NULL ||
d->outsarea == NULL || d->incarea == NULL) d->outsarea == NULL || d->incarea == NULL) {
{
freedfa(d); freedfa(d);
ERR(REG_ESPACE); ERR(REG_ESPACE);
return NULL; return NULL;
@@ -349,13 +330,14 @@ newdfa(struct vars * v,
} }
/* /*
* freedfa - free a DFA - freedfa - free a DFA
^ static VOID freedfa(struct dfa *);
*/ */
static void static VOID
freedfa(struct dfa * d) freedfa(d)
{ struct dfa *d;
if (d->cptsmalloced)
{ {
if (d->cptsmalloced) {
if (d->ssets != NULL) if (d->ssets != NULL)
FREE(d->ssets); FREE(d->ssets);
if (d->statesarea != NULL) if (d->statesarea != NULL)
@@ -371,13 +353,14 @@ freedfa(struct dfa * d)
} }
/* /*
* hash - construct a hash code for a bitvector - hash - construct a hash code for a bitvector
*
* There are probably better ways, but they're more expensive. * There are probably better ways, but they're more expensive.
^ static unsigned hash(unsigned *, int);
*/ */
static unsigned static unsigned
hash(unsigned *uv, hash(uv, n)
int n) unsigned *uv;
int n;
{ {
int i; int i;
unsigned h; unsigned h;
@@ -389,12 +372,14 @@ hash(unsigned *uv,
} }
/* /*
* initialize - hand-craft a cache entry for startup, otherwise get ready - initialize - hand-craft a cache entry for startup, otherwise get ready
^ static struct sset *initialize(struct vars *, struct dfa *, chr *);
*/ */
static struct sset * static struct sset *
initialize(struct vars * v, /* used only for debug flags */ initialize(v, d, start)
struct dfa * d, struct vars *v; /* used only for debug flags */
chr *start) struct dfa *d;
chr *start;
{ {
struct sset *ss; struct sset *ss;
int i; int i;
@@ -402,8 +387,7 @@ initialize(struct vars * v, /* used only for debug flags */
/* is previous one still there? */ /* is previous one still there? */
if (d->nssused > 0 && (d->ssets[0].flags&STARTER)) if (d->nssused > 0 && (d->ssets[0].flags&STARTER))
ss = &d->ssets[0]; ss = &d->ssets[0];
else else { /* no, must (re)build it */
{ /* no, must (re)build it */
ss = getvacant(v, d, start, start); ss = getvacant(v, d, start, start);
for (i = 0; i < d->wordsper; i++) for (i = 0; i < d->wordsper; i++)
ss->states[i] = 0; ss->states[i] = 0;
@@ -423,15 +407,18 @@ initialize(struct vars * v, /* used only for debug flags */
} }
/* /*
* miss - handle a cache miss - miss - handle a cache miss
^ static struct sset *miss(struct vars *, struct dfa *, struct sset *,
^ pcolor, chr *, chr *);
*/ */
static struct sset * /* NULL if goes to empty set */ static struct sset * /* NULL if goes to empty set */
miss(struct vars * v, /* used only for debug flags */ miss(v, d, css, co, cp, start)
struct dfa * d, struct vars *v; /* used only for debug flags */
struct sset * css, struct dfa *d;
pcolor co, struct sset *css;
chr *cp, /* next chr */ pcolor co;
chr *start) /* where the attempt got started */ chr *cp; /* next chr */
chr *start; /* where the attempt got started */
{ {
struct cnfa *cnfa = d->cnfa; struct cnfa *cnfa = d->cnfa;
int i; int i;
@@ -445,8 +432,7 @@ miss(struct vars * v, /* used only for debug flags */
int sawlacons; int sawlacons;
/* for convenience, we can be called even if it might not be a miss */ /* for convenience, we can be called even if it might not be a miss */
if (css->outs[co] != NULL) if (css->outs[co] != NULL) {
{
FDEBUG(("hit\n")); FDEBUG(("hit\n"));
return css->outs[co]; return css->outs[co];
} }
@@ -461,8 +447,7 @@ miss(struct vars * v, /* used only for debug flags */
for (i = 0; i < d->nstates; i++) for (i = 0; i < d->nstates; i++)
if (ISBSET(css->states, i)) if (ISBSET(css->states, i))
for (ca = cnfa->states[i]+1; ca->co != COLORLESS; ca++) for (ca = cnfa->states[i]+1; ca->co != COLORLESS; ca++)
if (ca->co == co) if (ca->co == co) {
{
BSET(d->work, ca->to); BSET(d->work, ca->to);
gotstate = 1; gotstate = 1;
if (ca->to == cnfa->post) if (ca->to == cnfa->post)
@@ -473,14 +458,12 @@ miss(struct vars * v, /* used only for debug flags */
} }
dolacons = (gotstate) ? (cnfa->flags&HASLACONS) : 0; dolacons = (gotstate) ? (cnfa->flags&HASLACONS) : 0;
sawlacons = 0; sawlacons = 0;
while (dolacons) while (dolacons) { /* transitive closure */
{ /* transitive closure */
dolacons = 0; dolacons = 0;
for (i = 0; i < d->nstates; i++) for (i = 0; i < d->nstates; i++)
if (ISBSET(d->work, i)) if (ISBSET(d->work, i))
for (ca = cnfa->states[i]+1; ca->co != COLORLESS; for (ca = cnfa->states[i]+1; ca->co != COLORLESS;
ca++) ca++) {
{
if (ca->co <= cnfa->ncolors) if (ca->co <= cnfa->ncolors)
continue; /* NOTE CONTINUE */ continue; /* NOTE CONTINUE */
sawlacons = 1; sawlacons = 1;
@@ -503,13 +486,11 @@ miss(struct vars * v, /* used only for debug flags */
/* next, is that in the cache? */ /* next, is that in the cache? */
for (p = d->ssets, i = d->nssused; i > 0; p++, i--) for (p = d->ssets, i = d->nssused; i > 0; p++, i--)
if (HIT(h, d->work, p, d->wordsper)) if (HIT(h, d->work, p, d->wordsper)) {
{
FDEBUG(("cached c%d\n", p - d->ssets)); FDEBUG(("cached c%d\n", p - d->ssets));
break; /* NOTE BREAK OUT */ break; /* NOTE BREAK OUT */
} }
if (i == 0) if (i == 0) { /* nope, need a new cache entry */
{ /* nope, need a new cache entry */
p = getvacant(v, d, cp, start); p = getvacant(v, d, cp, start);
assert(p != css); assert(p != css);
for (i = 0; i < d->wordsper; i++) for (i = 0; i < d->wordsper; i++)
@@ -521,8 +502,7 @@ miss(struct vars * v, /* used only for debug flags */
/* lastseen to be dealt with by caller */ /* lastseen to be dealt with by caller */
} }
if (!sawlacons) if (!sawlacons) { /* lookahead conds. always cache miss */
{ /* lookahead conds. always cache miss */
FDEBUG(("c%d[%d]->c%d\n", css - d->ssets, co, p - d->ssets)); FDEBUG(("c%d[%d]->c%d\n", css - d->ssets, co, p - d->ssets));
css->outs[co] = p; css->outs[co] = p;
css->inchain[co] = p->ins; css->inchain[co] = p->ins;
@@ -533,13 +513,15 @@ miss(struct vars * v, /* used only for debug flags */
} }
/* /*
* lacon - lookahead-constraint checker for miss() - lacon - lookahead-constraint checker for miss()
^ static int lacon(struct vars *, struct cnfa *, chr *, pcolor);
*/ */
static int /* predicate: constraint satisfied? */ static int /* predicate: constraint satisfied? */
lacon(struct vars * v, lacon(v, pcnfa, cp, co)
struct cnfa * pcnfa, /* parent cnfa */ struct vars *v;
chr *cp, struct cnfa *pcnfa; /* parent cnfa */
pcolor co) /* "color" of the lookahead constraint */ chr *cp;
pcolor co; /* "color" of the lookahead constraint */
{ {
int n; int n;
struct subre *sub; struct subre *sub;
@@ -552,8 +534,7 @@ lacon(struct vars * v,
FDEBUG(("=== testing lacon %d\n", n)); FDEBUG(("=== testing lacon %d\n", n));
sub = &v->g->lacons[n]; sub = &v->g->lacons[n];
d = newdfa(v, &sub->cnfa, &v->g->cmap, &sd); d = newdfa(v, &sub->cnfa, &v->g->cmap, &sd);
if (d == NULL) if (d == NULL) {
{
ERR(REG_ESPACE); ERR(REG_ESPACE);
return 0; return 0;
} }
@@ -564,15 +545,17 @@ lacon(struct vars * v,
} }
/* /*
* getvacant - get a vacant state set - getvacant - get a vacant state set
* This routine clears out the inarcs and outarcs, but does not otherwise * This routine clears out the inarcs and outarcs, but does not otherwise
* clear the innards of the state set -- that's up to the caller. * clear the innards of the state set -- that's up to the caller.
^ static struct sset *getvacant(struct vars *, struct dfa *, chr *, chr *);
*/ */
static struct sset * static struct sset *
getvacant(struct vars * v, /* used only for debug flags */ getvacant(v, d, cp, start)
struct dfa * d, struct vars *v; /* used only for debug flags */
chr *cp, struct dfa *d;
chr *start) chr *cp;
chr *start;
{ {
int i; int i;
struct sset *ss; struct sset *ss;
@@ -586,8 +569,7 @@ getvacant(struct vars * v, /* used only for debug flags */
/* clear out its inarcs, including self-referential ones */ /* clear out its inarcs, including self-referential ones */
ap = ss->ins; ap = ss->ins;
while ((p = ap.ss) != NULL) while ((p = ap.ss) != NULL) {
{
co = ap.co; co = ap.co;
FDEBUG(("zapping c%d's %ld outarc\n", p - d->ssets, (long)co)); FDEBUG(("zapping c%d's %ld outarc\n", p - d->ssets, (long)co));
p->outs[co] = NULL; p->outs[co] = NULL;
@@ -597,8 +579,7 @@ getvacant(struct vars * v, /* used only for debug flags */
ss->ins.ss = NULL; ss->ins.ss = NULL;
/* take it off the inarc chains of the ssets reached by its outarcs */ /* take it off the inarc chains of the ssets reached by its outarcs */
for (i = 0; i < d->ncolors; i++) for (i = 0; i < d->ncolors; i++) {
{
p = ss->outs[i]; p = ss->outs[i];
assert(p != ss); /* not self-referential */ assert(p != ss); /* not self-referential */
if (p == NULL) if (p == NULL)
@@ -606,8 +587,7 @@ getvacant(struct vars * v, /* used only for debug flags */
FDEBUG(("del outarc %d from c%d's in chn\n", i, p - d->ssets)); FDEBUG(("del outarc %d from c%d's in chn\n", i, p - d->ssets));
if (p->ins.ss == ss && p->ins.co == i) if (p->ins.ss == ss && p->ins.co == i)
p->ins = ss->inchain[i]; p->ins = ss->inchain[i];
else else {
{
assert(p->ins.ss != NULL); assert(p->ins.ss != NULL);
for (ap = p->ins; ap.ss != NULL && for (ap = p->ins; ap.ss != NULL &&
!(ap.ss == ss && ap.co == i); !(ap.ss == ss && ap.co == i);
@@ -634,13 +614,15 @@ getvacant(struct vars * v, /* used only for debug flags */
} }
/* /*
* pickss - pick the next stateset to be used - pickss - pick the next stateset to be used
^ static struct sset *pickss(struct vars *, struct dfa *, chr *, chr *);
*/ */
static struct sset * static struct sset *
pickss(struct vars * v, /* used only for debug flags */ pickss(v, d, cp, start)
struct dfa * d, struct vars *v; /* used only for debug flags */
chr *cp, struct dfa *d;
chr *start) chr *cp;
chr *start;
{ {
int i; int i;
struct sset *ss; struct sset *ss;
@@ -648,8 +630,7 @@ pickss(struct vars * v, /* used only for debug flags */
chr *ancient; chr *ancient;
/* shortcut for cases where cache isn't full */ /* shortcut for cases where cache isn't full */
if (d->nssused < d->nssets) if (d->nssused < d->nssets) {
{
i = d->nssused; i = d->nssused;
d->nssused++; d->nssused++;
ss = &d->ssets[i]; ss = &d->ssets[i];
@@ -661,8 +642,7 @@ pickss(struct vars * v, /* used only for debug flags */
ss->ins.co = WHITE; /* give it some value */ ss->ins.co = WHITE; /* give it some value */
ss->outs = &d->outsarea[i * d->ncolors]; ss->outs = &d->outsarea[i * d->ncolors];
ss->inchain = &d->incarea[i * d->ncolors]; ss->inchain = &d->incarea[i * d->ncolors];
for (i = 0; i < d->ncolors; i++) for (i = 0; i < d->ncolors; i++) {
{
ss->outs[i] = NULL; ss->outs[i] = NULL;
ss->inchain[i].ss = NULL; ss->inchain[i].ss = NULL;
} }
@@ -676,16 +656,14 @@ pickss(struct vars * v, /* used only for debug flags */
ancient = start; ancient = start;
for (ss = d->search, end = &d->ssets[d->nssets]; ss < end; ss++) for (ss = d->search, end = &d->ssets[d->nssets]; ss < end; ss++)
if ((ss->lastseen == NULL || ss->lastseen < ancient) && if ((ss->lastseen == NULL || ss->lastseen < ancient) &&
!(ss->flags & LOCKED)) !(ss->flags&LOCKED)) {
{
d->search = ss + 1; d->search = ss + 1;
FDEBUG(("replacing c%d\n", ss - d->ssets)); FDEBUG(("replacing c%d\n", ss - d->ssets));
return ss; return ss;
} }
for (ss = d->ssets, end = d->search; ss < end; ss++) for (ss = d->ssets, end = d->search; ss < end; ss++)
if ((ss->lastseen == NULL || ss->lastseen < ancient) && if ((ss->lastseen == NULL || ss->lastseen < ancient) &&
!(ss->flags & LOCKED)) !(ss->flags&LOCKED)) {
{
d->search = ss + 1; d->search = ss + 1;
FDEBUG(("replacing c%d\n", ss - d->ssets)); FDEBUG(("replacing c%d\n", ss - d->ssets));
return ss; return ss;

47
src/regex/regerror.c
View File

@@ -27,8 +27,6 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* $Header: /projects/cvsroot/pgsql-server/src/backend/regex/regerror.c,v 1.26 2003/08/04 00:43:21 momjian Exp $
*
*/ */
#include "regguts.h" #include "regguts.h"
@@ -37,36 +35,26 @@
static char unk[] = "*** unknown regex error code 0x%x ***"; static char unk[] = "*** unknown regex error code 0x%x ***";
/* struct to map among codes, code names, and explanations */ /* struct to map among codes, code names, and explanations */
static struct rerr static struct rerr {
{
int code; int code;
char *name; char *name;
char *explain; char *explain;
} rerrs[] = } rerrs[] = {
{
/* the actual table is built from regex.h */ /* the actual table is built from regex.h */
# include "regerrs.h" # include "regerrs.h"
{ { -1, "", "oops" }, /* explanation special-cased in code */
-1, "", "oops"
}, /* explanation special-cased in code */
}; };
size_t
regerror(int errcode, /* error code, or REG_ATOI or REG_ITOA */
const regex_t *preg, /* associated regex_t (unused at present) */
char *errbuf, /* result buffer (unless errbuf_size==0) */
size_t errbuf_size) /* available space in errbuf, can be 0 */
{ return wx_regerror(errcode, preg, errbuf, errbuf_size); }
/* /*
* pg_regerror - the interface to error numbers - regerror - the interface to error numbers
*/ */
/* ARGSUSED */ /* ARGSUSED */
size_t /* actual space needed (including NUL) */ size_t /* actual space needed (including NUL) */
wx_regerror(int errcode, /* error code, or REG_ATOI or REG_ITOA */ regerror(errcode, preg, errbuf, errbuf_size)
const regex_t *preg, /* associated regex_t (unused at present) */ int errcode; /* error code, or REG_ATOI or REG_ITOA */
char *errbuf, /* result buffer (unless errbuf_size==0) */ CONST regex_t *preg; /* associated regex_t (unused at present) */
size_t errbuf_size) /* available space in errbuf, can be 0 */ char *errbuf; /* result buffer (unless errbuf_size==0) */
size_t errbuf_size; /* available space in errbuf, can be 0 */
{ {
struct rerr *r; struct rerr *r;
char *msg; char *msg;
@@ -74,8 +62,7 @@ wx_regerror(int errcode, /* error code, or REG_ATOI or REG_ITOA */
size_t len; size_t len;
int icode; int icode;
switch (errcode) switch (errcode) {
{
case REG_ATOI: /* convert name to number */ case REG_ATOI: /* convert name to number */
for (r = rerrs; r->code >= 0; r++) for (r = rerrs; r->code >= 0; r++)
if (strcmp(r->name, errbuf) == 0) if (strcmp(r->name, errbuf) == 0)
@@ -90,8 +77,7 @@ wx_regerror(int errcode, /* error code, or REG_ATOI or REG_ITOA */
break; break;
if (r->code >= 0) if (r->code >= 0)
msg = r->name; msg = r->name;
else else { /* unknown; tell him the number */
{ /* unknown; tell him the number */
sprintf(convbuf, "REG_%u", (unsigned)icode); sprintf(convbuf, "REG_%u", (unsigned)icode);
msg = convbuf; msg = convbuf;
} }
@@ -102,8 +88,7 @@ wx_regerror(int errcode, /* error code, or REG_ATOI or REG_ITOA */
break; break;
if (r->code >= 0) if (r->code >= 0)
msg = r->explain; msg = r->explain;
else else { /* unknown; say so */
{ /* unknown; say so */
sprintf(convbuf, unk, errcode); sprintf(convbuf, unk, errcode);
msg = convbuf; msg = convbuf;
} }
@@ -111,13 +96,11 @@ wx_regerror(int errcode, /* error code, or REG_ATOI or REG_ITOA */
} }
len = strlen(msg) + 1; /* space needed, including NUL */ len = strlen(msg) + 1; /* space needed, including NUL */
if (errbuf_size > 0) if (errbuf_size > 0) {
{
if (errbuf_size > len) if (errbuf_size > len)
strcpy(errbuf, msg); strcpy(errbuf, msg);
else else { /* truncate to fit */
{ /* truncate to fit */ strncpy(errbuf, msg, errbuf_size-1);
memcpy(errbuf, msg, errbuf_size - 1); /*RN - was strncpy*/
errbuf[errbuf_size-1] = '\0'; errbuf[errbuf_size-1] = '\0';
} }
} }

93
src/regex/regerrs.h
View File

@@ -1,75 +1,18 @@
/* { REG_OKAY, "REG_OKAY", "no errors detected" },
* $Id$ { REG_NOMATCH, "REG_NOMATCH", "failed to match" },
*/ { REG_BADPAT, "REG_BADPAT", "invalid regexp (reg version 0.8)" },
{ REG_ECOLLATE, "REG_ECOLLATE", "invalid collating element" },
{ { REG_ECTYPE, "REG_ECTYPE", "invalid character class" },
REG_OKAY, "REG_OKAY", "no errors detected" { REG_EESCAPE, "REG_EESCAPE", "invalid escape \\ sequence" },
}, { REG_ESUBREG, "REG_ESUBREG", "invalid backreference number" },
{ REG_EBRACK, "REG_EBRACK", "brackets [] not balanced" },
{ { REG_EPAREN, "REG_EPAREN", "parentheses () not balanced" },
REG_NOMATCH, "REG_NOMATCH", "failed to match" { REG_EBRACE, "REG_EBRACE", "braces {} not balanced" },
}, { REG_BADBR, "REG_BADBR", "invalid repetition count(s)" },
{ REG_ERANGE, "REG_ERANGE", "invalid character range" },
{ { REG_ESPACE, "REG_ESPACE", "out of memory" },
REG_BADPAT, "REG_BADPAT", "invalid regexp (reg version 0.8)" { REG_BADRPT, "REG_BADRPT", "quantifier operand invalid" },
}, { REG_ASSERT, "REG_ASSERT", "\"can't happen\" -- you found a bug" },
{ REG_INVARG, "REG_INVARG", "invalid argument to regex function" },
{ { REG_MIXED, "REG_MIXED", "character widths of regex and string differ" },
REG_ECOLLATE, "REG_ECOLLATE", "invalid collating element" { REG_BADOPT, "REG_BADOPT", "invalid embedded option" },
},
{
REG_ECTYPE, "REG_ECTYPE", "invalid character class"
},
{
REG_EESCAPE, "REG_EESCAPE", "invalid escape \\ sequence"
},
{
REG_ESUBREG, "REG_ESUBREG", "invalid backreference number"
},
{
REG_EBRACK, "REG_EBRACK", "brackets [] not balanced"
},
{
REG_EPAREN, "REG_EPAREN", "parentheses () not balanced"
},
{
REG_EBRACE, "REG_EBRACE", "braces {} not balanced"
},
{
REG_BADBR, "REG_BADBR", "invalid repetition count(s)"
},
{
REG_ERANGE, "REG_ERANGE", "invalid character range"
},
{
REG_ESPACE, "REG_ESPACE", "out of memory"
},
{
REG_BADRPT, "REG_BADRPT", "quantifier operand invalid"
},
{
REG_ASSERT, "REG_ASSERT", "\"can't happen\" -- you found a bug"
},
{
REG_INVARG, "REG_INVARG", "invalid argument to regex function"
},
{
REG_MIXED, "REG_MIXED", "character widths of regex and string differ"
},
{
REG_BADOPT, "REG_BADOPT", "invalid embedded option"
},

228
src/regex/regex.h
View File

@@ -1,6 +1,5 @@
#ifndef _REGEX_H_ #ifndef _REGEX_H_
#define _REGEX_H_ /* never again */ #define _REGEX_H_ /* never again */
/* /*
* regular expressions * regular expressions
* *
@@ -30,35 +29,98 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* $Id$ *
*
* Prototypes etc. marked with "^" within comments get gathered up (and
* possibly edited) by the regfwd program and inserted near the bottom of
* this file.
*
* We offer the option of declaring one wide-character version of the
* RE functions as well as the char versions. To do that, define
* __REG_WIDE_T to the type of wide characters (unfortunately, there
* is no consensus that wchar_t is suitable) and __REG_WIDE_COMPILE and
* __REG_WIDE_EXEC to the names to be used for the compile and execute
* functions (suggestion: re_Xcomp and re_Xexec, where X is a letter
* suggestive of the wide type, e.g. re_ucomp and re_uexec for Unicode).
* For cranky old compilers, it may be necessary to do something like:
* #define __REG_WIDE_COMPILE(a,b,c,d) re_Xcomp(a,b,c,d)
* #define __REG_WIDE_EXEC(a,b,c,d,e,f,g) re_Xexec(a,b,c,d,e,f,g)
* rather than just #defining the names as parameterless macros.
*
* For some specialized purposes, it may be desirable to suppress the
* declarations of the "front end" functions, regcomp() and regexec(),
* or of the char versions of the compile and execute functions. To
* suppress the front-end functions, define __REG_NOFRONT. To suppress
* the char versions, define __REG_NOCHAR.
*
* The right place to do those defines (and some others you may want, see
* below) would be <sys/types.h>. If you don't have control of that file,
* the right place to add your own defines to this file is marked below.
* This is normally done automatically, by the makefile and regmkhdr, based
* on the contents of regcustom.h.
*/ */
/* /*
* Add your own defines, if needed, here. * voodoo for C++
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/*****************************
WXWINDOWS CUSTOM
*****************************/
#ifndef _REGEX_CUSTOM_H_
# define wx_wchar wxChar
/* FreeBSD, Watcom and DMars require this, CW doesn't have nor need it. */
/* Others also don't seem to need it. If you have an error related to */
/* (not) including <sys/types.h> please report details to */
/* wx-dev@lists.wxwindows.org */
# if defined(__UNIX__) || defined(__WATCOMC__) || defined(__DIGITALMARS__)
# include <sys/types.h>
# endif
#endif /* ndef _REGEX_CUSTOM_H_ */
/*****************************
END WXWINDOWS CUSTOM
*****************************/
#include <stdio.h>
#include <stdlib.h> /*
* Add your own defines, if needed, here.
*/
/*
* Location where a chunk of regcustom.h is automatically spliced into
* this file (working from its prototype, regproto.h).
*/
/* --- begin --- */
/* ensure certain things don't sneak in from system headers */
#ifdef __REG_WIDE_T
#undef __REG_WIDE_T
#endif
#ifdef __REG_WIDE_COMPILE
#undef __REG_WIDE_COMPILE
#endif
#ifdef __REG_WIDE_EXEC
#undef __REG_WIDE_EXEC
#endif
#ifdef __REG_REGOFF_T
#undef __REG_REGOFF_T
#endif
#ifdef __REG_VOID_T
#undef __REG_VOID_T
#endif
#ifdef __REG_CONST
#undef __REG_CONST
#endif
#ifdef __REG_NOFRONT
#undef __REG_NOFRONT
#endif
#ifdef __REG_NOCHAR
#undef __REG_NOCHAR
#endif
/* interface types */
#define __REG_WIDE_T Tcl_UniChar
#define __REG_REGOFF_T long /* not really right, but good enough... */
#define __REG_VOID_T VOID
#define __REG_CONST CONST
/* names and declarations */
#define __REG_WIDE_COMPILE TclReComp
#define __REG_WIDE_EXEC TclReExec
#define __REG_NOFRONT /* don't want regcomp() and regexec() */
#define __REG_NOCHAR /* or the char versions */
#define regfree TclReFree
#define regerror TclReError
/* --- end --- */
/* /*
* interface types etc. * interface types etc.
@@ -66,17 +128,41 @@ extern "C" {
/* /*
* regoff_t has to be large enough to hold either off_t or ssize_t, * regoff_t has to be large enough to hold either off_t or ssize_t,
* and must be signed; it's only a guess that long is suitable. * and must be signed; it's only a guess that long is suitable, so we
* offer <sys/types.h> an override.
*/ */
#ifdef __REG_REGOFF_T
typedef __REG_REGOFF_T regoff_t;
#else
typedef long regoff_t; typedef long regoff_t;
#endif
/*
* For benefit of old compilers, we offer <sys/types.h> the option of
* overriding the `void' type used to declare nonexistent return types.
*/
#ifdef __REG_VOID_T
typedef __REG_VOID_T re_void;
#else
typedef void re_void;
#endif
/*
* Also for benefit of old compilers, <sys/types.h> can supply a macro
* which expands to a substitute for `const'.
*/
#ifndef __REG_CONST
#define __REG_CONST const
#endif
/* /*
* other interface types * other interface types
*/ */
/* the biggie, a compiled RE (or rather, a front end to same) */ /* the biggie, a compiled RE (or rather, a front end to same) */
typedef struct typedef struct {
{
int re_magic; /* magic number */ int re_magic; /* magic number */
size_t re_nsub; /* number of subexpressions */ size_t re_nsub; /* number of subexpressions */
long re_info; /* information about RE */ long re_info; /* information about RE */
@@ -102,22 +188,29 @@ typedef struct
} regex_t; } regex_t;
/* result reporting (may acquire more fields later) */ /* result reporting (may acquire more fields later) */
typedef struct typedef struct {
{
regoff_t rm_so; /* start of substring */ regoff_t rm_so; /* start of substring */
regoff_t rm_eo; /* end of substring */ regoff_t rm_eo; /* end of substring */
} regmatch_t; } regmatch_t;
/* supplementary control and reporting */ /* supplementary control and reporting */
typedef struct typedef struct {
{
regmatch_t rm_extend; /* see REG_EXPECT */ regmatch_t rm_extend; /* see REG_EXPECT */
} rm_detail_t; } rm_detail_t;
/* /*
* regex compilation flags * compilation
^ #ifndef __REG_NOCHAR
^ int re_comp(regex_t *, __REG_CONST char *, size_t, int);
^ #endif
^ #ifndef __REG_NOFRONT
^ int regcomp(regex_t *, __REG_CONST char *, int);
^ #endif
^ #ifdef __REG_WIDE_T
^ int __REG_WIDE_COMPILE(regex_t *, __REG_CONST __REG_WIDE_T *, size_t, int);
^ #endif
*/ */
#define REG_BASIC 000000 /* BREs (convenience) */ #define REG_BASIC 000000 /* BREs (convenience) */
#define REG_EXTENDED 000001 /* EREs */ #define REG_EXTENDED 000001 /* EREs */
@@ -132,8 +225,7 @@ typedef struct
#define REG_NLANCH 000200 /* ^ matches after \n, $ before */ #define REG_NLANCH 000200 /* ^ matches after \n, $ before */
#define REG_NEWLINE 000300 /* newlines are line terminators */ #define REG_NEWLINE 000300 /* newlines are line terminators */
#define REG_PEND 000400 /* ugh -- backward-compatibility hack */ #define REG_PEND 000400 /* ugh -- backward-compatibility hack */
#define REG_EXPECT 001000 /* report details on partial/limited #define REG_EXPECT 001000 /* report details on partial/limited matches */
* matches */
#define REG_BOSONLY 002000 /* temporary kludge for BOS-only matches */ #define REG_BOSONLY 002000 /* temporary kludge for BOS-only matches */
#define REG_DUMP 004000 /* none of your business :-) */ #define REG_DUMP 004000 /* none of your business :-) */
#define REG_FAKE 010000 /* none of your business :-) */ #define REG_FAKE 010000 /* none of your business :-) */
@@ -142,7 +234,18 @@ typedef struct
/* /*
* regex execution flags * execution
^ #ifndef __REG_NOCHAR
^ int re_exec(regex_t *, __REG_CONST char *, size_t,
^ rm_detail_t *, size_t, regmatch_t [], int);
^ #endif
^ #ifndef __REG_NOFRONT
^ int regexec(regex_t *, __REG_CONST char *, size_t, regmatch_t [], int);
^ #endif
^ #ifdef __REG_WIDE_T
^ int __REG_WIDE_EXEC(regex_t *, __REG_CONST __REG_WIDE_T *, size_t,
^ rm_detail_t *, size_t, regmatch_t [], int);
^ #endif
*/ */
#define REG_NOTBOL 0001 /* BOS is not BOL */ #define REG_NOTBOL 0001 /* BOS is not BOL */
#define REG_NOTEOL 0002 /* EOS is not EOL */ #define REG_NOTEOL 0002 /* EOS is not EOL */
@@ -152,10 +255,24 @@ typedef struct
#define REG_SMALL 0040 /* none of your business */ #define REG_SMALL 0040 /* none of your business */
/*
* misc generics (may be more functions here eventually)
^ re_void regfree(regex_t *);
*/
/* /*
* error reporting * error reporting
* Be careful if modifying the list of error codes -- the table used by * Be careful if modifying the list of error codes -- the table used by
* regerror() is generated automatically from this file! * regerror() is generated automatically from this file!
*
* Note that there is no wide-char variant of regerror at this time; what
* kind of character is used for error reports is independent of what kind
* is used in matching.
*
^ extern size_t regerror(int, __REG_CONST regex_t *, char *, size_t);
*/ */
#define REG_OKAY 0 /* no errors detected */ #define REG_OKAY 0 /* no errors detected */
#define REG_NOMATCH 1 /* failed to match */ #define REG_NOMATCH 1 /* failed to match */
@@ -173,8 +290,7 @@ typedef struct
#define REG_BADRPT 13 /* quantifier operand invalid */ #define REG_BADRPT 13 /* quantifier operand invalid */
#define REG_ASSERT 15 /* "can't happen" -- you found a bug */ #define REG_ASSERT 15 /* "can't happen" -- you found a bug */
#define REG_INVARG 16 /* invalid argument to regex function */ #define REG_INVARG 16 /* invalid argument to regex function */
#define REG_MIXED 17 /* character widths of regex and string #define REG_MIXED 17 /* character widths of regex and string differ */
* differ */
#define REG_BADOPT 18 /* invalid embedded option */ #define REG_BADOPT 18 /* invalid embedded option */
/* two specials for debugging and testing */ /* two specials for debugging and testing */
#define REG_ATOI 101 /* convert error-code name to number */ #define REG_ATOI 101 /* convert error-code name to number */
@@ -183,19 +299,43 @@ typedef struct
/* /*
* the prototypes for exported functions * the prototypes, as possibly munched by regfwd
*/ */
extern int wx_regcomp(regex_t *, const wx_wchar *, size_t, int); /* =====^!^===== begin forwards =====^!^===== */
extern int regcomp(regex_t *, const wx_wchar *, int); /* automatically gathered by fwd; do not hand-edit */
extern int wx_regexec(regex_t *, const wx_wchar *, size_t, rm_detail_t *, size_t, regmatch_t[], int); /* === regproto.h === */
extern int regexec(regex_t *, const wx_wchar *, size_t, regmatch_t[], int); #ifndef __REG_NOCHAR
extern void regfree(regex_t *); int re_comp _ANSI_ARGS_((regex_t *, __REG_CONST char *, size_t, int));
extern size_t regerror(int, const regex_t *, char *, size_t); #endif
extern void wx_regfree(regex_t *); #ifndef __REG_NOFRONT
extern size_t wx_regerror(int, const regex_t *, char *, size_t); int regcomp _ANSI_ARGS_((regex_t *, __REG_CONST char *, int));
#endif
#ifdef __REG_WIDE_T
int __REG_WIDE_COMPILE _ANSI_ARGS_((regex_t *, __REG_CONST __REG_WIDE_T *, size_t, int));
#endif
#ifndef __REG_NOCHAR
int re_exec _ANSI_ARGS_((regex_t *, __REG_CONST char *, size_t, rm_detail_t *, size_t, regmatch_t [], int));
#endif
#ifndef __REG_NOFRONT
int regexec _ANSI_ARGS_((regex_t *, __REG_CONST char *, size_t, regmatch_t [], int));
#endif
#ifdef __REG_WIDE_T
int __REG_WIDE_EXEC _ANSI_ARGS_((regex_t *, __REG_CONST __REG_WIDE_T *, size_t, rm_detail_t *, size_t, regmatch_t [], int));
#endif
re_void regfree _ANSI_ARGS_((regex_t *));
extern size_t regerror _ANSI_ARGS_((int, __REG_CONST regex_t *, char *, size_t));
/* automatically gathered by fwd; do not hand-edit */
/* =====^!^===== end forwards =====^!^===== */
/*
* more C++ voodoo
*/
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _REGEX_H_ */
#endif

439
src/regex/regexec.c
View File

@@ -27,8 +27,6 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* $Header: /projects/cvsroot/pgsql-server/src/backend/regex/regexec.c,v 1.23 2003/08/08 21:41:56 momjian Exp $
*
*/ */
#include "regguts.h" #include "regguts.h"
@@ -36,14 +34,12 @@
/* lazy-DFA representation */ /* lazy-DFA representation */
struct arcp struct arcp { /* "pointer" to an outarc */
{ /* "pointer" to an outarc */
struct sset *ss; struct sset *ss;
color co; color co;
}; };
struct sset struct sset { /* state set */
{ /* state set */
unsigned *states; /* pointer to bitvector */ unsigned *states; /* pointer to bitvector */
unsigned hash; /* hash of bitvector */ unsigned hash; /* hash of bitvector */
# define HASH(bv, nw) (((nw) == 1) ? *(bv) : hash(bv, nw)) # define HASH(bv, nw) (((nw) == 1) ? *(bv) : hash(bv, nw))
@@ -60,8 +56,7 @@ struct sset
struct arcp *inchain; /* chain-pointer vector for outarcs */ struct arcp *inchain; /* chain-pointer vector for outarcs */
}; };
struct dfa struct dfa {
{
int nssets; /* size of cache */ int nssets; /* size of cache */
int nssused; /* how many entries occupied yet */ int nssused; /* how many entries occupied yet */
int nstates; /* number of states */ int nstates; /* number of states */
@@ -75,8 +70,7 @@ struct dfa
struct cnfa *cnfa; struct cnfa *cnfa;
struct colormap *cm; struct colormap *cm;
chr *lastpost; /* location of last cache-flushed success */ chr *lastpost; /* location of last cache-flushed success */
chr *lastnopr; /* location of last cache-flushed chr *lastnopr; /* location of last cache-flushed NOPROGRESS */
* NOPROGRESS */
struct sset *search; /* replacement-search-pointer memory */ struct sset *search; /* replacement-search-pointer memory */
int cptsmalloced; /* were the areas individually malloced? */ int cptsmalloced; /* were the areas individually malloced? */
char *mallocarea; /* self, or master malloced area, or NULL */ char *mallocarea; /* self, or master malloced area, or NULL */
@@ -87,22 +81,19 @@ struct dfa
/* setup for non-malloc allocation for small cases */ /* setup for non-malloc allocation for small cases */
#define FEWSTATES 20 /* must be less than UBITS */ #define FEWSTATES 20 /* must be less than UBITS */
#define FEWCOLORS 15 #define FEWCOLORS 15
struct smalldfa struct smalldfa {
{
struct dfa dfa; struct dfa dfa;
struct sset ssets[FEWSTATES*2]; struct sset ssets[FEWSTATES*2];
unsigned statesarea[FEWSTATES*2 + WORK]; unsigned statesarea[FEWSTATES*2 + WORK];
struct sset *outsarea[FEWSTATES*2 * FEWCOLORS]; struct sset *outsarea[FEWSTATES*2 * FEWCOLORS];
struct arcp incarea[FEWSTATES*2 * FEWCOLORS]; struct arcp incarea[FEWSTATES*2 * FEWCOLORS];
}; };
#define DOMALLOC ((struct smalldfa *)NULL) /* force malloc */ #define DOMALLOC ((struct smalldfa *)NULL) /* force malloc */
/* internal variables, bundled for easy passing around */ /* internal variables, bundled for easy passing around */
struct vars struct vars {
{
regex_t *re; regex_t *re;
struct guts *g; struct guts *g;
int eflags; /* copies of arguments */ int eflags; /* copies of arguments */
@@ -116,13 +107,11 @@ struct vars
struct smalldfa dfa1; struct smalldfa dfa1;
struct smalldfa dfa2; struct smalldfa dfa2;
}; };
#define VISERR(vv) ((vv)->err != 0) /* have we seen an error yet? */ #define VISERR(vv) ((vv)->err != 0) /* have we seen an error yet? */
#define ISERR() VISERR(v) #define ISERR() VISERR(v)
#define VERR(vv,e) (((vv)->err) ? (vv)->err : ((vv)->err = (e))) #define VERR(vv,e) (((vv)->err) ? (vv)->err : ((vv)->err = (e)))
#define ERR(e) VERR(v, e) /* record an error */ #define ERR(e) VERR(v, e) /* record an error */
#define NOERR() {if (ISERR()) return v->err;} /* if error seen, return #define NOERR() {if (ISERR()) return v->err;} /* if error seen, return it */
* it */
#define OFF(p) ((p) - v->start) #define OFF(p) ((p) - v->start)
#define LOFF(p) ((long)OFF(p)) #define LOFF(p) ((long)OFF(p))
@@ -131,67 +120,63 @@ struct vars
/* /*
* forward declarations * forward declarations
*/ */
/* =====^!^===== begin forwards =====^!^===== */
/* automatically gathered by fwd; do not hand-edit */
/* === regexec.c === */ /* === regexec.c === */
static int find(struct vars *, struct cnfa *, struct colormap *); int exec _ANSI_ARGS_((regex_t *, CONST chr *, size_t, rm_detail_t *, size_t, regmatch_t [], int));
static int cfind(struct vars *, struct cnfa *, struct colormap *); static int find _ANSI_ARGS_((struct vars *, struct cnfa *, struct colormap *));
static int cfindloop(struct vars *, struct cnfa *, struct colormap *, struct dfa *, struct dfa *, chr **); static int cfind _ANSI_ARGS_((struct vars *, struct cnfa *, struct colormap *));
static void zapsubs(regmatch_t *, size_t); static int cfindloop _ANSI_ARGS_((struct vars *, struct cnfa *, struct colormap *, struct dfa *, struct dfa *, chr **));
static void zapmem(struct vars *, struct subre *); static VOID zapsubs _ANSI_ARGS_((regmatch_t *, size_t));
static void subset(struct vars *, struct subre *, chr *, chr *); static VOID zapmem _ANSI_ARGS_((struct vars *, struct subre *));
static int dissect(struct vars *, struct subre *, chr *, chr *); static VOID subset _ANSI_ARGS_((struct vars *, struct subre *, chr *, chr *));
static int condissect(struct vars *, struct subre *, chr *, chr *); static int dissect _ANSI_ARGS_((struct vars *, struct subre *, chr *, chr *));
static int altdissect(struct vars *, struct subre *, chr *, chr *); static int condissect _ANSI_ARGS_((struct vars *, struct subre *, chr *, chr *));
static int cdissect(struct vars *, struct subre *, chr *, chr *); static int altdissect _ANSI_ARGS_((struct vars *, struct subre *, chr *, chr *));
static int ccondissect(struct vars *, struct subre *, chr *, chr *); static int cdissect _ANSI_ARGS_((struct vars *, struct subre *, chr *, chr *));
static int crevdissect(struct vars *, struct subre *, chr *, chr *); static int ccondissect _ANSI_ARGS_((struct vars *, struct subre *, chr *, chr *));
static int cbrdissect(struct vars *, struct subre *, chr *, chr *); static int crevdissect _ANSI_ARGS_((struct vars *, struct subre *, chr *, chr *));
static int caltdissect(struct vars *, struct subre *, chr *, chr *); static int cbrdissect _ANSI_ARGS_((struct vars *, struct subre *, chr *, chr *));
static int caltdissect _ANSI_ARGS_((struct vars *, struct subre *, chr *, chr *));
/* === rege_dfa.c === */ /* === rege_dfa.c === */
static chr *longest(struct vars *, struct dfa *, chr *, chr *, int *); static chr *longest _ANSI_ARGS_((struct vars *, struct dfa *, chr *, chr *, int *));
static chr *shortest(struct vars *, struct dfa *, chr *, chr *, chr *, chr **, int *); static chr *shortest _ANSI_ARGS_((struct vars *, struct dfa *, chr *, chr *, chr *, chr **, int *));
static chr *lastcold(struct vars *, struct dfa *); static chr *lastcold _ANSI_ARGS_((struct vars *, struct dfa *));
static struct dfa *newdfa(struct vars *, struct cnfa *, struct colormap *, struct smalldfa *); static struct dfa *newdfa _ANSI_ARGS_((struct vars *, struct cnfa *, struct colormap *, struct smalldfa *));
static void freedfa(struct dfa *); static VOID freedfa _ANSI_ARGS_((struct dfa *));
static unsigned hash(unsigned *, int); static unsigned hash _ANSI_ARGS_((unsigned *, int));
static struct sset *initialize(struct vars *, struct dfa *, chr *); static struct sset *initialize _ANSI_ARGS_((struct vars *, struct dfa *, chr *));
static struct sset *miss(struct vars *, struct dfa *, struct sset *, pcolor, chr *, chr *); static struct sset *miss _ANSI_ARGS_((struct vars *, struct dfa *, struct sset *, pcolor, chr *, chr *));
static int lacon(struct vars *, struct cnfa *, chr *, pcolor); static int lacon _ANSI_ARGS_((struct vars *, struct cnfa *, chr *, pcolor));
static struct sset *getvacant(struct vars *, struct dfa *, chr *, chr *); static struct sset *getvacant _ANSI_ARGS_((struct vars *, struct dfa *, chr *, chr *));
static struct sset *pickss(struct vars *, struct dfa *, chr *, chr *); static struct sset *pickss _ANSI_ARGS_((struct vars *, struct dfa *, chr *, chr *));
/* automatically gathered by fwd; do not hand-edit */
/* =====^!^===== end forwards =====^!^===== */
/* /*
* regexec - match regular expression - exec - match regular expression
^ int exec(regex_t *, CONST chr *, size_t, rm_detail_t *,
^ size_t, regmatch_t [], int);
*/ */
int int
regexec(regex_t *re, exec(re, string, len, details, nmatch, pmatch, flags)
const chr *string, regex_t *re;
size_t nmatch, CONST chr *string;
regmatch_t pmatch[], size_t len;
int flags) rm_detail_t *details;
{ size_t nmatch;
rm_detail_t det; regmatch_t pmatch[];
return wx_regexec(re, string, wx_strlen(string), &det, nmatch, pmatch, flags); int flags;
}
int
wx_regexec(regex_t *re,
const chr *string,
size_t len,
rm_detail_t *details,
size_t nmatch,
regmatch_t pmatch[],
int flags)
{ {
struct vars var; struct vars var;
register struct vars *v = &var; register struct vars *v = &var;
int st; int st;
size_t n; size_t n;
int backref; int backref;
# define LOCALMAT 20 # define LOCALMAT 20
regmatch_t mat[LOCALMAT]; regmatch_t mat[LOCALMAT];
# define LOCALMEM 40 # define LOCALMEM 40
regoff_t mem[LOCALMEM]; regoff_t mem[LOCALMEM];
@@ -213,8 +198,7 @@ wx_regexec(regex_t *re,
if (v->g->cflags&REG_NOSUB) if (v->g->cflags&REG_NOSUB)
nmatch = 0; /* override client */ nmatch = 0; /* override client */
v->nmatch = nmatch; v->nmatch = nmatch;
if (backref) if (backref) {
{
/* need work area */ /* need work area */
if (v->g->nsub + 1 <= LOCALMAT) if (v->g->nsub + 1 <= LOCALMAT)
v->pmatch = mat; v->pmatch = mat;
@@ -224,15 +208,13 @@ wx_regexec(regex_t *re,
if (v->pmatch == NULL) if (v->pmatch == NULL)
return REG_ESPACE; return REG_ESPACE;
v->nmatch = v->g->nsub + 1; v->nmatch = v->g->nsub + 1;
} } else
else
v->pmatch = pmatch; v->pmatch = pmatch;
v->details = details; v->details = details;
v->start = (chr *)string; v->start = (chr *)string;
v->stop = (chr *)string + len; v->stop = (chr *)string + len;
v->err = 0; v->err = 0;
if (backref) if (backref) {
{
/* need retry memory */ /* need retry memory */
assert(v->g->ntree >= 0); assert(v->g->ntree >= 0);
n = (size_t)v->g->ntree; n = (size_t)v->g->ntree;
@@ -240,14 +222,12 @@ wx_regexec(regex_t *re,
v->mem = mem; v->mem = mem;
else else
v->mem = (regoff_t *)MALLOC(n*sizeof(regoff_t)); v->mem = (regoff_t *)MALLOC(n*sizeof(regoff_t));
if (v->mem == NULL) if (v->mem == NULL) {
{
if (v->pmatch != pmatch && v->pmatch != mat) if (v->pmatch != pmatch && v->pmatch != mat)
FREE(v->pmatch); FREE(v->pmatch);
return REG_ESPACE; return REG_ESPACE;
} }
} } else
else
v->mem = NULL; v->mem = NULL;
/* do it */ /* do it */
@@ -258,8 +238,7 @@ wx_regexec(regex_t *re,
st = find(v, &v->g->tree->cnfa, &v->g->cmap); st = find(v, &v->g->tree->cnfa, &v->g->cmap);
/* copy (portion of) match vector over if necessary */ /* copy (portion of) match vector over if necessary */
if (st == REG_OKAY && v->pmatch != pmatch && nmatch > 0) if (st == REG_OKAY && v->pmatch != pmatch && nmatch > 0) {
{
zapsubs(pmatch, nmatch); zapsubs(pmatch, nmatch);
n = (nmatch < v->nmatch) ? nmatch : v->nmatch; n = (nmatch < v->nmatch) ? nmatch : v->nmatch;
memcpy(VS(pmatch), VS(v->pmatch), n*sizeof(regmatch_t)); memcpy(VS(pmatch), VS(v->pmatch), n*sizeof(regmatch_t));
@@ -274,20 +253,21 @@ wx_regexec(regex_t *re,
} }
/* /*
* find - find a match for the main NFA (no-complications case) - find - find a match for the main NFA (no-complications case)
^ static int find(struct vars *, struct cnfa *, struct colormap *);
*/ */
static int static int
find(struct vars * v, find(v, cnfa, cm)
struct cnfa * cnfa, struct vars *v;
struct colormap * cm) struct cnfa *cnfa;
struct colormap *cm;
{ {
struct dfa *s; struct dfa *s;
struct dfa *d; struct dfa *d;
chr *begin; chr *begin;
chr *end = NULL; chr *end = NULL;
chr *cold; chr *cold;
chr *open; /* open and close of range of possible chr *open; /* open and close of range of possible starts */
* starts */
chr *close; chr *close;
int hitend; int hitend;
int shorter = (v->g->tree->flags&SHORTER) ? 1 : 0; int shorter = (v->g->tree->flags&SHORTER) ? 1 : 0;
@@ -301,8 +281,7 @@ find(struct vars * v,
close = shortest(v, s, v->start, v->start, v->stop, &cold, (int *)NULL); close = shortest(v, s, v->start, v->start, v->stop, &cold, (int *)NULL);
freedfa(s); freedfa(s);
NOERR(); NOERR();
if (v->g->cflags & REG_EXPECT) if (v->g->cflags&REG_EXPECT) {
{
assert(v->details != NULL); assert(v->details != NULL);
if (cold != NULL) if (cold != NULL)
v->details->rm_extend.rm_so = OFF(cold); v->details->rm_extend.rm_so = OFF(cold);
@@ -323,8 +302,7 @@ find(struct vars * v,
d = newdfa(v, cnfa, cm, &v->dfa1); d = newdfa(v, cnfa, cm, &v->dfa1);
assert(!(ISERR() && d != NULL)); assert(!(ISERR() && d != NULL));
NOERR(); NOERR();
for (begin = open; begin <= close; begin++) for (begin = open; begin <= close; begin++) {
{
MDEBUG(("\nfind trying at %ld\n", LOFF(begin))); MDEBUG(("\nfind trying at %ld\n", LOFF(begin)));
if (shorter) if (shorter)
end = shortest(v, d, begin, begin, v->stop, end = shortest(v, d, begin, begin, v->stop,
@@ -344,8 +322,7 @@ find(struct vars * v,
assert(v->nmatch > 0); assert(v->nmatch > 0);
v->pmatch[0].rm_so = OFF(begin); v->pmatch[0].rm_so = OFF(begin);
v->pmatch[0].rm_eo = OFF(end); v->pmatch[0].rm_eo = OFF(end);
if (v->g->cflags & REG_EXPECT) if (v->g->cflags&REG_EXPECT) {
{
if (cold != NULL) if (cold != NULL)
v->details->rm_extend.rm_so = OFF(cold); v->details->rm_extend.rm_so = OFF(cold);
else else
@@ -361,12 +338,14 @@ find(struct vars * v,
} }
/* /*
* cfind - find a match for the main NFA (with complications) - cfind - find a match for the main NFA (with complications)
^ static int cfind(struct vars *, struct cnfa *, struct colormap *);
*/ */
static int static int
cfind(struct vars * v, cfind(v, cnfa, cm)
struct cnfa * cnfa, struct vars *v;
struct colormap * cm) struct cnfa *cnfa;
struct colormap *cm;
{ {
struct dfa *s; struct dfa *s;
struct dfa *d; struct dfa *d;
@@ -376,8 +355,7 @@ cfind(struct vars * v,
s = newdfa(v, &v->g->search, cm, &v->dfa1); s = newdfa(v, &v->g->search, cm, &v->dfa1);
NOERR(); NOERR();
d = newdfa(v, cnfa, cm, &v->dfa2); d = newdfa(v, cnfa, cm, &v->dfa2);
if (ISERR()) if (ISERR()) {
{
assert(d == NULL); assert(d == NULL);
freedfa(s); freedfa(s);
return v->err; return v->err;
@@ -388,8 +366,7 @@ cfind(struct vars * v,
freedfa(d); freedfa(d);
freedfa(s); freedfa(s);
NOERR(); NOERR();
if (v->g->cflags & REG_EXPECT) if (v->g->cflags&REG_EXPECT) {
{
assert(v->details != NULL); assert(v->details != NULL);
if (cold != NULL) if (cold != NULL)
v->details->rm_extend.rm_so = OFF(cold); v->details->rm_extend.rm_so = OFF(cold);
@@ -401,21 +378,23 @@ cfind(struct vars * v,
} }
/* /*
* cfindloop - the heart of cfind - cfindloop - the heart of cfind
^ static int cfindloop(struct vars *, struct cnfa *, struct colormap *,
^ struct dfa *, struct dfa *, chr **);
*/ */
static int static int
cfindloop(struct vars * v, cfindloop(v, cnfa, cm, d, s, coldp)
struct cnfa * cnfa, struct vars *v;
struct colormap * cm, struct cnfa *cnfa;
struct dfa * d, struct colormap *cm;
struct dfa * s, struct dfa *d;
chr **coldp) /* where to put coldstart pointer */ struct dfa *s;
chr **coldp; /* where to put coldstart pointer */
{ {
chr *begin; chr *begin;
chr *end; chr *end;
chr *cold; chr *cold;
chr *open; /* open and close of range of possible chr *open; /* open and close of range of possible starts */
* starts */
chr *close; chr *close;
chr *estart; chr *estart;
chr *estop; chr *estop;
@@ -426,8 +405,7 @@ cfindloop(struct vars * v,
assert(d != NULL && s != NULL); assert(d != NULL && s != NULL);
cold = NULL; cold = NULL;
close = v->start; close = v->start;
do do {
{
MDEBUG(("\ncsearch at %ld\n", LOFF(close))); MDEBUG(("\ncsearch at %ld\n", LOFF(close)));
close = shortest(v, s, close, close, v->stop, &cold, (int *)NULL); close = shortest(v, s, close, close, v->stop, &cold, (int *)NULL);
if (close == NULL) if (close == NULL)
@@ -436,13 +414,11 @@ cfindloop(struct vars * v,
open = cold; open = cold;
cold = NULL; cold = NULL;
MDEBUG(("cbetween %ld and %ld\n", LOFF(open), LOFF(close))); MDEBUG(("cbetween %ld and %ld\n", LOFF(open), LOFF(close)));
for (begin = open; begin <= close; begin++) for (begin = open; begin <= close; begin++) {
{
MDEBUG(("\ncfind trying at %ld\n", LOFF(begin))); MDEBUG(("\ncfind trying at %ld\n", LOFF(begin)));
estart = begin; estart = begin;
estop = v->stop; estop = v->stop;
for (;;) for (;;) {
{
if (shorter) if (shorter)
end = shortest(v, d, begin, estart, end = shortest(v, d, begin, estart,
estop, (chr **)NULL, &hitend); estop, (chr **)NULL, &hitend);
@@ -457,23 +433,19 @@ cfindloop(struct vars * v,
zapsubs(v->pmatch, v->nmatch); zapsubs(v->pmatch, v->nmatch);
zapmem(v, v->g->tree); zapmem(v, v->g->tree);
er = cdissect(v, v->g->tree, begin, end); er = cdissect(v, v->g->tree, begin, end);
if (er == REG_OKAY) if (er == REG_OKAY) {
{ if (v->nmatch > 0) {
if (v->nmatch > 0)
{
v->pmatch[0].rm_so = OFF(begin); v->pmatch[0].rm_so = OFF(begin);
v->pmatch[0].rm_eo = OFF(end); v->pmatch[0].rm_eo = OFF(end);
} }
*coldp = cold; *coldp = cold;
return REG_OKAY; return REG_OKAY;
} }
if (er != REG_NOMATCH) if (er != REG_NOMATCH) {
{
ERR(er); ERR(er);
return er; return er;
} }
if ((shorter) ? end == estop : end == begin) if ((shorter) ? end == estop : end == begin) {
{
/* no point in trying again */ /* no point in trying again */
*coldp = cold; *coldp = cold;
return REG_NOMATCH; return REG_NOMATCH;
@@ -492,35 +464,37 @@ cfindloop(struct vars * v,
} }
/* /*
* zapsubs - initialize the subexpression matches to "no match" - zapsubs - initialize the subexpression matches to "no match"
^ static VOID zapsubs(regmatch_t *, size_t);
*/ */
static void static VOID
zapsubs(regmatch_t *p, zapsubs(p, n)
size_t n) regmatch_t *p;
size_t n;
{ {
size_t i; size_t i;
for (i = n - 1; i > 0; i--) for (i = n-1; i > 0; i--) {
{
p[i].rm_so = -1; p[i].rm_so = -1;
p[i].rm_eo = -1; p[i].rm_eo = -1;
} }
} }
/* /*
* zapmem - initialize the retry memory of a subtree to zeros - zapmem - initialize the retry memory of a subtree to zeros
^ static VOID zapmem(struct vars *, struct subre *);
*/ */
static void static VOID
zapmem(struct vars * v, zapmem(v, t)
struct subre * t) struct vars *v;
struct subre *t;
{ {
if (t == NULL) if (t == NULL)
return; return;
assert(v->mem != NULL); assert(v->mem != NULL);
v->mem[t->retry] = 0; v->mem[t->retry] = 0;
if (t->op == '(') if (t->op == '(') {
{
assert(t->subno > 0); assert(t->subno > 0);
v->pmatch[t->subno].rm_so = -1; v->pmatch[t->subno].rm_so = -1;
v->pmatch[t->subno].rm_eo = -1; v->pmatch[t->subno].rm_eo = -1;
@@ -533,13 +507,15 @@ zapmem(struct vars * v,
} }
/* /*
* subset - set any subexpression relevant to a successful subre - subset - set any subexpression relevant to a successful subre
^ static VOID subset(struct vars *, struct subre *, chr *, chr *);
*/ */
static void static VOID
subset(struct vars * v, subset(v, sub, begin, end)
struct subre * sub, struct vars *v;
chr *begin, struct subre *sub;
chr *end) chr *begin;
chr *end;
{ {
int n = sub->subno; int n = sub->subno;
@@ -553,19 +529,20 @@ subset(struct vars * v,
} }
/* /*
* dissect - determine subexpression matches (uncomplicated case) - dissect - determine subexpression matches (uncomplicated case)
^ static int dissect(struct vars *, struct subre *, chr *, chr *);
*/ */
static int /* regexec return code */ static int /* regexec return code */
dissect(struct vars * v, dissect(v, t, begin, end)
struct subre * t, struct vars *v;
chr *begin, /* beginning of relevant substring */ struct subre *t;
chr *end) /* end of same */ chr *begin; /* beginning of relevant substring */
chr *end; /* end of same */
{ {
assert(t != NULL); assert(t != NULL);
MDEBUG(("dissect %ld-%ld\n", LOFF(begin), LOFF(end))); MDEBUG(("dissect %ld-%ld\n", LOFF(begin), LOFF(end)));
switch (t->op) switch (t->op) {
{
case '=': /* terminal node */ case '=': /* terminal node */
assert(t->left == NULL && t->right == NULL); assert(t->left == NULL && t->right == NULL);
return REG_OKAY; /* no action, parent did the work */ return REG_OKAY; /* no action, parent did the work */
@@ -594,13 +571,15 @@ dissect(struct vars * v,
} }
/* /*
* condissect - determine concatenation subexpression matches (uncomplicated) - condissect - determine concatenation subexpression matches (uncomplicated)
^ static int condissect(struct vars *, struct subre *, chr *, chr *);
*/ */
static int /* regexec return code */ static int /* regexec return code */
condissect(struct vars * v, condissect(v, t, begin, end)
struct subre * t, struct vars *v;
chr *begin, /* beginning of relevant substring */ struct subre *t;
chr *end) /* end of same */ chr *begin; /* beginning of relevant substring */
chr *end; /* end of same */
{ {
struct dfa *d; struct dfa *d;
struct dfa *d2; struct dfa *d2;
@@ -616,8 +595,7 @@ condissect(struct vars * v,
d = newdfa(v, &t->left->cnfa, &v->g->cmap, &v->dfa1); d = newdfa(v, &t->left->cnfa, &v->g->cmap, &v->dfa1);
NOERR(); NOERR();
d2 = newdfa(v, &t->right->cnfa, &v->g->cmap, &v->dfa2); d2 = newdfa(v, &t->right->cnfa, &v->g->cmap, &v->dfa2);
if (ISERR()) if (ISERR()) {
{
assert(d2 == NULL); assert(d2 == NULL);
freedfa(d); freedfa(d);
return v->err; return v->err;
@@ -629,8 +607,7 @@ condissect(struct vars * v,
(int *)NULL); (int *)NULL);
else else
mid = longest(v, d, begin, end, (int *)NULL); mid = longest(v, d, begin, end, (int *)NULL);
if (mid == NULL) if (mid == NULL) {
{
freedfa(d); freedfa(d);
freedfa(d2); freedfa(d2);
return REG_ASSERT; return REG_ASSERT;
@@ -638,11 +615,9 @@ condissect(struct vars * v,
MDEBUG(("tentative midpoint %ld\n", LOFF(mid))); MDEBUG(("tentative midpoint %ld\n", LOFF(mid)));
/* iterate until satisfaction or failure */ /* iterate until satisfaction or failure */
while (longest(v, d2, mid, end, (int *) NULL) != end) while (longest(v, d2, mid, end, (int *)NULL) != end) {
{
/* that midpoint didn't work, find a new one */ /* that midpoint didn't work, find a new one */
if (mid == stop) if (mid == stop) {
{
/* all possibilities exhausted! */ /* all possibilities exhausted! */
MDEBUG(("no midpoint!\n")); MDEBUG(("no midpoint!\n"));
freedfa(d); freedfa(d);
@@ -654,8 +629,7 @@ condissect(struct vars * v,
(int *)NULL); (int *)NULL);
else else
mid = longest(v, d, begin, mid-1, (int *)NULL); mid = longest(v, d, begin, mid-1, (int *)NULL);
if (mid == NULL) if (mid == NULL) {
{
/* failed to find a new one! */ /* failed to find a new one! */
MDEBUG(("failed midpoint!\n")); MDEBUG(("failed midpoint!\n"));
freedfa(d); freedfa(d);
@@ -676,13 +650,15 @@ condissect(struct vars * v,
} }
/* /*
* altdissect - determine alternative subexpression matches (uncomplicated) - altdissect - determine alternative subexpression matches (uncomplicated)
^ static int altdissect(struct vars *, struct subre *, chr *, chr *);
*/ */
static int /* regexec return code */ static int /* regexec return code */
altdissect(struct vars * v, altdissect(v, t, begin, end)
struct subre * t, struct vars *v;
chr *begin, /* beginning of relevant substring */ struct subre *t;
chr *end) /* end of same */ chr *begin; /* beginning of relevant substring */
chr *end; /* end of same */
{ {
struct dfa *d; struct dfa *d;
int i; int i;
@@ -690,15 +666,13 @@ altdissect(struct vars * v,
assert(t != NULL); assert(t != NULL);
assert(t->op == '|'); assert(t->op == '|');
for (i = 0; t != NULL; t = t->right, i++) for (i = 0; t != NULL; t = t->right, i++) {
{
MDEBUG(("trying %dth\n", i)); MDEBUG(("trying %dth\n", i));
assert(t->left != NULL && t->left->cnfa.nstates > 0); assert(t->left != NULL && t->left->cnfa.nstates > 0);
d = newdfa(v, &t->left->cnfa, &v->g->cmap, &v->dfa1); d = newdfa(v, &t->left->cnfa, &v->g->cmap, &v->dfa1);
if (ISERR()) if (ISERR())
return v->err; return v->err;
if (longest(v, d, begin, end, (int *) NULL) == end) if (longest(v, d, begin, end, (int *)NULL) == end) {
{
MDEBUG(("success\n")); MDEBUG(("success\n"));
freedfa(d); freedfa(d);
return dissect(v, t->left, begin, end); return dissect(v, t->left, begin, end);
@@ -709,23 +683,24 @@ altdissect(struct vars * v,
} }
/* /*
* cdissect - determine subexpression matches (with complications) - cdissect - determine subexpression matches (with complications)
* The retry memory stores the offset of the trial midpoint from begin, * The retry memory stores the offset of the trial midpoint from begin,
* plus 1 so that 0 uniquely means "clean slate". * plus 1 so that 0 uniquely means "clean slate".
^ static int cdissect(struct vars *, struct subre *, chr *, chr *);
*/ */
static int /* regexec return code */ static int /* regexec return code */
cdissect(struct vars * v, cdissect(v, t, begin, end)
struct subre * t, struct vars *v;
chr *begin, /* beginning of relevant substring */ struct subre *t;
chr *end) /* end of same */ chr *begin; /* beginning of relevant substring */
chr *end; /* end of same */
{ {
int er; int er;
assert(t != NULL); assert(t != NULL);
MDEBUG(("cdissect %ld-%ld %c\n", LOFF(begin), LOFF(end), t->op)); MDEBUG(("cdissect %ld-%ld %c\n", LOFF(begin), LOFF(end), t->op));
switch (t->op) switch (t->op) {
{
case '=': /* terminal node */ case '=': /* terminal node */
assert(t->left == NULL && t->right == NULL); assert(t->left == NULL && t->right == NULL);
return REG_OKAY; /* no action, parent did the work */ return REG_OKAY; /* no action, parent did the work */
@@ -757,15 +732,17 @@ cdissect(struct vars * v,
} }
/* /*
* ccondissect - concatenation subexpression matches (with complications) - ccondissect - concatenation subexpression matches (with complications)
* The retry memory stores the offset of the trial midpoint from begin, * The retry memory stores the offset of the trial midpoint from begin,
* plus 1 so that 0 uniquely means "clean slate". * plus 1 so that 0 uniquely means "clean slate".
^ static int ccondissect(struct vars *, struct subre *, chr *, chr *);
*/ */
static int /* regexec return code */ static int /* regexec return code */
ccondissect(struct vars * v, ccondissect(v, t, begin, end)
struct subre * t, struct vars *v;
chr *begin, /* beginning of relevant substring */ struct subre *t;
chr *end) /* end of same */ chr *begin; /* beginning of relevant substring */
chr *end; /* end of same */
{ {
struct dfa *d; struct dfa *d;
struct dfa *d2; struct dfa *d2;
@@ -783,35 +760,29 @@ ccondissect(struct vars * v,
if (ISERR()) if (ISERR())
return v->err; return v->err;
d2 = newdfa(v, &t->right->cnfa, &v->g->cmap, DOMALLOC); d2 = newdfa(v, &t->right->cnfa, &v->g->cmap, DOMALLOC);
if (ISERR()) if (ISERR()) {
{
freedfa(d); freedfa(d);
return v->err; return v->err;
} }
MDEBUG(("cconcat %d\n", t->retry)); MDEBUG(("cconcat %d\n", t->retry));
/* pick a tentative midpoint */ /* pick a tentative midpoint */
if (v->mem[t->retry] == 0) if (v->mem[t->retry] == 0) {
{
mid = longest(v, d, begin, end, (int *)NULL); mid = longest(v, d, begin, end, (int *)NULL);
if (mid == NULL) if (mid == NULL) {
{
freedfa(d); freedfa(d);
freedfa(d2); freedfa(d2);
return REG_NOMATCH; return REG_NOMATCH;
} }
MDEBUG(("tentative midpoint %ld\n", LOFF(mid))); MDEBUG(("tentative midpoint %ld\n", LOFF(mid)));
v->mem[t->retry] = (mid - begin) + 1; v->mem[t->retry] = (mid - begin) + 1;
} } else {
else
{
mid = begin + (v->mem[t->retry] - 1); mid = begin + (v->mem[t->retry] - 1);
MDEBUG(("working midpoint %ld\n", LOFF(mid))); MDEBUG(("working midpoint %ld\n", LOFF(mid)));
} }
/* iterate until satisfaction or failure */ /* iterate until satisfaction or failure */
for (;;) for (;;) {
{
/* try this midpoint on for size */ /* try this midpoint on for size */
er = cdissect(v, t->left, begin, mid); er = cdissect(v, t->left, begin, mid);
if (er == REG_OKAY && if (er == REG_OKAY &&
@@ -819,16 +790,14 @@ ccondissect(struct vars * v,
(er = cdissect(v, t->right, mid, end)) == (er = cdissect(v, t->right, mid, end)) ==
REG_OKAY) REG_OKAY)
break; /* NOTE BREAK OUT */ break; /* NOTE BREAK OUT */
if (er != REG_OKAY && er != REG_NOMATCH) if (er != REG_OKAY && er != REG_NOMATCH) {
{
freedfa(d); freedfa(d);
freedfa(d2); freedfa(d2);
return er; return er;
} }
/* that midpoint didn't work, find a new one */ /* that midpoint didn't work, find a new one */
if (mid == begin) if (mid == begin) {
{
/* all possibilities exhausted */ /* all possibilities exhausted */
MDEBUG(("%d no midpoint\n", t->retry)); MDEBUG(("%d no midpoint\n", t->retry));
freedfa(d); freedfa(d);
@@ -836,8 +805,7 @@ ccondissect(struct vars * v,
return REG_NOMATCH; return REG_NOMATCH;
} }
mid = longest(v, d, begin, mid-1, (int *)NULL); mid = longest(v, d, begin, mid-1, (int *)NULL);
if (mid == NULL) if (mid == NULL) {
{
/* failed to find a new one */ /* failed to find a new one */
MDEBUG(("%d failed midpoint\n", t->retry)); MDEBUG(("%d failed midpoint\n", t->retry));
freedfa(d); freedfa(d);
@@ -858,15 +826,17 @@ ccondissect(struct vars * v,
} }
/* /*
* crevdissect - determine backref shortest-first subexpression matches - crevdissect - determine backref shortest-first subexpression matches
* The retry memory stores the offset of the trial midpoint from begin, * The retry memory stores the offset of the trial midpoint from begin,
* plus 1 so that 0 uniquely means "clean slate". * plus 1 so that 0 uniquely means "clean slate".
^ static int crevdissect(struct vars *, struct subre *, chr *, chr *);
*/ */
static int /* regexec return code */ static int /* regexec return code */
crevdissect(struct vars * v, crevdissect(v, t, begin, end)
struct subre * t, struct vars *v;
chr *begin, /* beginning of relevant substring */ struct subre *t;
chr *end) /* end of same */ chr *begin; /* beginning of relevant substring */
chr *end; /* end of same */
{ {
struct dfa *d; struct dfa *d;
struct dfa *d2; struct dfa *d2;
@@ -883,35 +853,29 @@ crevdissect(struct vars * v,
if (ISERR()) if (ISERR())
return v->err; return v->err;
d2 = newdfa(v, &t->right->cnfa, &v->g->cmap, DOMALLOC); d2 = newdfa(v, &t->right->cnfa, &v->g->cmap, DOMALLOC);
if (ISERR()) if (ISERR()) {
{
freedfa(d); freedfa(d);
return v->err; return v->err;
} }
MDEBUG(("crev %d\n", t->retry)); MDEBUG(("crev %d\n", t->retry));
/* pick a tentative midpoint */ /* pick a tentative midpoint */
if (v->mem[t->retry] == 0) if (v->mem[t->retry] == 0) {
{
mid = shortest(v, d, begin, begin, end, (chr **)NULL, (int *)NULL); mid = shortest(v, d, begin, begin, end, (chr **)NULL, (int *)NULL);
if (mid == NULL) if (mid == NULL) {
{
freedfa(d); freedfa(d);
freedfa(d2); freedfa(d2);
return REG_NOMATCH; return REG_NOMATCH;
} }
MDEBUG(("tentative midpoint %ld\n", LOFF(mid))); MDEBUG(("tentative midpoint %ld\n", LOFF(mid)));
v->mem[t->retry] = (mid - begin) + 1; v->mem[t->retry] = (mid - begin) + 1;
} } else {
else
{
mid = begin + (v->mem[t->retry] - 1); mid = begin + (v->mem[t->retry] - 1);
MDEBUG(("working midpoint %ld\n", LOFF(mid))); MDEBUG(("working midpoint %ld\n", LOFF(mid)));
} }
/* iterate until satisfaction or failure */ /* iterate until satisfaction or failure */
for (;;) for (;;) {
{
/* try this midpoint on for size */ /* try this midpoint on for size */
er = cdissect(v, t->left, begin, mid); er = cdissect(v, t->left, begin, mid);
if (er == REG_OKAY && if (er == REG_OKAY &&
@@ -919,16 +883,14 @@ crevdissect(struct vars * v,
(er = cdissect(v, t->right, mid, end)) == (er = cdissect(v, t->right, mid, end)) ==
REG_OKAY) REG_OKAY)
break; /* NOTE BREAK OUT */ break; /* NOTE BREAK OUT */
if (er != REG_OKAY && er != REG_NOMATCH) if (er != REG_OKAY && er != REG_NOMATCH) {
{
freedfa(d); freedfa(d);
freedfa(d2); freedfa(d2);
return er; return er;
} }
/* that midpoint didn't work, find a new one */ /* that midpoint didn't work, find a new one */
if (mid == end) if (mid == end) {
{
/* all possibilities exhausted */ /* all possibilities exhausted */
MDEBUG(("%d no midpoint\n", t->retry)); MDEBUG(("%d no midpoint\n", t->retry));
freedfa(d); freedfa(d);
@@ -936,8 +898,7 @@ crevdissect(struct vars * v,
return REG_NOMATCH; return REG_NOMATCH;
} }
mid = shortest(v, d, begin, mid+1, end, (chr **)NULL, (int *)NULL); mid = shortest(v, d, begin, mid+1, end, (chr **)NULL, (int *)NULL);
if (mid == NULL) if (mid == NULL) {
{
/* failed to find a new one */ /* failed to find a new one */
MDEBUG(("%d failed midpoint\n", t->retry)); MDEBUG(("%d failed midpoint\n", t->retry));
freedfa(d); freedfa(d);
@@ -958,13 +919,15 @@ crevdissect(struct vars * v,
} }
/* /*
* cbrdissect - determine backref subexpression matches - cbrdissect - determine backref subexpression matches
^ static int cbrdissect(struct vars *, struct subre *, chr *, chr *);
*/ */
static int /* regexec return code */ static int /* regexec return code */
cbrdissect(struct vars * v, cbrdissect(v, t, begin, end)
struct subre * t, struct vars *v;
chr *begin, /* beginning of relevant substring */ struct subre *t;
chr *end) /* end of same */ chr *begin; /* beginning of relevant substring */
chr *end; /* end of same */
{ {
int i; int i;
int n = t->subno; int n = t->subno;
@@ -993,8 +956,7 @@ cbrdissect(struct vars * v,
v->mem[t->retry] = 1; v->mem[t->retry] = 1;
/* special-case zero-length string */ /* special-case zero-length string */
if (len == 0) if (len == 0) {
{
if (begin == end) if (begin == end)
return REG_OKAY; return REG_OKAY;
return REG_NOMATCH; return REG_NOMATCH;
@@ -1008,8 +970,7 @@ cbrdissect(struct vars * v,
/* count occurrences */ /* count occurrences */
i = 0; i = 0;
for (p = begin; p <= stop && (i < max || max == INFINITY); p += len) for (p = begin; p <= stop && (i < max || max == INFINITY); p += len) {
{
if ((*v->g->compare)(paren, p, len) != 0) if ((*v->g->compare)(paren, p, len) != 0)
break; break;
i++; i++;
@@ -1025,21 +986,21 @@ cbrdissect(struct vars * v,
} }
/* /*
* caltdissect - determine alternative subexpression matches (w. complications) - caltdissect - determine alternative subexpression matches (w. complications)
^ static int caltdissect(struct vars *, struct subre *, chr *, chr *);
*/ */
static int /* regexec return code */ static int /* regexec return code */
caltdissect(struct vars * v, caltdissect(v, t, begin, end)
struct subre * t, struct vars *v;
chr *begin, /* beginning of relevant substring */ struct subre *t;
chr *end) /* end of same */ chr *begin; /* beginning of relevant substring */
chr *end; /* end of same */
{ {
struct dfa *d; struct dfa *d;
int er; int er;
# define UNTRIED 0 /* not yet tried at all */ # define UNTRIED 0 /* not yet tried at all */
# define TRYING 1 /* top matched, trying submatches */ # define TRYING 1 /* top matched, trying submatches */
#define TRIED 2 /* top didn't match or submatches # define TRIED 2 /* top didn't match or submatches exhausted */
* exhausted */
if (t == NULL) if (t == NULL)
return REG_NOMATCH; return REG_NOMATCH;
@@ -1050,13 +1011,11 @@ caltdissect(struct vars * v,
MDEBUG(("calt n%d\n", t->retry)); MDEBUG(("calt n%d\n", t->retry));
assert(t->left != NULL); assert(t->left != NULL);
if (v->mem[t->retry] == UNTRIED) if (v->mem[t->retry] == UNTRIED) {
{
d = newdfa(v, &t->left->cnfa, &v->g->cmap, DOMALLOC); d = newdfa(v, &t->left->cnfa, &v->g->cmap, DOMALLOC);
if (ISERR()) if (ISERR())
return v->err; return v->err;
if (longest(v, d, begin, end, (int *) NULL) != end) if (longest(v, d, begin, end, (int *)NULL) != end) {
{
freedfa(d); freedfa(d);
v->mem[t->retry] = TRIED; v->mem[t->retry] = TRIED;
return caltdissect(v, t->right, begin, end); return caltdissect(v, t->right, begin, end);

12
src/regex/regfree.c
View File

@@ -27,7 +27,6 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* $Header: /projects/cvsroot/pgsql-server/src/backend/regex/regfree.c,v 1.17 2003/08/04 00:43:21 momjian Exp $
* *
* *
* You might think that this could be incorporated into regcomp.c, and * You might think that this could be incorporated into regcomp.c, and
@@ -39,17 +38,14 @@
#include "regguts.h" #include "regguts.h"
/* /*
* pg_regfree - free an RE (generic function, punts to RE-specific function) - regfree - free an RE (generic function, punts to RE-specific function)
* *
* Ignoring invocation with NULL is a convenience. * Ignoring invocation with NULL is a convenience.
*/ */
void VOID
regfree(regex_t *re) regfree(re)
{ wx_regfree(re); } regex_t *re;
void
wx_regfree(regex_t *re)
{ {
if (re == NULL) if (re == NULL)
return; return;

104
src/regex/regguts.h
View File

@@ -26,8 +26,6 @@
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Id$
*/ */
@@ -45,32 +43,52 @@
* Things that regcustom.h might override. * Things that regcustom.h might override.
*/ */
/* standard header files (NULL is a reasonable indicator for them) */
#ifndef NULL
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <limits.h>
#include <string.h>
#endif
/* assertions */ /* assertions */
#ifndef __WXWINCE__
#ifndef assert #ifndef assert
# ifndef REG_DEBUG # ifndef REG_DEBUG
# ifndef NDEBUG
# define NDEBUG /* no assertions */ # define NDEBUG /* no assertions */
# endif # endif
#endif
#include <assert.h> #include <assert.h>
#endif #endif
#else
// To do: assertion on WinCE
#define assert(x)
#endif
/* voids */ /* voids */
#ifndef VOID
#define VOID void /* for function return values */
#endif
#ifndef DISCARD #ifndef DISCARD
#define DISCARD void /* for throwing values away */ #define DISCARD VOID /* for throwing values away */
#endif
#ifndef PVOID
#define PVOID VOID * /* generic pointer */
#endif #endif
#ifndef VS #ifndef VS
#define VS(x) ((void *)(x)) /* cast something to generic ptr */ #define VS(x) ((PVOID)(x)) /* cast something to generic ptr */
#endif
#ifndef NOPARMS
#define NOPARMS VOID /* for empty parm lists */
#endif
/* const */
#ifndef CONST
#define CONST const /* for old compilers, might be empty */
#endif #endif
/* function-pointer declarator */ /* function-pointer declarator */
#ifndef FUNCPTR #ifndef FUNCPTR
#if __STDC__ >= 1
#define FUNCPTR(name, args) (*name)args #define FUNCPTR(name, args) (*name)args
#else
#define FUNCPTR(name, args) (*name)()
#endif
#endif #endif
/* memory allocation */ /* memory allocation */
@@ -141,8 +159,7 @@
#ifndef BYTBITS #ifndef BYTBITS
#define BYTBITS 8 /* bits in a byt */ #define BYTBITS 8 /* bits in a byt */
#endif #endif
#define BYTTAB (1<<BYTBITS) /* size of table with one entry per byt #define BYTTAB (1<<BYTBITS) /* size of table with one entry per byt value */
* value */
#define BYTMASK (BYTTAB-1) /* bit mask for byt */ #define BYTMASK (BYTTAB-1) /* bit mask for byt */
#define NBYTS ((CHRBITS+BYTBITS-1)/BYTBITS) #define NBYTS ((CHRBITS+BYTBITS-1)/BYTBITS)
/* the definition of GETCOLOR(), below, assumes NBYTS <= 4 */ /* the definition of GETCOLOR(), below, assumes NBYTS <= 4 */
@@ -155,7 +172,6 @@
*/ */
typedef short color; /* colors of characters */ typedef short color; /* colors of characters */
typedef int pcolor; /* what color promotes to */ typedef int pcolor; /* what color promotes to */
#define COLORLESS (-1) /* impossible color */ #define COLORLESS (-1) /* impossible color */
#define WHITE 0 /* default color, parent of all others */ #define WHITE 0 /* default color, parent of all others */
@@ -172,26 +188,21 @@ typedef int pcolor; /* what color promotes to */
*/ */
/* the tree itself */ /* the tree itself */
struct colors struct colors {
{
color ccolor[BYTTAB]; color ccolor[BYTTAB];
}; };
struct ptrs struct ptrs {
{
union tree *pptr[BYTTAB]; union tree *pptr[BYTTAB];
}; };
union tree union tree {
{
struct colors colors; struct colors colors;
struct ptrs ptrs; struct ptrs ptrs;
}; };
#define tcolor colors.ccolor #define tcolor colors.ccolor
#define tptr ptrs.pptr #define tptr ptrs.pptr
/* internal per-color structure for the color machinery */ /* internal per-color structure for the color machinery */
struct colordesc struct colordesc {
{
uchr nchrs; /* number of chars of this color */ uchr nchrs; /* number of chars of this color */
color sub; /* open subcolor (if any); free chain ptr */ color sub; /* open subcolor (if any); free chain ptr */
# define NOSUB COLORLESS # define NOSUB COLORLESS
@@ -204,8 +215,7 @@ struct colordesc
}; };
/* the color map itself */ /* the color map itself */
struct colormap struct colormap {
{
int magic; int magic;
# define CMMAGIC 0x876 # define CMMAGIC 0x876
struct vars *v; /* for compile error reporting */ struct vars *v; /* for compile error reporting */
@@ -241,8 +251,7 @@ struct colormap
* Interface definitions for locale-interface functions in locale.c. * Interface definitions for locale-interface functions in locale.c.
* Multi-character collating elements (MCCEs) cause most of the trouble. * Multi-character collating elements (MCCEs) cause most of the trouble.
*/ */
struct cvec struct cvec {
{
int nchrs; /* number of chrs */ int nchrs; /* number of chrs */
int chrspace; /* number of chrs possible */ int chrspace; /* number of chrs possible */
chr *chrs; /* pointer to vector of chrs */ chr *chrs; /* pointer to vector of chrs */
@@ -269,8 +278,7 @@ struct cvec
*/ */
struct state; struct state;
struct arc struct arc {
{
int type; int type;
# define ARCFREE '\0' # define ARCFREE '\0'
color co; color co;
@@ -282,15 +290,13 @@ struct arc
struct arc *colorchain; /* color's arc chain */ struct arc *colorchain; /* color's arc chain */
}; };
struct arcbatch struct arcbatch { /* for bulk allocation of arcs */
{ /* for bulk allocation of arcs */
struct arcbatch *next; struct arcbatch *next;
# define ABSIZE 10 # define ABSIZE 10
struct arc a[ABSIZE]; struct arc a[ABSIZE];
}; };
struct state struct state {
{
int no; int no;
# define FREESTATE (-1) # define FREESTATE (-1)
char flag; /* marks special states */ char flag; /* marks special states */
@@ -302,13 +308,11 @@ struct state
struct state *tmp; /* temporary for traversal algorithms */ struct state *tmp; /* temporary for traversal algorithms */
struct state *next; /* chain for traversing all */ struct state *next; /* chain for traversing all */
struct state *prev; /* back chain */ struct state *prev; /* back chain */
struct arcbatch oas; /* first arcbatch, avoid malloc in easy struct arcbatch oas; /* first arcbatch, avoid malloc in easy case */
* case */
int noas; /* number of arcs used in first arcbatch */ int noas; /* number of arcs used in first arcbatch */
}; };
struct nfa struct nfa {
{
struct state *pre; /* pre-initial state */ struct state *pre; /* pre-initial state */
struct state *init; /* initial state */ struct state *init; /* initial state */
struct state *final; /* final state */ struct state *final; /* final state */
@@ -329,14 +333,12 @@ struct nfa
/* /*
* definitions for compacted NFA * definitions for compacted NFA
*/ */
struct carc struct carc {
{
color co; /* COLORLESS is list terminator */ color co; /* COLORLESS is list terminator */
int to; /* state number */ int to; /* state number */
}; };
struct cnfa struct cnfa {
{
int nstates; /* number of states */ int nstates; /* number of states */
int ncolors; /* number of colors */ int ncolors; /* number of colors */
int flags; int flags;
@@ -348,7 +350,6 @@ struct cnfa
struct carc **states; /* vector of pointers to outarc lists */ struct carc **states; /* vector of pointers to outarc lists */
struct carc *arcs; /* the area for the lists */ struct carc *arcs; /* the area for the lists */
}; };
#define ZAPCNFA(cnfa) ((cnfa).nstates = 0) #define ZAPCNFA(cnfa) ((cnfa).nstates = 0)
#define NULLCNFA(cnfa) ((cnfa).nstates == 0) #define NULLCNFA(cnfa) ((cnfa).nstates == 0)
@@ -357,10 +358,8 @@ struct cnfa
/* /*
* subexpression tree * subexpression tree
*/ */
struct subre struct subre {
{ char op; /* '|', '.' (concat), 'b' (backref), '(', '=' */
char op; /* '|', '.' (concat), 'b' (backref), '(',
* '=' */
char flags; char flags;
# define LONGER 01 /* prefers longer match */ # define LONGER 01 /* prefers longer match */
# define SHORTER 02 /* prefers shorter match */ # define SHORTER 02 /* prefers shorter match */
@@ -380,8 +379,7 @@ struct subre
int subno; /* subexpression number (for 'b' and '(') */ int subno; /* subexpression number (for 'b' and '(') */
short min; /* min repetitions, for backref only */ short min; /* min repetitions, for backref only */
short max; /* max repetitions, for backref only */ short max; /* max repetitions, for backref only */
struct subre *left; /* left child, if any (also freelist struct subre *left; /* left child, if any (also freelist chain) */
* chain) */
struct subre *right; /* right child, if any */ struct subre *right; /* right child, if any */
struct state *begin; /* outarcs from here... */ struct state *begin; /* outarcs from here... */
struct state *end; /* ...ending in inarcs here */ struct state *end; /* ...ending in inarcs here */
@@ -395,9 +393,8 @@ struct subre
* table of function pointers for generic manipulation functions * table of function pointers for generic manipulation functions
* A regex_t's re_fns points to one of these. * A regex_t's re_fns points to one of these.
*/ */
struct fns struct fns {
{ VOID FUNCPTR(free, (regex_t *));
void FUNCPTR(free, (regex_t *));
}; };
@@ -405,8 +402,7 @@ struct fns
/* /*
* the insides of a regex_t, hidden behind a void * * the insides of a regex_t, hidden behind a void *
*/ */
struct guts struct guts {
{
int magic; int magic;
# define GUTSMAGIC 0xfed9 # define GUTSMAGIC 0xfed9
int cflags; /* copy of compile flags */ int cflags; /* copy of compile flags */
@@ -416,7 +412,7 @@ struct guts
struct cnfa search; /* for fast preliminary search */ struct cnfa search; /* for fast preliminary search */
int ntree; int ntree;
struct colormap cmap; struct colormap cmap;
int FUNCPTR(compare, (const chr *, const chr *, size_t)); int FUNCPTR(compare, (CONST chr *, CONST chr *, size_t));
struct subre *lacons; /* lookahead-constraint vector */ struct subre *lacons; /* lookahead-constraint vector */
int nlacons; /* size of lacons */ int nlacons; /* size of lacons */
}; };