Import regex from tcl 8.4.5
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
@@ -28,7 +28,6 @@
|
||||
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
* $Header$
|
||||
*
|
||||
*
|
||||
* 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
|
||||
initcm(struct vars * v,
|
||||
struct colormap * cm)
|
||||
static VOID
|
||||
initcm(v, cm)
|
||||
struct vars *v;
|
||||
struct colormap *cm;
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
@@ -70,8 +71,7 @@ initcm(struct vars * v,
|
||||
cd->nchrs = CHR_MAX - CHR_MIN + 1;
|
||||
|
||||
/* 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;
|
||||
for (i = BYTTAB-1; i >= 0; i--)
|
||||
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
|
||||
freecm(struct colormap * cm)
|
||||
static VOID
|
||||
freecm(cm)
|
||||
struct colormap *cm;
|
||||
{
|
||||
size_t i;
|
||||
union tree *cb;
|
||||
@@ -96,8 +98,7 @@ freecm(struct colormap * cm)
|
||||
if (NBYTS > 1)
|
||||
cmtreefree(cm, cm->tree, 0);
|
||||
for (i = 1; i <= cm->max; i++) /* skip WHITE */
|
||||
if (!UNUSEDCOLOR(&cm->cd[i]))
|
||||
{
|
||||
if (!UNUSEDCOLOR(&cm->cd[i])) {
|
||||
cb = cm->cd[i].block;
|
||||
if (cb != NULL)
|
||||
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
|
||||
cmtreefree(struct colormap * cm,
|
||||
union tree * tree,
|
||||
int level) /* level number (top == 0) of this block */
|
||||
static VOID
|
||||
cmtreefree(cm, tree, level)
|
||||
struct colormap *cm;
|
||||
union tree *tree;
|
||||
int level; /* level number (top == 0) of this block */
|
||||
{
|
||||
int i;
|
||||
union tree *t;
|
||||
@@ -120,19 +123,14 @@ cmtreefree(struct colormap * cm,
|
||||
union tree *cb;
|
||||
|
||||
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];
|
||||
assert(t != NULL);
|
||||
if (t != fillt)
|
||||
{
|
||||
if (level < NBYTS - 2)
|
||||
{ /* more pointer blocks below */
|
||||
if (t != fillt) {
|
||||
if (level < NBYTS-2) { /* more pointer blocks below */
|
||||
cmtreefree(cm, t, level+1);
|
||||
FREE(t);
|
||||
}
|
||||
else
|
||||
{ /* color block below */
|
||||
} else { /* color block below */
|
||||
cb = cm->cd[t->tcolor[0]].block;
|
||||
if (t != cb) /* not a solid block */
|
||||
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 */
|
||||
setcolor(struct colormap * cm,
|
||||
chr c,
|
||||
pcolor co)
|
||||
setcolor(cm, c, co)
|
||||
struct colormap *cm;
|
||||
pchr c;
|
||||
pcolor co;
|
||||
{
|
||||
uchr uc = c;
|
||||
int shift;
|
||||
@@ -167,8 +167,7 @@ setcolor(struct colormap * cm,
|
||||
|
||||
t = cm->tree;
|
||||
for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0;
|
||||
level++, shift -= BYTBITS)
|
||||
{
|
||||
level++, shift -= BYTBITS) {
|
||||
b = (uc >> shift) & BYTMASK;
|
||||
lastt = t;
|
||||
t = lastt->tptr[b];
|
||||
@@ -176,12 +175,10 @@ setcolor(struct colormap * cm,
|
||||
fillt = &cm->tree[level+1];
|
||||
bottom = (shift <= BYTBITS) ? 1 : 0;
|
||||
cb = (bottom) ? cm->cd[t->tcolor[0]].block : fillt;
|
||||
if (t == fillt || t == cb)
|
||||
{ /* must allocate a new block */
|
||||
if (t == fillt || t == cb) { /* must allocate a new block */
|
||||
newt = (union tree *)MALLOC((bottom) ?
|
||||
sizeof(struct colors) : sizeof(struct ptrs));
|
||||
if (newt == NULL)
|
||||
{
|
||||
if (newt == NULL) {
|
||||
CERR(REG_ESPACE);
|
||||
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
|
||||
maxcolor(struct colormap * cm)
|
||||
maxcolor(cm)
|
||||
struct colormap *cm;
|
||||
{
|
||||
if (CISERR())
|
||||
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.
|
||||
^ static color newcolor(struct colormap *);
|
||||
*/
|
||||
static color /* COLORLESS for error */
|
||||
newcolor(struct colormap * cm)
|
||||
newcolor(cm)
|
||||
struct colormap *cm;
|
||||
{
|
||||
struct colordesc *cd;
|
||||
struct colordesc *new;
|
||||
@@ -228,37 +229,29 @@ newcolor(struct colormap * cm)
|
||||
if (CISERR())
|
||||
return COLORLESS;
|
||||
|
||||
if (cm->free != 0)
|
||||
{
|
||||
if (cm->free != 0) {
|
||||
assert(cm->free > 0);
|
||||
assert((size_t)cm->free < cm->ncds);
|
||||
cd = &cm->cd[cm->free];
|
||||
assert(UNUSEDCOLOR(cd));
|
||||
assert(cd->arcs == NULL);
|
||||
cm->free = cd->sub;
|
||||
}
|
||||
else if (cm->max < cm->ncds - 1)
|
||||
{
|
||||
} else if (cm->max < cm->ncds - 1) {
|
||||
cm->max++;
|
||||
cd = &cm->cd[cm->max];
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
/* oops, must allocate more */
|
||||
n = cm->ncds * 2;
|
||||
if (cm->cd == cm->cdspace)
|
||||
{
|
||||
if (cm->cd == cm->cdspace) {
|
||||
new = (struct colordesc *)MALLOC(n *
|
||||
sizeof(struct colordesc));
|
||||
if (new != NULL)
|
||||
memcpy(VS(new), VS(cm->cdspace), cm->ncds *
|
||||
sizeof(struct colordesc));
|
||||
}
|
||||
else
|
||||
} else
|
||||
new = (struct colordesc *)REALLOC(cm->cd,
|
||||
n * sizeof(struct colordesc));
|
||||
if (new == NULL)
|
||||
{
|
||||
if (new == NULL) {
|
||||
CERR(REG_ESPACE);
|
||||
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
|
||||
freecolor(struct colormap * cm,
|
||||
pcolor co)
|
||||
static VOID
|
||||
freecolor(cm, co)
|
||||
struct colormap *cm;
|
||||
pcolor co;
|
||||
{
|
||||
struct colordesc *cd = &cm->cd[co];
|
||||
color pco,
|
||||
nco; /* for freelist scan */
|
||||
color pco, nco; /* for freelist scan */
|
||||
|
||||
assert(co >= 0);
|
||||
if (co == WHITE)
|
||||
@@ -297,51 +291,45 @@ freecolor(struct colormap * cm,
|
||||
assert(cd->sub == NOSUB);
|
||||
assert(cd->nchrs == 0);
|
||||
cd->flags = FREECOL;
|
||||
if (cd->block != NULL)
|
||||
{
|
||||
if (cd->block != NULL) {
|
||||
FREE(cd->block);
|
||||
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]))
|
||||
cm->max--;
|
||||
assert(cm->free >= 0);
|
||||
while ((size_t)cm->free > cm->max)
|
||||
cm->free = cm->cd[cm->free].sub;
|
||||
if (cm->free > 0)
|
||||
{
|
||||
if (cm->free > 0) {
|
||||
assert(cm->free < cm->max);
|
||||
pco = cm->free;
|
||||
nco = cm->cd[pco].sub;
|
||||
while (nco > 0)
|
||||
if ((size_t) nco > cm->max)
|
||||
{
|
||||
if ((size_t)nco > cm->max) {
|
||||
/* take this one out of freelist */
|
||||
nco = cm->cd[nco].sub;
|
||||
cm->cd[pco].sub = nco;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
assert(nco < cm->max);
|
||||
pco = nco;
|
||||
nco = cm->cd[pco].sub;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
cd->sub = cm->free;
|
||||
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
|
||||
pseudocolor(struct colormap * cm)
|
||||
pseudocolor(cm)
|
||||
struct colormap *cm;
|
||||
{
|
||||
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
|
||||
subcolor(struct colormap * cm, chr c)
|
||||
subcolor(cm, c)
|
||||
struct colormap *cm;
|
||||
pchr c;
|
||||
{
|
||||
color co; /* current color of c */
|
||||
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
|
||||
newsub(struct colormap * cm,
|
||||
pcolor co)
|
||||
newsub(cm, co)
|
||||
struct colormap *cm;
|
||||
pcolor co;
|
||||
{
|
||||
color sco; /* new subcolor */
|
||||
|
||||
sco = cm->cd[co].sub;
|
||||
if (sco == NOSUB)
|
||||
{ /* color has no open subcolor */
|
||||
if (sco == NOSUB) { /* color has no open subcolor */
|
||||
if (cm->cd[co].nchrs == 1) /* optimization */
|
||||
return co;
|
||||
sco = newcolor(cm); /* must create subcolor */
|
||||
if (sco == COLORLESS)
|
||||
{
|
||||
if (sco == COLORLESS) {
|
||||
assert(CISERR());
|
||||
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
|
||||
subrange(struct vars * v,
|
||||
chr from,
|
||||
chr to,
|
||||
struct state * lp,
|
||||
struct state * rp)
|
||||
static VOID
|
||||
subrange(v, from, to, lp, rp)
|
||||
struct vars *v;
|
||||
pchr from;
|
||||
pchr to;
|
||||
struct state *lp;
|
||||
struct state *rp;
|
||||
{
|
||||
uchr uf;
|
||||
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
|
||||
subblock(struct vars * v,
|
||||
chr start, /* first of BYTTAB chrs */
|
||||
struct state * lp,
|
||||
struct state * rp)
|
||||
static VOID
|
||||
subblock(v, start, lp, rp)
|
||||
struct vars *v;
|
||||
pchr start; /* first of BYTTAB chrs */
|
||||
struct state *lp;
|
||||
struct state *rp;
|
||||
{
|
||||
uchr uc = start;
|
||||
struct colormap *cm = v->cm;
|
||||
@@ -466,18 +462,15 @@ subblock(struct vars * v,
|
||||
t = cm->tree;
|
||||
fillt = NULL;
|
||||
for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0;
|
||||
level++, shift -= BYTBITS)
|
||||
{
|
||||
level++, shift -= BYTBITS) {
|
||||
b = (uc >> shift) & BYTMASK;
|
||||
lastt = t;
|
||||
t = lastt->tptr[b];
|
||||
assert(t != NULL);
|
||||
fillt = &cm->tree[level+1];
|
||||
if (t == fillt && shift > BYTBITS)
|
||||
{ /* need new ptr block */
|
||||
if (t == fillt && shift > BYTBITS) { /* need new ptr block */
|
||||
t = (union tree *)MALLOC(sizeof(struct ptrs));
|
||||
if (t == NULL)
|
||||
{
|
||||
if (t == NULL) {
|
||||
CERR(REG_ESPACE);
|
||||
return;
|
||||
}
|
||||
@@ -490,16 +483,13 @@ subblock(struct vars * v,
|
||||
/* special cases: fill block or solid block */
|
||||
co = t->tcolor[0];
|
||||
cb = cm->cd[co].block;
|
||||
if (t == fillt || t == cb)
|
||||
{
|
||||
if (t == fillt || t == cb) {
|
||||
/* either way, we want a subcolor solid block */
|
||||
sco = newsub(cm, co);
|
||||
t = cm->cd[sco].block;
|
||||
if (t == NULL)
|
||||
{ /* must set it up */
|
||||
if (t == NULL) { /* must set it up */
|
||||
t = (union tree *)MALLOC(sizeof(struct colors));
|
||||
if (t == NULL)
|
||||
{
|
||||
if (t == NULL) {
|
||||
CERR(REG_ESPACE);
|
||||
return;
|
||||
}
|
||||
@@ -517,14 +507,12 @@ subblock(struct vars * v,
|
||||
|
||||
/* general case, a mixed block to be altered */
|
||||
i = 0;
|
||||
while (i < BYTTAB)
|
||||
{
|
||||
while (i < BYTTAB) {
|
||||
co = t->tcolor[i];
|
||||
sco = newsub(cm, co);
|
||||
newarc(v->nfa, PLAIN, sco, lp, rp);
|
||||
previ = i;
|
||||
do
|
||||
{
|
||||
do {
|
||||
t->tcolor[i++] = sco;
|
||||
} while (i < BYTTAB && t->tcolor[i] == co);
|
||||
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
|
||||
okcolors(struct nfa * nfa,
|
||||
struct colormap * cm)
|
||||
static VOID
|
||||
okcolors(nfa, cm)
|
||||
struct nfa *nfa;
|
||||
struct colormap *cm;
|
||||
{
|
||||
struct colordesc *cd;
|
||||
struct colordesc *end = CDEND(cm);
|
||||
@@ -547,27 +537,20 @@ okcolors(struct nfa * nfa,
|
||||
color co;
|
||||
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;
|
||||
if (UNUSEDCOLOR(cd) || sco == NOSUB)
|
||||
{
|
||||
if (UNUSEDCOLOR(cd) || sco == NOSUB) {
|
||||
/* has no subcolor, no further action */
|
||||
}
|
||||
else if (sco == co)
|
||||
{
|
||||
} else if (sco == co) {
|
||||
/* 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 */
|
||||
cd->sub = NOSUB;
|
||||
scd = &cm->cd[sco];
|
||||
assert(scd->nchrs > 0);
|
||||
assert(scd->sub == sco);
|
||||
scd->sub = NOSUB;
|
||||
while ((a = cd->arcs) != NULL)
|
||||
{
|
||||
while ((a = cd->arcs) != NULL) {
|
||||
assert(a->co == co);
|
||||
/* uncolorchain(cm, a); */
|
||||
cd->arcs = a->colorchain;
|
||||
@@ -577,17 +560,14 @@ okcolors(struct nfa * nfa,
|
||||
scd->arcs = a;
|
||||
}
|
||||
freecolor(cm, co);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
/* parent's arcs must gain parallel subcolor arcs */
|
||||
cd->sub = NOSUB;
|
||||
scd = &cm->cd[sco];
|
||||
assert(scd->nchrs > 0);
|
||||
assert(scd->sub == sco);
|
||||
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);
|
||||
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
|
||||
colorchain(struct colormap * cm,
|
||||
struct arc * a)
|
||||
static VOID
|
||||
colorchain(cm, a)
|
||||
struct colormap *cm;
|
||||
struct arc *a;
|
||||
{
|
||||
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
|
||||
uncolorchain(struct colormap * cm,
|
||||
struct arc * a)
|
||||
static VOID
|
||||
uncolorchain(cm, a)
|
||||
struct colormap *cm;
|
||||
struct arc *a;
|
||||
{
|
||||
struct colordesc *cd = &cm->cd[a->co];
|
||||
struct arc *aa;
|
||||
@@ -621,8 +605,7 @@ uncolorchain(struct colormap * cm,
|
||||
aa = cd->arcs;
|
||||
if (aa == a) /* easy case */
|
||||
cd->arcs = a->colorchain;
|
||||
else
|
||||
{
|
||||
else {
|
||||
for (; aa != NULL && aa->colorchain != a; aa = aa->colorchain)
|
||||
continue;
|
||||
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 */
|
||||
singleton(struct colormap * cm,
|
||||
chr c)
|
||||
singleton(cm, c)
|
||||
struct colormap *cm;
|
||||
pchr 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
|
||||
rainbow(struct nfa * nfa,
|
||||
struct colormap * cm,
|
||||
int type,
|
||||
pcolor but, /* COLORLESS if no exceptions */
|
||||
struct state * from,
|
||||
struct state * to)
|
||||
static VOID
|
||||
rainbow(nfa, cm, type, but, from, to)
|
||||
struct nfa *nfa;
|
||||
struct colormap *cm;
|
||||
int type;
|
||||
pcolor but; /* COLORLESS if no exceptions */
|
||||
struct state *from;
|
||||
struct state *to;
|
||||
{
|
||||
struct colordesc *cd;
|
||||
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().
|
||||
^ static VOID colorcomplement(struct nfa *, struct colormap *, int,
|
||||
^ struct state *, struct state *, struct state *);
|
||||
*/
|
||||
static void
|
||||
colorcomplement(struct nfa * nfa,
|
||||
struct colormap * cm,
|
||||
int type,
|
||||
struct state * of, /* complements of this guy's PLAIN
|
||||
* outarcs */
|
||||
struct state * from,
|
||||
struct state * to)
|
||||
static VOID
|
||||
colorcomplement(nfa, cm, type, of, from, to)
|
||||
struct nfa *nfa;
|
||||
struct colormap *cm;
|
||||
int type;
|
||||
struct state *of; /* complements of this guy's PLAIN outarcs */
|
||||
struct state *from;
|
||||
struct state *to;
|
||||
{
|
||||
struct colordesc *cd;
|
||||
struct colordesc *end = CDEND(cm);
|
||||
@@ -693,14 +682,20 @@ colorcomplement(struct nfa * nfa,
|
||||
}
|
||||
|
||||
|
||||
|
||||
#ifdef REG_DEBUG
|
||||
/*
|
||||
^ #ifdef REG_DEBUG
|
||||
*/
|
||||
|
||||
/*
|
||||
* dumpcolors - debugging output
|
||||
- dumpcolors - debugging output
|
||||
^ static VOID dumpcolors(struct colormap *, FILE *);
|
||||
*/
|
||||
static void
|
||||
dumpcolors(struct colormap * cm,
|
||||
FILE *f)
|
||||
static VOID
|
||||
dumpcolors(cm, f)
|
||||
struct colormap *cm;
|
||||
FILE *f;
|
||||
{
|
||||
struct colordesc *cd;
|
||||
struct colordesc *end;
|
||||
@@ -713,8 +708,7 @@ dumpcolors(struct colormap * cm,
|
||||
fillcheck(cm, cm->tree, 0, f);
|
||||
end = CDEND(cm);
|
||||
for (cd = cm->cd + 1, co = 1; cd < end; cd++, co++) /* skip 0 */
|
||||
if (!UNUSEDCOLOR(cd))
|
||||
{
|
||||
if (!UNUSEDCOLOR(cd)) {
|
||||
assert(cd->nchrs > 0);
|
||||
has = (cd->block != NULL) ? "#" : "";
|
||||
if (cd->flags&PSEUDO)
|
||||
@@ -734,40 +728,41 @@ 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
|
||||
fillcheck(struct colormap * cm,
|
||||
union tree * tree,
|
||||
int level, /* level number (top == 0) of this block */
|
||||
FILE *f)
|
||||
static VOID
|
||||
fillcheck(cm, tree, level, f)
|
||||
struct colormap *cm;
|
||||
union tree *tree;
|
||||
int level; /* level number (top == 0) of this block */
|
||||
FILE *f;
|
||||
{
|
||||
int i;
|
||||
union tree *t;
|
||||
union tree *fillt = &cm->tree[level+1];
|
||||
|
||||
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];
|
||||
if (t == NULL)
|
||||
fprintf(f, "NULL found in filled tree!\n");
|
||||
else if (t == fillt)
|
||||
{
|
||||
}
|
||||
{}
|
||||
else if (level < NBYTS-2) /* more pointer blocks below */
|
||||
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.
|
||||
^ static VOID dumpchr(pchr, FILE *);
|
||||
*/
|
||||
static void
|
||||
dumpchr(chr c,
|
||||
FILE *f)
|
||||
static VOID
|
||||
dumpchr(c, f)
|
||||
pchr c;
|
||||
FILE *f;
|
||||
{
|
||||
if (c == '\\')
|
||||
fprintf(f, "\\\\");
|
||||
@@ -777,4 +772,7 @@ dumpchr(chr c,
|
||||
fprintf(f, "\\u%04lx", (long)c);
|
||||
}
|
||||
|
||||
#endif /* REG_DEBUG */
|
||||
/*
|
||||
^ #endif
|
||||
*/
|
||||
#endif /* ifdef REG_DEBUG */
|
||||
|
||||
Reference in New Issue
Block a user