Added support for static (inlined) wxImages with

[wxWidgets.git] / src / regex / regc_color.c

diff --git a/src/regex/regc_color.c b/src/regex/regc_color.c
index 5376af2ed5f17d43db13d6700eae77a346a841ac..5aed21c63084a5f2fce6ad659cd6b8c5f0c0de55 100644 (file)
--- a/src/regex/regc_color.c
+++ b/src/regex/regc_color.c
@@ -2,21 +2,21 @@
  * colorings of characters
  * This file is #included by regcomp.c.
  *
  * colorings of characters
  * 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.,
  * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
  * Corporation, none of whom are responsible for the results.  The author
  * Development of this software was funded, in part, by Cray Research Inc.,
  * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
  * 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
  * modification -- are permitted for any purpose, provided that
  * redistributions in source form retain this entire copyright notice and
  * indicate the origin and nature of any modifications.
  * Redistribution and use in source and binary forms -- with or without
  * modification -- are permitted for any purpose, provided that
  * redistributions in source form retain this entire copyright notice and
  * indicate the origin and nature of any modifications.

- *
+ * 

  * I'd appreciate being given credit for this package in the documentation
  * of software which uses it, but that is not a requirement.
  * I'd appreciate being given credit for this package in the documentation
  * of software which uses it, but that is not a requirement.

- *
+ * 

  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  * 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
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * 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
  *
  *
  * Note that there are some incestuous relationships between this code and


@@ -37,20 +36,22 @@
 
 
 
 
 
 

-#define CISERR()       VISERR(cm->v)
-#define CERR(e)                VERR(cm->v, (e))
+#define        CISERR()        VISERR(cm->v)
+#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
-initcm(struct vars * v,
-          struct colormap * cm)
+static VOID
+initcm(v, cm)
+struct vars *v;
+struct colormap *cm;

 {
 {

-       int                     i;
-       int                     j;
+       int i;
+       int j;

        union tree *t;
        union tree *nextt;
        struct colordesc *cd;
        union tree *t;
        union tree *nextt;
        struct colordesc *cd;


@@ -63,41 +64,41 @@ initcm(struct vars * v,
        cm->max = 0;
        cm->free = 0;
 
        cm->max = 0;
        cm->free = 0;
 

-       cd = cm->cd;                            /* cm->cd[WHITE] */
+       cd = cm->cd;                    /* cm->cd[WHITE] */

        cd->sub = NOSUB;
        cd->arcs = NULL;
        cd->flags = 0;
        cd->nchrs = CHR_MAX - CHR_MIN + 1;
 
        /* upper levels of tree */
        cd->sub = NOSUB;
        cd->arcs = NULL;
        cd->flags = 0;
        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;
                nextt = t + 1;

-               for (i = BYTTAB - 1; i >= 0; i--)
+               for (i = BYTTAB-1; i >= 0; i--)

                        t->tptr[i] = nextt;
        }
        /* bottom level is solid white */
                        t->tptr[i] = nextt;
        }
        /* bottom level is solid white */

-       t = &cm->tree[NBYTS - 1];
-       for (i = BYTTAB - 1; i >= 0; i--)
+       t = &cm->tree[NBYTS-1];
+       for (i = BYTTAB-1; i >= 0; i--)

                t->tcolor[i] = WHITE;
        cd->block = t;
 }
 
 /*
                t->tcolor[i] = WHITE;
        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
-freecm(struct colormap * cm)
+static VOID
+freecm(cm)
+struct colormap *cm;

 {
 {

-       size_t          i;
+       size_t i;

        union tree *cb;
 
        cm->magic = 0;
        if (NBYTS > 1)
                cmtreefree(cm, cm->tree, 0);
        for (i = 1; i <= cm->max; i++)          /* skip WHITE */
        union tree *cb;
 
        cm->magic = 0;
        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);
                        cb = cm->cd[i].block;
                        if (cb != NULL)
                                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
