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

Import regex from tcl 8.4.5

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/branches/RXSPENCER@4096 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Ryan Norton
1999-10-21 02:16:20 +00:00
parent bcdf529fe2
commit 9e0b898ade
1 changed files with 284 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files

570
src/regex/regc_color.c
View File

@@ -2,21 +2,21 @@
* colorings of characters * colorings of characters
* This file is #included by regcomp.c. * This file is #included by regcomp.c.
* *
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved. * Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
* *
* Development of this software was funded, in part, by Cray Research Inc., * Development of this software was funded, in part, by Cray Research Inc.,
* UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
* Corporation, none of whom are responsible for the results. The author * Corporation, none of whom are responsible for the results. The author
* thanks all of them. * thanks all of them.
* *
* Redistribution and use in source and binary forms -- with or without * Redistribution and use in source and binary forms -- with or without
* modification -- are permitted for any purpose, provided that * modification -- are permitted for any purpose, provided that
* redistributions in source form retain this entire copyright notice and * redistributions in source form retain this entire copyright notice and
* indicate the origin and nature of any modifications. * indicate the origin and nature of any modifications.
* *
* I'd appreciate being given credit for this package in the documentation * I'd appreciate being given credit for this package in the documentation
* of software which uses it, but that is not a requirement. * of software which uses it, but that is not a requirement.
* *
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@@ -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
@@ -37,20 +36,22 @@
#define CISERR() VISERR(cm->v) #define CISERR() VISERR(cm->v)
#define CERR(e) VERR(cm->v, (e)) #define CERR(e) VERR(cm->v, (e))
/* /*
* 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;
union tree *t; union tree *t;
union tree *nextt; union tree *nextt;
struct colordesc *cd; struct colordesc *cd;
@@ -63,41 +64,41 @@ initcm(struct vars * v,
cm->max = 0; cm->max = 0;
cm->free = 0; cm->free = 0;
cd = cm->cd; /* cm->cd[WHITE] */ cd = cm->cd; /* cm->cd[WHITE] */
cd->sub = NOSUB; cd->sub = NOSUB;
cd->arcs = NULL; cd->arcs = NULL;
cd->flags = 0; cd->flags = 0;
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;
} }
/* bottom level is solid white */ /* bottom level is solid white */
t = &cm->tree[NBYTS - 1]; t = &cm->tree[NBYTS-1];
for (i = BYTTAB - 1; i >= 0; i--) for (i = BYTTAB-1; i >= 0; i--)
t->tcolor[i] = WHITE; t->tcolor[i] = WHITE;
cd->block = t; cd->block = t;
} }
/* /*
* 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;
cm->magic = 0; cm->magic = 0;
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,32 +108,29 @@ 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;
union tree *fillt = &cm->tree[level + 1]; union tree *fillt = &cm->tree[level+1];
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) cmtreefree(cm, t, level+1);
{ /* more pointer blocks below */
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,24 +140,26 @@ 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;
int level; int level;
int b; int b;
int bottom; int bottom;
union tree *t; union tree *t;
union tree *newt; union tree *newt;
union tree *fillt; union tree *fillt;
union tree *lastt; union tree *lastt;
union tree *cb; union tree *cb;
color prev; color prev;
assert(cm->magic == CMMAGIC); assert(cm->magic == CMMAGIC);
if (CISERR() || co == COLORLESS) if (CISERR() || co == COLORLESS)
@@ -167,30 +167,27 @@ 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];
assert(t != NULL); assert(t != NULL);
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;
} }
if (bottom) if (bottom)
memcpy(VS(newt->tcolor), VS(t->tcolor), memcpy(VS(newt->tcolor), VS(t->tcolor),
BYTTAB * sizeof(color)); BYTTAB*sizeof(color));
else else
memcpy(VS(newt->tptr), VS(t->tptr), memcpy(VS(newt->tptr), VS(t->tptr),
BYTTAB * sizeof(union tree *)); BYTTAB*sizeof(union tree *));
t = newt; t = newt;
lastt->tptr[b] = t; lastt->tptr[b] = t;
} }
@@ -198,67 +195,63 @@ setcolor(struct colormap * cm,
b = uc & BYTMASK; b = uc & BYTMASK;
prev = t->tcolor[b]; prev = t->tcolor[b];
t->tcolor[b] = (color) co; t->tcolor[b] = (color)co;
return prev; return prev;
} }
/* /*
* 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;
return (color) cm->max; return (color)cm->max;
} }
/* /*
* 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;
size_t n; size_t n;
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;
} }
@@ -275,19 +268,20 @@ newcolor(struct colormap * cm)
cd->flags = 0; cd->flags = 0;
cd->block = NULL; cd->block = NULL;
return (color) (cd - cm->cd); return (color)(cd - cm->cd);
} }
/* /*
* 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,53 +291,47 @@ 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;
co = newcolor(cm); co = newcolor(cm);
if (CISERR()) if (CISERR())
@@ -354,13 +342,16 @@ 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 */
co = GETCOLOR(cm, c); co = GETCOLOR(cm, c);
sco = newsub(cm, co); sco = newsub(cm, co);
@@ -368,8 +359,8 @@ subcolor(struct colormap * cm, chr c)
return COLORLESS; return COLORLESS;
assert(sco != COLORLESS); assert(sco != COLORLESS);
if (co == sco) /* already in an open subcolor */ if (co == sco) /* already in an open subcolor */
return co; /* rest is redundant */ return co; /* rest is redundant */
cm->cd[co].nchrs--; cm->cd[co].nchrs--;
cm->cd[sco].nchrs++; cm->cd[sco].nchrs++;
setcolor(cm, c, sco); setcolor(cm, c, sco);
@@ -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,26 +396,29 @@ 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;
assert(from <= to); assert(from <= to);
/* first, align "from" on a tree-block boundary */ /* first, align "from" on a tree-block boundary */
uf = (uchr) from; uf = (uchr)from;
i = (int) (((uf + BYTTAB - 1) & (uchr) ~BYTMASK) - uf); i = (int)( ((uf + BYTTAB-1) & (uchr)~BYTMASK) - uf );
for (; from <= to && i > 0; i--, from++) for (; from <= to && i > 0; i--, from++)
newarc(v->nfa, PLAIN, subcolor(v->cm, from), lp, rp); newarc(v->nfa, PLAIN, subcolor(v->cm, from), lp, rp);
if (from > to) /* didn't reach a boundary */ if (from > to) /* didn't reach a boundary */
return; return;
/* deal with whole blocks */ /* deal with whole blocks */
@@ -437,28 +431,30 @@ 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;
int shift; int shift;
int level; int level;
int i; int i;
int b; int b;
union tree *t; union tree *t;
union tree *cb; union tree *cb;
union tree *fillt; union tree *fillt;
union tree *lastt; union tree *lastt;
int previ; int previ;
int ndone; int ndone;
color co; color co;
color sco; color sco;
assert((uc % BYTTAB) == 0); assert((uc % BYTTAB) == 0);
@@ -466,23 +462,20 @@ 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;
} }
memcpy(VS(t->tptr), VS(fillt->tptr), memcpy(VS(t->tptr), VS(fillt->tptr),
BYTTAB * sizeof(union tree *)); BYTTAB*sizeof(union tree *));
lastt->tptr[b] = t; lastt->tptr[b] = t;
} }
} }
@@ -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,40 +522,35 @@ 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);
struct colordesc *scd; struct colordesc *scd;
struct arc *a; struct arc *a;
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,36 +591,39 @@ 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;
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);
aa->colorchain = a->colorchain; aa->colorchain = a->colorchain;
} }
a->colorchain = NULL; /* paranoia */ a->colorchain = NULL; /* paranoia */
} }
/* /*
* 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 */
co = GETCOLOR(cm, c); co = GETCOLOR(cm, c);
if (cm->cd[co].nchrs == 1 && cm->cd[co].sub == NOSUB) if (cm->cd[co].nchrs == 1 && cm->cd[co].sub == NOSUB)
@@ -647,81 +632,90 @@ 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);
color co; color co;
for (cd = cm->cd, co = 0; cd < end && !CISERR(); cd++, co++) for (cd = cm->cd, co = 0; cd < end && !CISERR(); cd++, co++)
if (!UNUSEDCOLOR(cd) && cd->sub != co && co != but && if (!UNUSEDCOLOR(cd) && cd->sub != co && co != but &&
!(cd->flags & PSEUDO)) !(cd->flags&PSEUDO))
newarc(nfa, type, co, from, to); newarc(nfa, type, co, from, to);
} }
/* /*
* 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);
color co; color co;
assert(of != from); assert(of != from);
for (cd = cm->cd, co = 0; cd < end && !CISERR(); cd++, co++) for (cd = cm->cd, co = 0; cd < end && !CISERR(); cd++, co++)
if (!UNUSEDCOLOR(cd) && !(cd->flags & PSEUDO)) if (!UNUSEDCOLOR(cd) && !(cd->flags&PSEUDO))
if (findarc(of, PLAIN, co) == NULL) if (findarc(of, PLAIN, co) == NULL)
newarc(nfa, type, co, from, to); newarc(nfa, type, co, from, to);
} }
#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;
color co; color co;
chr c; chr c;
char *has; char *has;
fprintf(f, "max %ld\n", (long) cm->max); fprintf(f, "max %ld\n", (long)cm->max);
if (NBYTS > 1) if (NBYTS > 1)
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)
fprintf(f, "#%2ld%s(ps): ", (long) co, has); fprintf(f, "#%2ld%s(ps): ", (long)co, has);
else else
fprintf(f, "#%2ld%s(%2d): ", (long) co, fprintf(f, "#%2ld%s(%2d): ", (long)co,
has, cd->nchrs); has, cd->nchrs);
/* it's hard to do this more efficiently */ /* it's hard to do this more efficiently */
for (c = CHR_MIN; c < CHR_MAX; c++) for (c = CHR_MIN; c < CHR_MAX; c++)
if (GETCOLOR(cm, c) == co) if (GETCOLOR(cm, c) == co)
@@ -734,47 +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 (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 /* REG_DEBUG */ /*
^ #endif
*/
#endif /* ifdef REG_DEBUG */