pgindent run.

1 files changed, 232 insertions, 180 deletions

diff --git a/src/backend/regex/regc_color.c b/src/backend/regex/regc_color.c
index eb250556822..da2b79b5f09 100644
--- a/src/backend/regex/regc_color.c
+++ b/src/backend/regex/regc_color.c
@@ -2,21 +2,21 @@
  * 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
- * 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.
- * 
+ *
  * 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
@@ -28,7 +28,7 @@
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * $Header: /cvsroot/pgsql/src/backend/regex/regc_color.c,v 1.1 2003/02/05 17:41:32 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/regex/regc_color.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
  *
  *
  * Note that there are some incestuous relationships between this code and
@@ -37,8 +37,8 @@
 
 
 
-#define	CISERR()	VISERR(cm->v)
-#define	CERR(e)		VERR(cm->v, (e))
+#define CISERR()	VISERR(cm->v)
+#define CERR(e)		VERR(cm->v, (e))
 
 
 
@@ -46,11 +46,11 @@
  * initcm - set up new colormap
  */
 static void
-initcm(struct vars *v,
-	   struct colormap *cm)
+initcm(struct vars * v,
+	   struct colormap * cm)
 {
-	int i;
-	int j;
+	int			i;
+	int			j;
 	union tree *t;
 	union tree *nextt;
 	struct colordesc *cd;
@@ -63,21 +63,22 @@ initcm(struct vars *v,
 	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 */
-	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--)
+		for (i = BYTTAB - 1; i >= 0; i--)
 			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;
 }
@@ -86,16 +87,17 @@ initcm(struct vars *v,
  * freecm - free dynamically-allocated things in a colormap
  */
 static void
-freecm(struct colormap *cm)
+freecm(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 */
-		if (!UNUSEDCOLOR(&cm->cd[i])) {
+		if (!UNUSEDCOLOR(&cm->cd[i]))
+		{
 			cb = cm->cd[i].block;
 			if (cb != NULL)
 				FREE(cb);
@@ -108,24 +110,29 @@ freecm(struct colormap *cm)
  * cmtreefree - free a non-terminal part of a colormap tree
  */
 static void
-cmtreefree(struct colormap *cm,
-		   union tree *tree,
+cmtreefree(struct colormap * cm,
+		   union tree * tree,
 		   int level)			/* level number (top == 0) of this block */
 {
-	int i;
+	int			i;
 	union tree *t;
-	union tree *fillt = &cm->tree[level+1];
+	union tree *fillt = &cm->tree[level + 1];
 	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);
-		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);
-			} else {		/* color block below */
+			}
+			else
+			{					/* color block below */
 				cb = cm->cd[t->tcolor[0]].block;
 				if (t != cb)	/* not a solid block */
 					FREE(t);
@@ -137,22 +144,22 @@ cmtreefree(struct colormap *cm,
 /*
  * setcolor - set the color of a character in a colormap
  */
-static color			/* previous color */
-setcolor(struct colormap *cm,
+static color				/* previous color */
+setcolor(struct colormap * cm,
 		 chr 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;
-	color prev;
+	color		prev;
 
 	assert(cm->magic == CMMAGIC);
 	if (CISERR() || co == COLORLESS)
@@ -160,27 +167,30 @@ 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];
 		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;
-		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),
-							BYTTAB*sizeof(color));
+					   BYTTAB * sizeof(color));
 			else
 				memcpy(VS(newt->tptr), VS(t->tptr),
-						BYTTAB*sizeof(union tree *));
+					   BYTTAB * sizeof(union tree *));
 			t = newt;
 			lastt->tptr[b] = t;
 		}
@@ -188,7 +198,7 @@ setcolor(struct colormap *cm,
 
 	b = uc & BYTMASK;
 	prev = t->tcolor[b];
-	t->tcolor[b] = (color)co;
+	t->tcolor[b] = (color) co;
 	return prev;
 }
 
@@ -196,51 +206,59 @@ setcolor(struct colormap *cm,
  * maxcolor - report largest color number in use
  */
 static color
-maxcolor(struct colormap *cm)
+maxcolor(struct colormap * cm)
 {
 	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.
+ * Beware:	may relocate the colordescs.
  */
-static color			/* COLORLESS for error */
-newcolor(struct colormap *cm)
+static color				/* COLORLESS for error */
+newcolor(struct colormap * cm)
 {
 	struct colordesc *cd;
 	struct colordesc *new;
-	size_t n;
+	size_t		n;
 
 	if (CISERR())
 		return COLORLESS;
 
-	if (cm->free != 0) {
+	if (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;
-	} 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) {
-			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 *
-						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;
 		}
@@ -257,18 +275,19 @@ newcolor(struct colormap *cm)
 	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)
  */
 static void
-freecolor(struct colormap *cm,
+freecolor(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)
@@ -278,35 +297,43 @@ 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 */
+		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)
+		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);
+		cm->free = (color) (cd - cm->cd);
 	}
 }
 