-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;
+       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 */
-       for (i = BYTTAB - 1; i >= 0; i--)
-       {
+       assert(level < NBYTS-1);        /* this level has pointers */
+       for (i = BYTTAB-1; i >= 0; i--) {

                t = tree->tptr[i];
                assert(t != NULL);
                t = tree->tptr[i];
                assert(t != NULL);

-               if (t != fillt)
-               {
-                       if (level < NBYTS - 2)
-                       {                                       /* more pointer blocks below */
-                               cmtreefree(cm, t, level + 1);
+               if (t != fillt) {
+                       if (level < NBYTS-2) {  /* 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;
                                if (t != cb)    /* not a solid block */
                                        FREE(t);
                                cb = cm->cd[t->tcolor[0]].block;
                                if (t != cb)    /* not a solid block */
                                        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 */
-setcolor(struct colormap * cm,
-                chr c,
-                pcolor co)
+static color                   /* previous color */
+setcolor(cm, c, co)
+struct colormap *cm;
+pchr c;
+pcolor co;

 {
 {

-       uchr            uc = c;
-       int                     shift;
-       int                     level;
-       int                     b;
-       int                     bottom;
+       uchr uc = c;
+       int shift;
+       int level;
+       int b;
+       int bottom;

        union tree *t;
        union tree *newt;
        union tree *fillt;
        union tree *lastt;
        union tree *cb;
        union tree *t;
        union tree *newt;
        union tree *fillt;
        union tree *lastt;
        union tree *cb;

-       color           prev;
+       color prev;

 
        assert(cm->magic == CMMAGIC);
        if (CISERR() || co == COLORLESS)
 
        assert(cm->magic == CMMAGIC);
        if (CISERR() || co == COLORLESS)


@@ -167,30 +167,27 @@ setcolor(struct colormap * cm,
 
        t = cm->tree;
        for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0;
 
        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];
                assert(t != NULL);
                b = (uc >> shift) & BYTMASK;
                lastt = t;
                t = lastt->tptr[b];
                assert(t != NULL);

-               fillt = &cm->tree[level + 1];
+               fillt = &cm->tree[level+1];

                bottom = (shift <= BYTBITS) ? 1 : 0;
                cb = (bottom) ? cm->cd[t->tcolor[0]].block : fillt;
                bottom = (shift <= BYTBITS) ? 1 : 0;
                cb = (bottom) ? cm->cd[t->tcolor[0]].block : fillt;

-               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 (t == fillt || t == cb) {    /* must allocate a new block */
+                       newt = (union tree *)MALLOC((bottom) ?
+                               sizeof(struct colors) : sizeof(struct ptrs));
+                       if (newt == NULL) {

                                CERR(REG_ESPACE);
                                return COLORLESS;
                        }
                        if (bottom)
                                memcpy(VS(newt->tcolor), VS(t->tcolor),
                                CERR(REG_ESPACE);
                                return COLORLESS;
                        }
                        if (bottom)
                                memcpy(VS(newt->tcolor), VS(t->tcolor),

-                                          BYTTAB * sizeof(color));
+                                                       BYTTAB*sizeof(color));

                        else
                                memcpy(VS(newt->tptr), VS(t->tptr),
                        else
                                memcpy(VS(newt->tptr), VS(t->tptr),

-                                          BYTTAB * sizeof(union tree *));
+                                               BYTTAB*sizeof(union tree *));

                        t = newt;
                        lastt->tptr[b] = t;
                }
                        t = newt;
                        lastt->tptr[b] = t;
                }


@@ -198,67 +195,63 @@ setcolor(struct colormap * cm,
 
        b = uc & BYTMASK;
        prev = t->tcolor[b];
 
        b = uc & BYTMASK;
        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())
                return COLORLESS;
 
 {
        if (CISERR())
                return COLORLESS;
 

-       return (color) cm->max;
+       return (color)cm->max;

 }
 
 /*
 }
 
 /*

- * newcolor - find a new color (must be subject of setcolor at once)
- * Beware:     may relocate the colordescs.
+ - 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)
+static color                   /* COLORLESS for error */
+newcolor(cm)
+struct colormap *cm;

 {
        struct colordesc *cd;
        struct colordesc *new;
 {
        struct colordesc *cd;
        struct colordesc *new;

-       size_t          n;
+       size_t n;

 
        if (CISERR())
                return COLORLESS;
 
 
        if (CISERR())
                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];
                assert(UNUSEDCOLOR(cd));
                assert(cd->arcs == NULL);
                cm->free = cd->sub;
                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];
                cm->max++;
                cd = &cm->cd[cm->max];

-       }
-       else
-       {
+       } else {

                /* oops, must allocate more */
                n = cm->ncds * 2;
                /* oops, must allocate more */
                n = cm->ncds * 2;

-               if (cm->cd == cm->cdspace)
-               {
-                       new = (struct colordesc *) MALLOC(n *
-                                                                                         sizeof(struct colordesc));
+               if (cm->cd == cm->cdspace) {
+                       new = (struct colordesc *)MALLOC(n *
+                                               sizeof(struct colordesc));

                        if (new != NULL)
                                memcpy(VS(new), VS(cm->cdspace), cm->ncds *
                        if (new != NULL)
                                memcpy(VS(new), VS(cm->cdspace), cm->ncds *

-                                          sizeof(struct colordesc));
-               }
-               else
-                       new = (struct colordesc *) REALLOC(cm->cd,
-                                                                                  n * sizeof(struct colordesc));
-               if (new == NULL)
-               {
+                                               sizeof(struct colordesc));
+               } else
+                       new = (struct colordesc *)REALLOC(cm->cd,
+                                               n * sizeof(struct colordesc));
+               if (new == NULL) {

                        CERR(REG_ESPACE);
                        return COLORLESS;
                }
                        CERR(REG_ESPACE);
                        return COLORLESS;
                }


@@ -275,19 +268,20 @@ newcolor(struct colormap * cm)
        cd->flags = 0;
        cd->block = NULL;
 
        cd->flags = 0;
        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
-freecolor(struct colormap * cm,
-                 pcolor co)
+static VOID
+freecolor(cm, co)
+struct colormap *cm;
+pcolor co;

 {
        struct colordesc *cd = &cm->cd[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)
 
        assert(co >= 0);
        if (co == WHITE)


@@ -297,53 +291,47 @@ freecolor(struct colormap * cm,
        assert(cd->sub == NOSUB);
        assert(cd->nchrs == 0);
        cd->flags = FREECOL;
        assert(cd->sub == NOSUB);
        assert(cd->nchrs == 0);
        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]))
                        cm->max--;
                assert(cm->free >= 0);
                while (cm->max > WHITE && UNUSEDCOLOR(&cm->cd[cm->max]))
                        cm->max--;
                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);
                        pco = cm->free;
                        nco = cm->cd[pco].sub;
                        while (nco > 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;
                                        /* 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;
                                }
                }
                                        assert(nco < cm->max);
                                        pco = nco;
                                        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);
        if (CISERR())
 
        co = newcolor(cm);
        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           sco;                    /* new subcolor */
+       color co;                       /* current color of c */
+       color sco;                      /* new subcolor */

 
        co = GETCOLOR(cm, c);
        sco = newsub(cm, co);
 
        co = GETCOLOR(cm, c);
        sco = newsub(cm, co);


@@ -368,8 +359,8 @@ subcolor(struct colormap * cm, chr c)
                return COLORLESS;
        assert(sco != COLORLESS);
 
                return COLORLESS;
        assert(sco != COLORLESS);
 

-       if (co == sco)                          /* already in an open subcolor */
-               return co;                              /* rest is redundant */
+       if (co == sco)          /* already in an open subcolor */
+               return co;      /* rest is redundant */

        cm->cd[co].nchrs--;
        cm->cd[sco].nchrs++;
        setcolor(cm, c, sco);
        cm->cd[co].nchrs--;
        cm->cd[sco].nchrs++;
        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,
-          pcolor co)
+newsub(cm, 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)
-       {                                                       /* color has no open subcolor */
-               if (cm->cd[co].nchrs == 1)              /* optimization */
+       if (sco == NOSUB) {             /* color has no open subcolor */
+               if (cm->cd[co].nchrs == 1)      /* optimization */

                        return co;
                        return co;

-               sco = newcolor(cm);             /* must create subcolor */
-               if (sco == COLORLESS)
-               {
+               sco = newcolor(cm);     /* must create subcolor */
+               if (sco == COLORLESS) {

                        assert(CISERR());
                        return COLORLESS;
                }
                        assert(CISERR());
                        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
-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;
+       uchr uf;
+       int i;

 
        assert(from <= to);
 
        /* first, align "from" on a tree-block boundary */
 
        assert(from <= to);
 
        /* first, align "from" on a tree-block boundary */

-       uf = (uchr) from;
-       i = (int) (((uf + BYTTAB - 1) & (uchr) ~BYTMASK) - uf);
+       uf = (uchr)from;
+       i = (int)( ((uf + BYTTAB-1) & (uchr)~BYTMASK) - uf );

        for (; from <= to && i > 0; i--, from++)
                newarc(v->nfa, PLAIN, subcolor(v->cm, from), lp, rp);
        for (; from <= to && i > 0; i--, from++)
                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;
 
        /* deal with whole blocks */
                return;
 
        /* 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
-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;
+       uchr uc = start;

        struct colormap *cm = v->cm;
        struct colormap *cm = v->cm;

-       int                     shift;
-       int                     level;
-       int                     i;
-       int                     b;
+       int shift;
+       int level;
+       int i;
+       int b;

        union tree *t;
        union tree *cb;
        union tree *fillt;
        union tree *lastt;
        union tree *t;
        union tree *cb;
        union tree *fillt;
        union tree *lastt;

-       int                     previ;
-       int                     ndone;
-       color           co;
-       color           sco;
+       int previ;
+       int ndone;
+       color co;
+       color sco;

 
        assert((uc % BYTTAB) == 0);
 
 
        assert((uc % BYTTAB) == 0);
 


@@ -466,23 +462,20 @@ subblock(struct vars * v,
        t = cm->tree;
        fillt = NULL;
        for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0;
        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);
                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 */
-                       t = (union tree *) MALLOC(sizeof(struct ptrs));
-                       if (t == NULL)
-                       {
+               fillt = &cm->tree[level+1];
+               if (t == fillt && shift > BYTBITS) {    /* need new ptr block */
+                       t = (union tree *)MALLOC(sizeof(struct ptrs));
+                       if (t == NULL) {

                                CERR(REG_ESPACE);
                                return;
                        }
                        memcpy(VS(t->tptr), VS(fillt->tptr),
                                CERR(REG_ESPACE);
                                return;
                        }
                        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 */
        co = t->tcolor[0];
        cb = cm->cd[co].block;
        /* 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;
                /* either way, we want a subcolor solid block */
                sco = newsub(cm, co);
                t = cm->cd[sco].block;

-               if (t == NULL)
-               {                                               /* must set it up */
-                       t = (union tree *) MALLOC(sizeof(struct colors));
-                       if (t == NULL)
-                       {
+               if (t == NULL) {        /* must set it up */
+                       t = (union tree *)MALLOC(sizeof(struct colors));
+                       if (t == NULL) {

                                CERR(REG_ESPACE);
                                return;
                        }
                                CERR(REG_ESPACE);
                                return;
                        }


@@ -517,14 +507,12 @@ subblock(struct vars * v,
 
        /* general case, a mixed block to be altered */
        i = 0;
 
        /* 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;
                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;
                        t->tcolor[i++] = sco;
                } while (i < BYTTAB && t->tcolor[i] == co);
                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
-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);
        struct colordesc *scd;
        struct arc *a;
 {
        struct colordesc *cd;
        struct colordesc *end = CDEND(cm);
        struct colordesc *scd;
        struct arc *a;

-       color           co;
-       color           sco;
+       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;
                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 */
                        cd->sub = NOSUB;
                        scd = &cm->cd[sco];
                        assert(scd->nchrs > 0);
                        assert(scd->sub == sco);
                        scd->sub = NOSUB;
                        /* 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;
                                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);
                                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;
                        /* 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);
                        }
                                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];
 
 {
        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
-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;
 
        aa = cd->arcs;
 {
        struct colordesc *cd = &cm->cd[a->co];
        struct arc *aa;
 
        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)
                        continue;
                assert(aa != NULL);
                aa->colorchain = a->colorchain;
        }
                for (; aa != NULL && aa->colorchain != a; aa = aa->colorchain)
                        continue;
                assert(aa != NULL);
                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 */
-singleton(struct colormap * cm,
-                 chr c)
+static int                     /* predicate */
+singleton(cm, c)
+struct colormap *cm;
+pchr c;

 {
 {

-       color           co;                             /* color of c */
+       color co;                       /* color of c */

 
        co = GETCOLOR(cm, c);
        if (cm->cd[co].nchrs == 1 && cm->cd[co].sub == NOSUB)
 
        co = GETCOLOR(cm, c);
        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
-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);
 {
        struct colordesc *cd;
        struct colordesc *end = CDEND(cm);

-       color           co;
+       color co;

 
        for (cd = cm->cd, co = 0; cd < end && !CISERR(); cd++, co++)
                if (!UNUSEDCOLOR(cd) && cd->sub != co && co != but &&
 
        for (cd = cm->cd, co = 0; cd < end && !CISERR(); cd++, co++)
                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
-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);
 {
        struct colordesc *cd;
        struct colordesc *end = CDEND(cm);

-       color           co;
+       color co;

 
        assert(of != from);
        for (cd = cm->cd, co = 0; cd < end && !CISERR(); cd++, co++)
 
        assert(of != from);
        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)
                                newarc(nfa, type, co, from, to);
 }
 
 
                        if (findarc(of, PLAIN, co) == NULL)
                                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
-dumpcolors(struct colormap * cm,
-                  FILE *f)
+static VOID
+dumpcolors(cm, f)
+struct colormap *cm;
+FILE *f;

 {
        struct colordesc *cd;
        struct colordesc *end;
 {
        struct colordesc *cd;
        struct colordesc *end;

-       color           co;
-       chr                     c;
-       char       *has;
+       color co;
+       chr c;
+       char *has;

 
 

-       fprintf(f, "max %ld\n", (long) cm->max);
+       fprintf(f, "max %ld\n", (long)cm->max);

        if (NBYTS > 1)
                fillcheck(cm, cm->tree, 0, f);
        end = CDEND(cm);
        if (NBYTS > 1)
                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))
-               {
+       for (cd = cm->cd + 1, co = 1; cd < end; cd++, co++)     /* skip 0 */
+               if (!UNUSEDCOLOR(cd)) {

                        assert(cd->nchrs > 0);
                        has = (cd->block != NULL) ? "#" : "";
                        assert(cd->nchrs > 0);
                        has = (cd->block != NULL) ? "#" : "";

-                       if (cd->flags & PSEUDO)
-                               fprintf(f, "#%2ld%s(ps): ", (long) co, has);
+                       if (cd->flags&PSEUDO)
+                               fprintf(f, "#%2ld%s(ps): ", (long)co, has);

                        else
                        else

-                               fprintf(f, "#%2ld%s(%2d): ", (long) co,
-                                               has, cd->nchrs);
+                               fprintf(f, "#%2ld%s(%2d): ", (long)co,
+                                                       has, cd->nchrs);

                        /* it's hard to do this more efficiently */
                        for (c = CHR_MIN; c < CHR_MAX; c++)
                                if (GETCOLOR(cm, c) == co)
                        /* it's hard to do this more efficiently */
                        for (c = CHR_MIN; c < CHR_MAX; c++)
                                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
-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;
+       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 */
-       for (i = BYTTAB - 1; i >= 0; i--)
-       {
+       assert(level < NBYTS-1);        /* this level has pointers */
+       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)
                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);
+                       {}
+               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.
  * 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, "\\\\");
        else if (c > ' ' && c <= '~')
 {
        if (c == '\\')
                fprintf(f, "\\\\");
        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 */