@@ -314,9 +341,9 @@ freecolor(struct colormap *cm,
  * pseudocolor - allocate a false color, to be managed by other means
  */
 static color
-pseudocolor(struct colormap *cm)
+pseudocolor(struct colormap * cm)
 {
-	color co;
+	color		co;
 
 	co = newcolor(cm);
 	if (CISERR())
@@ -330,10 +357,10 @@ pseudocolor(struct colormap *cm)
  * subcolor - allocate a new subcolor (if necessary) to this chr
  */
 static color
-subcolor(struct colormap *cm, chr c)
+subcolor(struct colormap * cm, chr 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);
@@ -341,8 +368,8 @@ subcolor(struct colormap *cm, chr c)
 		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);
@@ -353,17 +380,19 @@ subcolor(struct colormap *cm, chr c)
  * newsub - allocate a new subcolor (if necessary) for a color
  */
 static color
-newsub(struct colormap *cm,
+newsub(struct colormap * cm,
 	   pcolor co)
 {
-	color sco;			/* new subcolor */
+	color		sco;			/* new subcolor */
 
 	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;
-		sco = newcolor(cm);	/* must create subcolor */
-		if (sco == COLORLESS) {
+		sco = newcolor(cm);		/* must create subcolor */
+		if (sco == COLORLESS)
+		{
 			assert(CISERR());
 			return COLORLESS;
 		}
@@ -379,23 +408,23 @@ newsub(struct colormap *cm,
  * subrange - allocate new subcolors to this range of chrs, fill in arcs
  */
 static void
-subrange(struct vars *v,
+subrange(struct vars * v,
 		 chr from,
 		 chr to,
-		 struct state *lp,
-		 struct state *rp)
+		 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 */
-	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);
-	if (from > to)			/* didn't reach a boundary */
+	if (from > to)				/* didn't reach a boundary */
 		return;
 
 	/* deal with whole blocks */
@@ -411,25 +440,25 @@ subrange(struct vars *v,
  * subblock - allocate new subcolors for one tree block of chrs, fill in arcs
  */
 static void
-subblock(struct vars *v,
+subblock(struct vars * v,
 		 chr start,				/* first of BYTTAB chrs */
-		 struct state *lp,
-		 struct state *rp)
+		 struct state * lp,
+		 struct state * rp)
 {
-	uchr uc = start;
+	uchr		uc = start;
 	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;
-	int previ;
-	int ndone;
-	color co;
-	color sco;
+	int			previ;
+	int			ndone;
+	color		co;
+	color		sco;
 
 	assert((uc % BYTTAB) == 0);
 
@@ -437,20 +466,23 @@ 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 */
-			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),
-						BYTTAB*sizeof(union tree *));
+				   BYTTAB * sizeof(union tree *));
 			lastt->tptr[b] = t;
 		}
 	}
@@ -458,13 +490,16 @@ 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 */
-			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;
 			}
@@ -482,12 +517,14 @@ 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;
@@ -500,30 +537,37 @@ subblock(struct vars *v,
  * okcolors - promote subcolors to full colors
  */
 static void
-okcolors(struct nfa *nfa,
-		 struct colormap *cm)
+okcolors(struct nfa * nfa,
+		 struct colormap * cm)
 {
 	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;
-		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;
@@ -533,14 +577,17 @@ 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);
 			}
@@ -552,8 +599,8 @@ okcolors(struct nfa *nfa,
  * colorchain - add this arc to the color chain of its color
  */
 static void
-colorchain(struct colormap *cm,
-		   struct arc *a)
+colorchain(struct colormap * cm,
+		   struct arc * a)
 {
 	struct colordesc *cd = &cm->cd[a->co];
 
@@ -565,32 +612,33 @@ colorchain(struct colormap *cm,
  * uncolorchain - delete this arc from the color chain of its color
  */
 static void
-uncolorchain(struct colormap *cm,
-			 struct arc *a)
+uncolorchain(struct colormap * cm,
+			 struct arc * a)
 {
 	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;
-	else {
+	else
+	{
 		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?
  */
-static int			/* predicate */
-singleton(struct colormap *cm,
+static int						/* predicate */
+singleton(struct colormap * cm,
 		  chr 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)
@@ -602,20 +650,20 @@ singleton(struct colormap *cm,
  * rainbow - add arcs of all full colors (but one) between specified states
  */
 static void
-rainbow(struct nfa *nfa,
-		struct colormap *cm,
+rainbow(struct nfa * nfa,
+		struct colormap * cm,
 		int type,
 		pcolor but,				/* COLORLESS if no exceptions */
-		struct state *from,
-		struct state *to)
+		struct state * from,
+		struct state * to)
 {
 	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 &&
-							!(cd->flags&PSEUDO))
+			!(cd->flags & PSEUDO))
 			newarc(nfa, type, co, from, to);
 }
 
@@ -625,20 +673,21 @@ rainbow(struct nfa *nfa,
  * The calling sequence ought to be reconciled with cloneouts().
  */
 static void
-colorcomplement(struct nfa *nfa,
-				struct colormap *cm,
+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)
+				struct state * of,		/* complements of this guy's PLAIN
+										 * outarcs */
+				struct state * from,
+				struct state * to)
 {
 	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++)
-		if (!UNUSEDCOLOR(cd) && !(cd->flags&PSEUDO))
+		if (!UNUSEDCOLOR(cd) && !(cd->flags & PSEUDO))
 			if (findarc(of, PLAIN, co) == NULL)
 				newarc(nfa, type, co, from, to);
 }
@@ -650,28 +699,29 @@ colorcomplement(struct nfa *nfa,
  * dumpcolors - debugging output
  */
 static void
-dumpcolors(struct colormap *cm,
+dumpcolors(struct colormap * cm,
 		   FILE *f)
 {
 	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);
-	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) ? "#" : "";
-			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
-				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)
@@ -687,24 +737,26 @@ dumpcolors(struct colormap *cm,
  * fillcheck - check proper filling of a tree
  */
 static void
-fillcheck(struct colormap *cm,
-		  union tree *tree,
+fillcheck(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 *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)
-			{}
-		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);
 	}
 }
 
@@ -720,9 +772,9 @@ dumpchr(chr c,
 	if (c == '\\')
 		fprintf(f, "\\\\");
 	else if (c > ' ' && c <= '~')
-		putc((char)c, f);
+		putc((char) c, f);
 	else
-		fprintf(f, "\\u%04lx", (long)c);
+		fprintf(f, "\\u%04lx", (long) c);
 }
 
-#endif /* REG_DEBUG */
+#endif   /* REG_DEBUG */