Massive commit to run PGINDENT on all *.c and *.h files.

5 files changed, 1268 insertions, 1069 deletions

diff --git a/src/backend/regex/engine.c b/src/backend/regex/engine.c
index 3c323586d6b..6e0e7012140 100644
--- a/src/backend/regex/engine.c
+++ b/src/backend/regex/engine.c
@@ -1,7 +1,7 @@
 /*-
  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  * Copyright (c) 1992, 1993, 1994
- *	The Regents of the University of California.  All rights reserved.
+ *		The Regents of the University of California.  All rights reserved.
  *
  * This code is derived from software contributed to Berkeley by
  * Henry Spencer.
@@ -10,22 +10,22 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
+ *	  must display the following acknowledgement:
+ *		This product includes software developed by the University of
+ *		California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
+ *	  may be used to endorse or promote products derived from this software
+ *	  without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -34,7 +34,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	@(#)engine.c	8.5 (Berkeley) 3/20/94
+ *		@(#)engine.c	8.5 (Berkeley) 3/20/94
  */
 
 /*
@@ -45,150 +45,157 @@
  */
 
 #ifdef SNAMES
-#define	matcher	smatcher
-#define	fast	sfast
-#define	slow	sslow
-#define	dissect	sdissect
-#define	backref	sbackref
-#define	step	sstep
-#define	print	sprint
-#define	at	sat
-#define	match	smat
+#define matcher smatcher
+#define fast	sfast
+#define slow	sslow
+#define dissect sdissect
+#define backref sbackref
+#define step	sstep
+#define print	sprint
+#define at		sat
+#define match	smat
 #endif
 #ifdef LNAMES
-#define	matcher	lmatcher
-#define	fast	lfast
-#define	slow	lslow
-#define	dissect	ldissect
-#define	backref	lbackref
-#define	step	lstep
-#define	print	lprint
-#define	at	lat
-#define	match	lmat
+#define matcher lmatcher
+#define fast	lfast
+#define slow	lslow
+#define dissect ldissect
+#define backref lbackref
+#define step	lstep
+#define print	lprint
+#define at		lat
+#define match	lmat
 #endif
 
 /* another structure passed up and down to avoid zillions of parameters */
-struct match {
+struct match
+{
 	struct re_guts *g;
-	int eflags;
-	regmatch_t *pmatch;	/* [nsub+1] (0 element unused) */
-	char *offp;		/* offsets work from here */
-	char *beginp;		/* start of string -- virtual NUL precedes */
-	char *endp;		/* end of string -- virtual NUL here */
-	char *coldp;		/* can be no match starting before here */
-	char **lastpos;		/* [nplus+1] */
-	STATEVARS;
-	states st;		/* current states */
-	states fresh;		/* states for a fresh start */
-	states tmp;		/* temporary */
-	states empty;		/* empty set of states */
+	int				eflags;
+	regmatch_t	   *pmatch;		/* [nsub+1] (0 element unused) */
+	char		   *offp;		/* offsets work from here */
+	char		   *beginp;		/* start of string -- virtual NUL precedes */
+	char		   *endp;		/* end of string -- virtual NUL here */
+	char		   *coldp;		/* can be no match starting before here */
+	char		  **lastpos;	/* [nplus+1] */
+					STATEVARS;
+	states			st;			/* current states */
+	states			fresh;		/* states for a fresh start */
+	states			tmp;		/* temporary */
+	states			empty;		/* empty set of states */
 };
 
 /* ========= begin header generated by ./mkh ========= */
 #ifdef __cplusplus
-extern "C" {
+extern			"C"
+{
 #endif
 
 /* === engine.c === */
-static int 
-matcher(struct re_guts *g, char *string, size_t nmatch, 
-         regmatch_t pmatch[], int eflags);
-static char *
-dissect(struct match *m, char *start, char *stop, 
-        sopno startst, sopno stopst);
-static char *
-backref(struct match *m, char *start, char *stop, 
-        sopno startst, sopno stopst, sopno lev);
-static char *
-fast(struct match *m, char *start, char *stop, 
-     sopno startst, sopno stopst);
-static char *
-slow(struct match *m, char *start, char *stop, sopno startst, sopno stopst);
-static states 
-step(struct re_guts *g, sopno start, 
-     sopno stop, states bef, int ch, states aft);
-#define	BOL	(OUT+1)
-#define	EOL	(BOL+1)
-#define	BOLEOL	(BOL+2)
-#define	NOTHING	(BOL+3)
-#define	BOW	(BOL+4)
-#define	EOW	(BOL+5)
-#define	CODEMAX	(BOL+5)		/* highest code used */
-#define	NONCHAR(c)	((c) > CHAR_MAX)
-#define	NNONCHAR	(CODEMAX-CHAR_MAX)
+	static int
+					matcher(struct re_guts * g, char *string, size_t nmatch,
+										regmatch_t pmatch[], int eflags);
+	static char    *
+					dissect(struct match * m, char *start, char *stop,
+											sopno startst, sopno stopst);
+	static char    *
+					backref(struct match * m, char *start, char *stop,
+								 sopno startst, sopno stopst, sopno lev);
+	static char    *
+					fast(struct match * m, char *start, char *stop,
+										 sopno startst, sopno stopst);
+	static char    *
+					slow(struct match * m, char *start, char *stop, sopno startst, sopno stopst);
+	static			states
+					step(struct re_guts * g, sopno start,
+							 sopno stop, states bef, int ch, states aft);
+#define BOL		(OUT+1)
+#define EOL		(BOL+1)
+#define BOLEOL	(BOL+2)
+#define NOTHING (BOL+3)
+#define BOW		(BOL+4)
+#define EOW		(BOL+5)
+#define CODEMAX (BOL+5)			/* highest code used */
+#define NONCHAR(c)		((c) > CHAR_MAX)
+#define NNONCHAR		(CODEMAX-CHAR_MAX)
 #ifdef REDEBUG
-static void 
-print(struct match *m, char *caption, states st, int ch, FILE *d);
+	static void
+					print(struct match * m, char *caption, states st, int ch, FILE * d);
 #endif
 #ifdef REDEBUG
-static void 
-at(struct match *m, char *title, char *start, char *stop, 
-   sopno startst, sopno stopst);
+	static void
+					at(struct match * m, char *title, char *start, char *stop,
+									   sopno startst, sopno stopst);
 #endif
 #ifdef REDEBUG
-static char *
-pchar(int ch);
+	static char    *
+					pchar(int ch);
 #endif
 
 #ifdef __cplusplus
 }
+
 #endif
 /* ========= end header generated by ./mkh ========= */
 
 #ifdef REDEBUG
-#define	SP(t, s, c)	print(m, t, s, c, stdout)
-#define	AT(t, p1, p2, s1, s2)	at(m, t, p1, p2, s1, s2)
-#define	NOTE(str)	{ if (m->eflags&REG_TRACE) printf("=%s\n", (str)); }
+#define SP(t, s, c)		print(m, t, s, c, stdout)
+#define AT(t, p1, p2, s1, s2)	at(m, t, p1, p2, s1, s2)
+#define NOTE(str)		{ if (m->eflags&REG_TRACE) printf("=%s\n", (str)); }
 #else
-#define	SP(t, s, c)	/* nothing */
-#define	AT(t, p1, p2, s1, s2)	/* nothing */
-#define	NOTE(s)	/* nothing */
+#define SP(t, s, c)				/* nothing */
+#define AT(t, p1, p2, s1, s2)	/* nothing */
+#define NOTE(s)					/* nothing */
 #endif
 
 /*
  - matcher - the actual matching engine
  == static int matcher(register struct re_guts *g, char *string, \
- ==	size_t nmatch, regmatch_t pmatch[], int eflags);
+ ==		size_t nmatch, regmatch_t pmatch[], int eflags);
  */
-static int			/* 0 success, REG_NOMATCH failure */
+static int						/* 0 success, REG_NOMATCH failure */
 matcher(g, string, nmatch, pmatch, eflags)
 register struct re_guts *g;
-char *string;
-size_t nmatch;
-regmatch_t pmatch[];
-int eflags;
+char		   *string;
+size_t			nmatch;
+regmatch_t		pmatch[];
+int				eflags;
 {
-	register char *endp;
-	register int i;
-	struct match mv;
+	register char  *endp;
+	register int	i;
+	struct match	mv;
 	register struct match *m = &mv;
-	register char *dp;
-	register const sopno gf = g->firststate+1;	/* +1 for OEND */
+	register char  *dp;
+	register const sopno gf = g->firststate + 1;		/* +1 for OEND */
 	register const sopno gl = g->laststate;
-	char *start;
-	char *stop;
+	char		   *start;
+	char		   *stop;
 
 	/* simplify the situation where possible */
-	if (g->cflags&REG_NOSUB)
+	if (g->cflags & REG_NOSUB)
 		nmatch = 0;
-	if (eflags&REG_STARTEND) {
+	if (eflags & REG_STARTEND)
+	{
 		start = string + pmatch[0].rm_so;
 		stop = string + pmatch[0].rm_eo;
-	} else {
+	}
+	else
+	{
 		start = string;
 		stop = start + strlen(start);
 	}
 	if (stop < start)
-		return(REG_INVARG);
+		return (REG_INVARG);
 
 	/* prescreening; this does wonders for this rather slow code */
-	if (g->must != NULL) {
+	if (g->must != NULL)
+	{
 		for (dp = start; dp < stop; dp++)
 			if (*dp == g->must[0] && stop - dp >= g->mlen &&
-				memcmp(dp, g->must, (size_t)g->mlen) == 0)
+				memcmp(dp, g->must, (size_t) g->mlen) == 0)
 				break;
-		if (dp == stop)		/* we didn't find g->must */
-			return(REG_NOMATCH);
+		if (dp == stop)			/* we didn't find g->must */
+			return (REG_NOMATCH);
 	}
 
 	/* match struct setup */
@@ -207,18 +214,21 @@ int eflags;
 	CLEAR(m->empty);
 
 	/* this loop does only one repetition except for backrefs */
-	for (;;) {
+	for (;;)
+	{
 		endp = fast(m, start, stop, gf, gl);
-		if (endp == NULL) {		/* a miss */
+		if (endp == NULL)
+		{						/* a miss */
 			STATETEARDOWN(m);
-			return(REG_NOMATCH);
+			return (REG_NOMATCH);
 		}
 		if (nmatch == 0 && !g->backrefs)
-			break;		/* no further info needed */
+			break;				/* no further info needed */
 
 		/* where? */
 		assert(m->coldp != NULL);
-		for (;;) {
+		for (;;)
+		{
 			NOTE("finding start");
 			endp = slow(m, m->coldp, stop, gf, gl);
 			if (endp != NULL)
@@ -227,32 +237,37 @@ int eflags;
 			m->coldp++;
 		}
 		if (nmatch == 1 && !g->backrefs)
-			break;		/* no further info needed */
+			break;				/* no further info needed */
 
 		/* oh my, he wants the subexpressions... */
 		if (m->pmatch == NULL)
-			m->pmatch = (regmatch_t *)malloc((m->g->nsub + 1) *
-							sizeof(regmatch_t));
-		if (m->pmatch == NULL) {
+			m->pmatch = (regmatch_t *) malloc((m->g->nsub + 1) *
+											  sizeof(regmatch_t));
+		if (m->pmatch == NULL)
+		{
 			STATETEARDOWN(m);
-			return(REG_ESPACE);
+			return (REG_ESPACE);
 		}
 		for (i = 1; i <= m->g->nsub; i++)
 			m->pmatch[i].rm_so = m->pmatch[i].rm_eo = -1;
-		if (!g->backrefs && !(m->eflags&REG_BACKR)) {
+		if (!g->backrefs && !(m->eflags & REG_BACKR))
+		{
 			NOTE("dissecting");
 			dp = dissect(m, m->coldp, endp, gf, gl);
-		} else {
+		}
+		else
+		{
+			if (g->nplus > 0 && m->lastpos == NULL)
+				m->lastpos = (char **) malloc((g->nplus + 1) *
+											  sizeof(char *));
 			if (g->nplus > 0 && m->lastpos == NULL)
-				m->lastpos = (char **)malloc((g->nplus+1) *
-							sizeof(char *));
-			if (g->nplus > 0 && m->lastpos == NULL) {
+			{
 				free(m->pmatch);
 				STATETEARDOWN(m);
-				return(REG_ESPACE);
+				return (REG_ESPACE);
 			}
 			NOTE("backref dissect");
-			dp = backref(m, m->coldp, endp, gf, gl, (sopno)0);
+			dp = backref(m, m->coldp, endp, gf, gl, (sopno) 0);
 		}
 		if (dp != NULL)
 			break;
@@ -260,25 +275,27 @@ int eflags;
 		/* uh-oh... we couldn't find a subexpression-level match */
 		assert(g->backrefs);	/* must be back references doing it */
 		assert(g->nplus == 0 || m->lastpos != NULL);
-		for (;;) {
+		for (;;)
+		{
 			if (dp != NULL || endp <= m->coldp)
-				break;		/* defeat */
+				break;			/* defeat */
 			NOTE("backoff");
-			endp = slow(m, m->coldp, endp-1, gf, gl);
+			endp = slow(m, m->coldp, endp - 1, gf, gl);
 			if (endp == NULL)
-				break;		/* defeat */
+				break;			/* defeat */
 			/* try it on a shorter possibility */
 #ifndef NDEBUG
-			for (i = 1; i <= m->g->nsub; i++) {
+			for (i = 1; i <= m->g->nsub; i++)
+			{
 				assert(m->pmatch[i].rm_so == -1);
 				assert(m->pmatch[i].rm_eo == -1);
 			}
 #endif
 			NOTE("backoff dissect");
-			dp = backref(m, m->coldp, endp, gf, gl, (sopno)0);
+			dp = backref(m, m->coldp, endp, gf, gl, (sopno) 0);
 		}
 		assert(dp == NULL || dp == endp);
-		if (dp != NULL)		/* found a shorter one */
+		if (dp != NULL)			/* found a shorter one */
 			break;
 
 		/* despite initial appearances, there is no match here */
@@ -288,62 +305,67 @@ int eflags;
 	}
 
 	/* fill in the details if requested */
-	if (nmatch > 0) {
+	if (nmatch > 0)
+	{
 		pmatch[0].rm_so = m->coldp - m->offp;
 		pmatch[0].rm_eo = endp - m->offp;
 	}
-	if (nmatch > 1) {
+	if (nmatch > 1)
+	{
 		assert(m->pmatch != NULL);
 		for (i = 1; i < nmatch; i++)
 			if (i <= m->g->nsub)
 				pmatch[i] = m->pmatch[i];
-			else {
+			else
+			{
 				pmatch[i].rm_so = -1;
 				pmatch[i].rm_eo = -1;
 			}
 	}
 
 	if (m->pmatch != NULL)
-		free((char *)m->pmatch);
+		free((char *) m->pmatch);
 	if (m->lastpos != NULL)
-		free((char *)m->lastpos);
+		free((char *) m->lastpos);
 	STATETEARDOWN(m);
-	return(0);
+	return (0);
 }
 
 /*
  - dissect - figure out what matched what, no back references
  == static char *dissect(register struct match *m, char *start, \
- ==	char *stop, sopno startst, sopno stopst);
+ ==		char *stop, sopno startst, sopno stopst);
  */
-static char *			/* == stop (success) always */
+static char    *				/* == stop (success) always */
 dissect(m, start, stop, startst, stopst)
 register struct match *m;
-char *start;
-char *stop;
-sopno startst;
-sopno stopst;
+char		   *start;
+char		   *stop;
+sopno			startst;
+sopno			stopst;
 {
-	register int i;
-	register sopno ss;	/* start sop of current subRE */
-	register sopno es;	/* end sop of current subRE */
-	register char *sp;	/* start of string matched by it */
-	register char *stp;	/* string matched by it cannot pass here */
-	register char *rest;	/* start of rest of string */
-	register char *tail;	/* string unmatched by rest of RE */
-	register sopno ssub;	/* start sop of subsubRE */
-	register sopno esub;	/* end sop of subsubRE */
-	register char *ssp;	/* start of string matched by subsubRE */
-	register char *sep;	/* end of string matched by subsubRE */
-	register char *oldssp;	/* previous ssp */
-	register char *dp;
+	register int	i;
+	register sopno	ss;			/* start sop of current subRE */
+	register sopno	es;			/* end sop of current subRE */
+	register char  *sp;			/* start of string matched by it */
+	register char  *stp;		/* string matched by it cannot pass here */
+	register char  *rest;		/* start of rest of string */
+	register char  *tail;		/* string unmatched by rest of RE */
+	register sopno	ssub;		/* start sop of subsubRE */
+	register sopno	esub;		/* end sop of subsubRE */
+	register char  *ssp;		/* start of string matched by subsubRE */
+	register char  *sep;		/* end of string matched by subsubRE */
+	register char  *oldssp;		/* previous ssp */
+	register char  *dp;
 
 	AT("diss", start, stop, startst, stopst);
 	sp = start;
-	for (ss = startst; ss < stopst; ss = es) {
+	for (ss = startst; ss < stopst; ss = es)
+	{
 		/* identify end of subRE */
 		es = ss;
-		switch (OP(m->g->strip[es])) {
+		switch (OP(m->g->strip[es]))
+		{
 		case OPLUS_:
 		case OQUEST_:
 			es += OPND(m->g->strip[es]);
@@ -356,7 +378,8 @@ sopno stopst;
 		es++;
 
 		/* figure out what it matched */
-		switch (OP(m->g->strip[ss])) {
+		switch (OP(m->g->strip[ss]))
+		{
 		case OEND:
 			assert(nope);
 			break;
@@ -376,10 +399,11 @@ sopno stopst;
 		case O_BACK:
 			assert(nope);
 			break;
-		/* cases where length of match is hard to find */
+			/* cases where length of match is hard to find */
 		case OQUEST_:
 			stp = stop;
-			for (;;) {
+			for (;;)
+			{
 				/* how long could this one be? */
 				rest = slow(m, sp, stp, ss, es);
 				assert(rest != NULL);	/* it did match */
@@ -389,21 +413,25 @@ sopno stopst;
 					break;		/* yes! */
 				/* no -- try a shorter match for this one */
 				stp = rest - 1;
-				assert(stp >= sp);	/* it did work */
+				assert(stp >= sp);		/* it did work */
 			}
 			ssub = ss + 1;
 			esub = es - 1;
 			/* did innards match? */
-			if (slow(m, sp, rest, ssub, esub) != NULL) {
+			if (slow(m, sp, rest, ssub, esub) != NULL)
+			{
 				dp = dissect(m, sp, rest, ssub, esub);
 				assert(dp == rest);
-			} else		/* no */
+			}
+			else
+/* no */
 				assert(sp == rest);
 			sp = rest;
 			break;
 		case OPLUS_:
 			stp = stop;
-			for (;;) {
+			for (;;)
+			{
 				/* how long could this one be? */
 				rest = slow(m, sp, stp, ss, es);
 				assert(rest != NULL);	/* it did match */
@@ -413,25 +441,27 @@ sopno stopst;
 					break;		/* yes! */
 				/* no -- try a shorter match for this one */
 				stp = rest - 1;
-				assert(stp >= sp);	/* it did work */
+				assert(stp >= sp);		/* it did work */
 			}
 			ssub = ss + 1;
 			esub = es - 1;
 			ssp = sp;
 			oldssp = ssp;
-			for (;;) {	/* find last match of innards */
+			for (;;)
+			{					/* find last match of innards */
 				sep = slow(m, ssp, rest, ssub, esub);
 				if (sep == NULL || sep == ssp)
-					break;	/* failed or matched null */
+					break;		/* failed or matched null */
 				oldssp = ssp;	/* on to next try */
 				ssp = sep;
 			}
-			if (sep == NULL) {
+			if (sep == NULL)
+			{
 				/* last successful match */
 				sep = ssp;
 				ssp = oldssp;
 			}
-			assert(sep == rest);	/* must exhaust substring */
+			assert(sep == rest);/* must exhaust substring */
 			assert(slow(m, ssp, sep, ssub, esub) == rest);
 			dp = dissect(m, ssp, sep, ssub, esub);
 			assert(dp == sep);
@@ -439,7 +469,8 @@ sopno stopst;
 			break;
 		case OCH_:
 			stp = stop;
-			for (;;) {
+			for (;;)
+			{
 				/* how long could this one be? */
 				rest = slow(m, sp, stp, ss, es);
 				assert(rest != NULL);	/* it did match */
@@ -449,14 +480,15 @@ sopno stopst;
 					break;		/* yes! */
 				/* no -- try a shorter match for this one */
 				stp = rest - 1;
-				assert(stp >= sp);	/* it did work */
+				assert(stp >= sp);		/* it did work */
 			}
 			ssub = ss + 1;
 			esub = ss + OPND(m->g->strip[ss]) - 1;
 			assert(OP(m->g->strip[esub]) == OOR1);
-			for (;;) {	/* find first matching branch */
+			for (;;)
+			{					/* find first matching branch */
 				if (slow(m, sp, rest, ssub, esub) == rest)
-					break;	/* it matched all of it */
+					break;		/* it matched all of it */
 				/* that one missed, try next one */
 				assert(OP(m->g->strip[esub]) == OOR1);
 				esub++;
@@ -489,42 +521,42 @@ sopno stopst;
 			assert(0 < i && i <= m->g->nsub);
 			m->pmatch[i].rm_eo = sp - m->offp;
 			break;
-		default:		/* uh oh */
+		default:				/* uh oh */
 			assert(nope);
 			break;
 		}
 	}
 
 	assert(sp == stop);
-	return(sp);
+	return (sp);
 }
 
 /*
  - backref - figure out what matched what, figuring in back references
  == static char *backref(register struct match *m, char *start, \
- ==	char *stop, sopno startst, sopno stopst, sopno lev);
+ ==		char *stop, sopno startst, sopno stopst, sopno lev);
  */
-static char *			/* == stop (success) or NULL (failure) */
+static char    *				/* == stop (success) or NULL (failure) */
 backref(m, start, stop, startst, stopst, lev)
 register struct match *m;
-char *start;
-char *stop;
-sopno startst;
-sopno stopst;
-sopno lev;			/* PLUS nesting level */
+char		   *start;
+char		   *stop;
+sopno			startst;
+sopno			stopst;
+sopno			lev;			/* PLUS nesting level */
 {
-	register int i;
-	register sopno ss;	/* start sop of current subRE */
-	register char *sp;	/* start of string matched by it */
-	register sopno ssub;	/* start sop of subsubRE */
-	register sopno esub;	/* end sop of subsubRE */
-	register char *ssp;	/* start of string matched by subsubRE */
-	register char *dp;
+	register int	i;
+	register sopno	ss;			/* start sop of current subRE */
+	register char  *sp;			/* start of string matched by it */
+	register sopno	ssub;		/* start sop of subsubRE */
+	register sopno	esub;		/* end sop of subsubRE */
+	register char  *ssp;		/* start of string matched by subsubRE */
+	register char  *dp;
 	register size_t len;
-	register int hard;
-	register sop s;
+	register int	hard;
+	register sop	s;
 	register regoff_t offsave;
-	register cset *cs;
+	register cset  *cs;
 
 	AT("back", start, stop, startst, stopst);
 	sp = start;
@@ -532,135 +564,144 @@ sopno lev;			/* PLUS nesting level */
 	/* get as far as we can with easy stuff */
 	hard = 0;
 	for (ss = startst; !hard && ss < stopst; ss++)
-		switch (OP(s = m->g->strip[ss])) {
+		switch (OP(s = m->g->strip[ss]))
+		{
 		case OCHAR:
-			if (sp == stop || *sp++ != (char)OPND(s))
-				return(NULL);
+			if (sp == stop || *sp++ != (char) OPND(s))
+				return (NULL);
 			break;
 		case OANY:
 			if (sp == stop)
-				return(NULL);
+				return (NULL);
 			sp++;
 			break;
 		case OANYOF:
 			cs = &m->g->sets[OPND(s)];
 			if (sp == stop || !CHIN(cs, *sp++))
-				return(NULL);
+				return (NULL);
 			break;
 		case OBOL:
-			if ( (sp == m->beginp && !(m->eflags&REG_NOTBOL)) ||
-					(sp < m->endp && *(sp-1) == '\n' &&
-						(m->g->cflags&REG_NEWLINE)) )
-				{ /* yes */ }
+			if ((sp == m->beginp && !(m->eflags & REG_NOTBOL)) ||
+				(sp < m->endp && *(sp - 1) == '\n' &&
+				 (m->g->cflags & REG_NEWLINE)))
+			{					/* yes */
+			}
 			else
-				return(NULL);
+				return (NULL);
 			break;
 		case OEOL:
-			if ( (sp == m->endp && !(m->eflags&REG_NOTEOL)) ||
-					(sp < m->endp && *sp == '\n' &&
-						(m->g->cflags&REG_NEWLINE)) )
-				{ /* yes */ }
+			if ((sp == m->endp && !(m->eflags & REG_NOTEOL)) ||
+				(sp < m->endp && *sp == '\n' &&
+				 (m->g->cflags & REG_NEWLINE)))
+			{					/* yes */
+			}
 			else
-				return(NULL);
+				return (NULL);
 			break;
 		case OBOW:
-			if (( (sp == m->beginp && !(m->eflags&REG_NOTBOL)) ||
-					(sp < m->endp && *(sp-1) == '\n' &&
-						(m->g->cflags&REG_NEWLINE)) ||
-					(sp > m->beginp &&
-							!ISWORD(*(sp-1))) ) &&
-					(sp < m->endp && ISWORD(*sp)) )
-				{ /* yes */ }
+			if (((sp == m->beginp && !(m->eflags & REG_NOTBOL)) ||
+				 (sp < m->endp && *(sp - 1) == '\n' &&
+				  (m->g->cflags & REG_NEWLINE)) ||
+				 (sp > m->beginp &&
+				  !ISWORD(*(sp - 1)))) &&
+				(sp < m->endp && ISWORD(*sp)))
+			{					/* yes */
+			}
 			else
-				return(NULL);
+				return (NULL);
 			break;
 		case OEOW:
-			if (( (sp == m->endp && !(m->eflags&REG_NOTEOL)) ||
-					(sp < m->endp && *sp == '\n' &&
-						(m->g->cflags&REG_NEWLINE)) ||
-					(sp < m->endp && !ISWORD(*sp)) ) &&
-					(sp > m->beginp && ISWORD(*(sp-1))) )
-				{ /* yes */ }
+			if (((sp == m->endp && !(m->eflags & REG_NOTEOL)) ||
+				 (sp < m->endp && *sp == '\n' &&
+				  (m->g->cflags & REG_NEWLINE)) ||
+				 (sp < m->endp && !ISWORD(*sp))) &&
+				(sp > m->beginp && ISWORD(*(sp - 1))))
+			{					/* yes */
+			}
 			else
-				return(NULL);
+				return (NULL);
 			break;
 		case O_QUEST:
 			break;
-		case OOR1:	/* matches null but needs to skip */
+		case OOR1:				/* matches null but needs to skip */
 			ss++;
 			s = m->g->strip[ss];
-			do {
+			do
+			{
 				assert(OP(s) == OOR2);
 				ss += OPND(s);
 			} while (OP(s = m->g->strip[ss]) != O_CH);
 			/* note that the ss++ gets us past the O_CH */
 			break;
-		default:	/* have to make a choice */
+		default:				/* have to make a choice */
 			hard = 1;
 			break;
 		}
-	if (!hard) {		/* that was it! */
+	if (!hard)
+	{							/* that was it! */
 		if (sp != stop)
-			return(NULL);
-		return(sp);
+			return (NULL);
+		return (sp);
 	}
-	ss--;			/* adjust for the for's final increment */
+	ss--;						/* adjust for the for's final increment */
 
 	/* the hard stuff */
 	AT("hard", sp, stop, ss, stopst);
 	s = m->g->strip[ss];
-	switch (OP(s)) {
-	case OBACK_:		/* the vilest depths */
+	switch (OP(s))
+	{
+	case OBACK_:				/* the vilest depths */
 		i = OPND(s);
 		assert(0 < i && i <= m->g->nsub);
 		if (m->pmatch[i].rm_eo == -1)
-			return(NULL);
+			return (NULL);
 		assert(m->pmatch[i].rm_so != -1);
 		len = m->pmatch[i].rm_eo - m->pmatch[i].rm_so;
 		assert(stop - m->beginp >= len);
 		if (sp > stop - len)
-			return(NULL);	/* not enough left to match */
+			return (NULL);		/* not enough left to match */
 		ssp = m->offp + m->pmatch[i].rm_so;
 		if (memcmp(sp, ssp, len) != 0)
-			return(NULL);
+			return (NULL);
 		while (m->g->strip[ss] != SOP(O_BACK, i))
 			ss++;
-		return(backref(m, sp+len, stop, ss+1, stopst, lev));
+		return (backref(m, sp + len, stop, ss + 1, stopst, lev));
 		break;
-	case OQUEST_:		/* to null or not */
-		dp = backref(m, sp, stop, ss+1, stopst, lev);
+	case OQUEST_:				/* to null or not */
+		dp = backref(m, sp, stop, ss + 1, stopst, lev);
 		if (dp != NULL)
-			return(dp);	/* not */
-		return(backref(m, sp, stop, ss+OPND(s)+1, stopst, lev));
+			return (dp);		/* not */
+		return (backref(m, sp, stop, ss + OPND(s) + 1, stopst, lev));
 		break;
 	case OPLUS_:
 		assert(m->lastpos != NULL);
-		assert(lev+1 <= m->g->nplus);
-		m->lastpos[lev+1] = sp;
-		return(backref(m, sp, stop, ss+1, stopst, lev+1));
+		assert(lev + 1 <= m->g->nplus);
+		m->lastpos[lev + 1] = sp;
+		return (backref(m, sp, stop, ss + 1, stopst, lev + 1));
 		break;
 	case O_PLUS:
-		if (sp == m->lastpos[lev])	/* last pass matched null */
-			return(backref(m, sp, stop, ss+1, stopst, lev-1));
+		if (sp == m->lastpos[lev])		/* last pass matched null */
+			return (backref(m, sp, stop, ss + 1, stopst, lev - 1));
 		/* try another pass */
 		m->lastpos[lev] = sp;
-		dp = backref(m, sp, stop, ss-OPND(s)+1, stopst, lev);
+		dp = backref(m, sp, stop, ss - OPND(s) + 1, stopst, lev);
 		if (dp == NULL)
-			return(backref(m, sp, stop, ss+1, stopst, lev-1));
+			return (backref(m, sp, stop, ss + 1, stopst, lev - 1));
 		else
-			return(dp);
+			return (dp);
 		break;
-	case OCH_:		/* find the right one, if any */
+	case OCH_:					/* find the right one, if any */
 		ssub = ss + 1;
 		esub = ss + OPND(s) - 1;
 		assert(OP(m->g->strip[esub]) == OOR1);
-		for (;;) {	/* find first matching branch */
+		for (;;)
+		{						/* find first matching branch */
 			dp = backref(m, sp, stop, ssub, esub, lev);
 			if (dp != NULL)
-				return(dp);
+				return (dp);
 			/* that one missed, try next one */
 			if (OP(m->g->strip[esub]) == O_CH)
-				return(NULL);	/* there is none */
+				return (NULL);	/* there is none */
 			esub++;
 			assert(OP(m->g->strip[esub]) == OOR2);
 			ssub = esub + 1;
@@ -671,29 +712,29 @@ sopno lev;			/* PLUS nesting level */
 				assert(OP(m->g->strip[esub]) == O_CH);
 		}
 		break;
-	case OLPAREN:		/* must undo assignment if rest fails */
+	case OLPAREN:				/* must undo assignment if rest fails */
 		i = OPND(s);
 		assert(0 < i && i <= m->g->nsub);
 		offsave = m->pmatch[i].rm_so;
 		m->pmatch[i].rm_so = sp - m->offp;
-		dp = backref(m, sp, stop, ss+1, stopst, lev);
+		dp = backref(m, sp, stop, ss + 1, stopst, lev);
 		if (dp != NULL)
-			return(dp);
+			return (dp);
 		m->pmatch[i].rm_so = offsave;
-		return(NULL);
+		return (NULL);
 		break;
-	case ORPAREN:		/* must undo assignment if rest fails */
+	case ORPAREN:				/* must undo assignment if rest fails */
 		i = OPND(s);
 		assert(0 < i && i <= m->g->nsub);
 		offsave = m->pmatch[i].rm_eo;
 		m->pmatch[i].rm_eo = sp - m->offp;
-		dp = backref(m, sp, stop, ss+1, stopst, lev);
+		dp = backref(m, sp, stop, ss + 1, stopst, lev);
 		if (dp != NULL)
-			return(dp);
+			return (dp);
 		m->pmatch[i].rm_eo = offsave;
-		return(NULL);
+		return (NULL);
 		break;
-	default:		/* uh oh */
+	default:					/* uh oh */
 		assert(nope);
 		break;
 	}
@@ -707,25 +748,26 @@ sopno lev;			/* PLUS nesting level */
 /*
  - fast - step through the string at top speed
  == static char *fast(register struct match *m, char *start, \
- ==	char *stop, sopno startst, sopno stopst);
+ ==		char *stop, sopno startst, sopno stopst);
  */
-static char *			/* where tentative match ended, or NULL */
+static char    *				/* where tentative match ended, or NULL */
 fast(m, start, stop, startst, stopst)
 register struct match *m;
-char *start;
-char *stop;
-sopno startst;
-sopno stopst;
+char		   *start;
+char		   *stop;
+sopno			startst;
+sopno			stopst;
 {
 	register states st = m->st;
 	register states fresh = m->fresh;
 	register states tmp = m->tmp;
-	register char *p = start;
-	register int c = (start == m->beginp) ? OUT : *(start-1);
-	register int lastc;	/* previous c */
-	register int flagch;
-	register int i;
-	register char *coldp;	/* last p after which no match was underway */
+	register char  *p = start;
+	register int	c = (start == m->beginp) ? OUT : *(start - 1);
+	register int	lastc;		/* previous c */
+	register int	flagch;
+	register int	i;
+	register char  *coldp;		/* last p after which no match was
+								 * underway */
 
 	CLEAR(st);
 	SET1(st, startst);
@@ -733,7 +775,8 @@ sopno stopst;
 	ASSIGN(fresh, st);
 	SP("start", st, *p);
 	coldp = NULL;
-	for (;;) {
+	for (;;)
+	{
 		/* next character */
 		lastc = c;
 		c = (p == m->endp) ? OUT : *p;
@@ -743,39 +786,45 @@ sopno stopst;
 		/* is there an EOL and/or BOL between lastc and c? */
 		flagch = '\0';
 		i = 0;
-		if ( (lastc == '\n' && m->g->cflags&REG_NEWLINE) ||
-				(lastc == OUT && !(m->eflags&REG_NOTBOL)) ) {
+		if ((lastc == '\n' && m->g->cflags & REG_NEWLINE) ||
+			(lastc == OUT && !(m->eflags & REG_NOTBOL)))
+		{
 			flagch = BOL;
 			i = m->g->nbol;
 		}
-		if ( (c == '\n' && m->g->cflags&REG_NEWLINE) ||
-				(c == OUT && !(m->eflags&REG_NOTEOL)) ) {
+		if ((c == '\n' && m->g->cflags & REG_NEWLINE) ||
+			(c == OUT && !(m->eflags & REG_NOTEOL)))
+		{
 			flagch = (flagch == BOL) ? BOLEOL : EOL;
 			i += m->g->neol;
 		}
-		if (i != 0) {
+		if (i != 0)
+		{
 			for (; i > 0; i--)
 				st = step(m->g, startst, stopst, st, flagch, st);
 			SP("boleol", st, c);
 		}
 
 		/* how about a word boundary? */
-		if ( (flagch == BOL || (lastc != OUT && !ISWORD(lastc))) &&
-					(c != OUT && ISWORD(c)) ) {
+		if ((flagch == BOL || (lastc != OUT && !ISWORD(lastc))) &&
+			(c != OUT && ISWORD(c)))
+		{
 			flagch = BOW;
 		}
-		if ( (lastc != OUT && ISWORD(lastc)) &&
-				(flagch == EOL || (c != OUT && !ISWORD(c))) ) {
+		if ((lastc != OUT && ISWORD(lastc)) &&
+			(flagch == EOL || (c != OUT && !ISWORD(c))))
+		{
 			flagch = EOW;
 		}
-		if (flagch == BOW || flagch == EOW) {
+		if (flagch == BOW || flagch == EOW)
+		{
 			st = step(m->g, startst, stopst, st, flagch, st);
 			SP("boweow", st, c);
 		}
 
 		/* are we done? */
 		if (ISSET(st, stopst) || p == stop)
-			break;		/* NOTE BREAK OUT */
+			break;				/* NOTE BREAK OUT */
 
 		/* no, we must deal with this character */
 		ASSIGN(tmp, st);
@@ -790,33 +839,33 @@ sopno stopst;
 	assert(coldp != NULL);
 	m->coldp = coldp;
 	if (ISSET(st, stopst))
-		return(p+1);
+		return (p + 1);
 	else
-		return(NULL);
+		return (NULL);
 }
 
 /*
  - slow - step through the string more deliberately
  == static char *slow(register struct match *m, char *start, \
- ==	char *stop, sopno startst, sopno stopst);
+ ==		char *stop, sopno startst, sopno stopst);
  */
-static char *			/* where it ended */
+static char    *				/* where it ended */
 slow(m, start, stop, startst, stopst)
 register struct match *m;
-char *start;
-char *stop;
-sopno startst;
-sopno stopst;
+char		   *start;
+char		   *stop;
+sopno			startst;
+sopno			stopst;
 {
 	register states st = m->st;
 	register states empty = m->empty;
 	register states tmp = m->tmp;
-	register char *p = start;
-	register int c = (start == m->beginp) ? OUT : *(start-1);
-	register int lastc;	/* previous c */
-	register int flagch;
-	register int i;
-	register char *matchp;	/* last p at which a match ended */
+	register char  *p = start;
+	register int	c = (start == m->beginp) ? OUT : *(start - 1);
+	register int	lastc;		/* previous c */
+	register int	flagch;
+	register int	i;
+	register char  *matchp;		/* last p at which a match ended */
 
 	AT("slow", start, stop, startst, stopst);
 	CLEAR(st);
@@ -824,7 +873,8 @@ sopno stopst;
 	SP("sstart", st, *p);
 	st = step(m->g, startst, stopst, st, NOTHING, st);
 	matchp = NULL;
-	for (;;) {
+	for (;;)
+	{
 		/* next character */
 		lastc = c;
 		c = (p == m->endp) ? OUT : *p;
@@ -832,32 +882,38 @@ sopno stopst;
 		/* is there an EOL and/or BOL between lastc and c? */
 		flagch = '\0';
 		i = 0;
-		if ( (lastc == '\n' && m->g->cflags&REG_NEWLINE) ||
-				(lastc == OUT && !(m->eflags&REG_NOTBOL)) ) {
+		if ((lastc == '\n' && m->g->cflags & REG_NEWLINE) ||
+			(lastc == OUT && !(m->eflags & REG_NOTBOL)))
+		{
 			flagch = BOL;
 			i = m->g->nbol;
 		}
-		if ( (c == '\n' && m->g->cflags&REG_NEWLINE) ||
-				(c == OUT && !(m->eflags&REG_NOTEOL)) ) {
+		if ((c == '\n' && m->g->cflags & REG_NEWLINE) ||
+			(c == OUT && !(m->eflags & REG_NOTEOL)))
+		{
 			flagch = (flagch == BOL) ? BOLEOL : EOL;
 			i += m->g->neol;
 		}
-		if (i != 0) {
+		if (i != 0)
+		{
 			for (; i > 0; i--)
 				st = step(m->g, startst, stopst, st, flagch, st);
 			SP("sboleol", st, c);
 		}
 
 		/* how about a word boundary? */
-		if ( (flagch == BOL || (lastc != OUT && !ISWORD(lastc))) &&
-					(c != OUT && ISWORD(c)) ) {
+		if ((flagch == BOL || (lastc != OUT && !ISWORD(lastc))) &&
+			(c != OUT && ISWORD(c)))
+		{
 			flagch = BOW;
 		}
-		if ( (lastc != OUT && ISWORD(lastc)) &&
-				(flagch == EOL || (c != OUT && !ISWORD(c))) ) {
+		if ((lastc != OUT && ISWORD(lastc)) &&
+			(flagch == EOL || (c != OUT && !ISWORD(c))))
+		{
 			flagch = EOW;
 		}
-		if (flagch == BOW || flagch == EOW) {
+		if (flagch == BOW || flagch == EOW)
+		{
 			st = step(m->g, startst, stopst, st, flagch, st);
 			SP("sboweow", st, c);
 		}
@@ -866,7 +922,7 @@ sopno stopst;
 		if (ISSET(st, stopst))
 			matchp = p;
 		if (EQ(st, empty) || p == stop)
-			break;		/* NOTE BREAK OUT */
+			break;				/* NOTE BREAK OUT */
 
 		/* no, we must deal with this character */
 		ASSIGN(tmp, st);
@@ -878,50 +934,52 @@ sopno stopst;
 		p++;
 	}
 
-	return(matchp);
+	return (matchp);
 }
 
 
 /*
  - step - map set of states reachable before char to set reachable after
  == static states step(register struct re_guts *g, sopno start, sopno stop, \
- ==	register states bef, int ch, register states aft);
- == #define	BOL	(OUT+1)
- == #define	EOL	(BOL+1)
- == #define	BOLEOL	(BOL+2)
- == #define	NOTHING	(BOL+3)
- == #define	BOW	(BOL+4)
- == #define	EOW	(BOL+5)
- == #define	CODEMAX	(BOL+5)		// highest code used
- == #define	NONCHAR(c)	((c) > CHAR_MAX)
- == #define	NNONCHAR	(CODEMAX-CHAR_MAX)
+ ==		register states bef, int ch, register states aft);
+ == #define		BOL		(OUT+1)
+ == #define		EOL		(BOL+1)
+ == #define		BOLEOL	(BOL+2)
+ == #define		NOTHING (BOL+3)
+ == #define		BOW		(BOL+4)
+ == #define		EOW		(BOL+5)
+ == #define		CODEMAX (BOL+5)			// highest code used
+ == #define		NONCHAR(c)		((c) > CHAR_MAX)
+ == #define		NNONCHAR		(CODEMAX-CHAR_MAX)
  */
-static states
+static			states
 step(g, start, stop, bef, ch, aft)
 register struct re_guts *g;
-sopno start;			/* start state within strip */
-sopno stop;			/* state after stop state within strip */
-register states bef;		/* states reachable before */
-int ch;				/* character or NONCHAR code */
-register states aft;		/* states already known reachable after */
+sopno			start;			/* start state within strip */
+sopno			stop;			/* state after stop state within strip */
+register states bef;			/* states reachable before */
+int				ch;				/* character or NONCHAR code */
+register states aft;			/* states already known reachable after */
 {
-	register cset *cs;
-	register sop s;
-	register sopno pc;
+	register cset  *cs;
+	register sop	s;
+	register sopno	pc;
 	register onestate here;		/* note, macros know this name */
-	register sopno look;
-	register int i;
+	register sopno	look;
+	register int	i;
 
-	for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) {
+	for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here))
+	{
 		s = g->strip[pc];
-		switch (OP(s)) {
+		switch (OP(s))
+		{
 		case OEND:
-			assert(pc == stop-1);
+			assert(pc == stop - 1);
 			break;
 		case OCHAR:
 			/* only characters can match */
-			assert(!NONCHAR(ch) || ch != (char)OPND(s));
-			if (ch == (char)OPND(s))
+			assert(!NONCHAR(ch) || ch != (char) OPND(s));
+			if (ch == (char) OPND(s))
 				FWD(aft, bef, 1);
 			break;
 		case OBOL:
@@ -949,65 +1007,68 @@ register states aft;		/* states already known reachable after */
 			if (!NONCHAR(ch) && CHIN(cs, ch))
 				FWD(aft, bef, 1);
 			break;
-		case OBACK_:		/* ignored here */
+		case OBACK_:			/* ignored here */
 		case O_BACK:
 			FWD(aft, aft, 1);
 			break;
-		case OPLUS_:		/* forward, this is just an empty */
+		case OPLUS_:			/* forward, this is just an empty */
 			FWD(aft, aft, 1);
 			break;
-		case O_PLUS:		/* both forward and back */
+		case O_PLUS:			/* both forward and back */
 			FWD(aft, aft, 1);
 			i = ISSETBACK(aft, OPND(s));
 			BACK(aft, aft, OPND(s));
-			if (!i && ISSETBACK(aft, OPND(s))) {
+			if (!i && ISSETBACK(aft, OPND(s)))
+			{
 				/* oho, must reconsider loop body */
 				pc -= OPND(s) + 1;
 				INIT(here, pc);
 			}
 			break;
-		case OQUEST_:		/* two branches, both forward */
+		case OQUEST_:			/* two branches, both forward */
 			FWD(aft, aft, 1);
 			FWD(aft, aft, OPND(s));
 			break;
-		case O_QUEST:		/* just an empty */
+		case O_QUEST:			/* just an empty */
 			FWD(aft, aft, 1);
 			break;
-		case OLPAREN:		/* not significant here */
+		case OLPAREN:			/* not significant here */
 		case ORPAREN:
 			FWD(aft, aft, 1);
 			break;
-		case OCH_:		/* mark the first two branches */
+		case OCH_:				/* mark the first two branches */
 			FWD(aft, aft, 1);
-			assert(OP(g->strip[pc+OPND(s)]) == OOR2);
+			assert(OP(g->strip[pc + OPND(s)]) == OOR2);
 			FWD(aft, aft, OPND(s));
 			break;
-		case OOR1:		/* done a branch, find the O_CH */
-			if (ISSTATEIN(aft, here)) {
+		case OOR1:				/* done a branch, find the O_CH */
+			if (ISSTATEIN(aft, here))
+			{
 				for (look = 1;
-						OP(s = g->strip[pc+look]) != O_CH;
-						look += OPND(s))
+					 OP(s = g->strip[pc + look]) != O_CH;
+					 look += OPND(s))
 					assert(OP(s) == OOR2);
 				FWD(aft, aft, look);
 			}
 			break;
-		case OOR2:		/* propagate OCH_'s marking */
+		case OOR2:				/* propagate OCH_'s marking */
 			FWD(aft, aft, 1);
-			if (OP(g->strip[pc+OPND(s)]) != O_CH) {
-				assert(OP(g->strip[pc+OPND(s)]) == OOR2);
+			if (OP(g->strip[pc + OPND(s)]) != O_CH)
+			{
+				assert(OP(g->strip[pc + OPND(s)]) == OOR2);
 				FWD(aft, aft, OPND(s));
 			}
 			break;
-		case O_CH:		/* just empty */
+		case O_CH:				/* just empty */
 			FWD(aft, aft, 1);
 			break;
-		default:		/* ooooops... */
+		default:				/* ooooops... */
 			assert(nope);
 			break;
 		}
 	}
 
-	return(aft);
+	return (aft);
 }
 
 #ifdef REDEBUG
@@ -1015,84 +1076,86 @@ register states aft;		/* states already known reachable after */
  - print - print a set of states
  == #ifdef REDEBUG
  == static void print(struct match *m, char *caption, states st, \
- ==	int ch, FILE *d);
+ ==		int ch, FILE *d);
  == #endif
  */
 static void
 print(m, caption, st, ch, d)
-struct match *m;
-char *caption;
-states st;
-int ch;
-FILE *d;
+struct match   *m;
+char		   *caption;
+states			st;
+int				ch;
+FILE		   *d;
 {
 	register struct re_guts *g = m->g;
-	register int i;
-	register int first = 1;
+	register int	i;
+	register int	first = 1;
 
-	if (!(m->eflags&REG_TRACE))
+	if (!(m->eflags & REG_TRACE))
 		return;
 
 	fprintf(d, "%s", caption);
 	if (ch != '\0')
 		fprintf(d, " %s", pchar(ch));
 	for (i = 0; i < g->nstates; i++)
-		if (ISSET(st, i)) {
+		if (ISSET(st, i))
+		{
 			fprintf(d, "%s%d", (first) ? "\t" : ", ", i);
 			first = 0;
 		}
 	fprintf(d, "\n");
 }
 
-/* 
+/*
  - at - print current situation
  == #ifdef REDEBUG
  == static void at(struct match *m, char *title, char *start, char *stop, \
- ==						sopno startst, sopno stopst);
+ ==												sopno startst, sopno stopst);
  == #endif
  */
 static void
 at(m, title, start, stop, startst, stopst)
-struct match *m;
-char *title;
-char *start;
-char *stop;
-sopno startst;
-sopno stopst;
+struct match   *m;
+char		   *title;
+char		   *start;
+char		   *stop;
+sopno			startst;
+sopno			stopst;
 {
-	if (!(m->eflags&REG_TRACE))
+	if (!(m->eflags & REG_TRACE))
 		return;
 
 	printf("%s %s-", title, pchar(*start));
 	printf("%s ", pchar(*stop));
-	printf("%ld-%ld\n", (long)startst, (long)stopst);
+	printf("%ld-%ld\n", (long) startst, (long) stopst);
 }
 
 #ifndef PCHARDONE
-#define	PCHARDONE	/* never again */
+#define PCHARDONE				/* never again */
 /*
  - pchar - make a character printable
  == #ifdef REDEBUG
  == static char *pchar(int ch);
  == #endif
  *
- * Is this identical to regchar() over in debug.c?  Well, yes.  But a
+ * Is this identical to regchar() over in debug.c?	Well, yes.	But a
  * duplicate here avoids having a debugging-capable regexec.o tied to
- * a matching debug.o, and this is convenient.  It all disappears in
+ * a matching debug.o, and this is convenient.	It all disappears in
  * the non-debug compilation anyway, so it doesn't matter much.
  */
-static char *			/* -> representation */
+static char    *				/* -> representation */
 pchar(ch)
-int ch;
+int				ch;
 {
-	static char pbuf[10];
+	static char		pbuf[10];
 
 	if (isprint(ch) || ch == ' ')
 		sprintf(pbuf, "%c", ch);
 	else
 		sprintf(pbuf, "\\%o", ch);
-	return(pbuf);
+	return (pbuf);
 }
+
 #endif
 #endif
 
diff --git a/src/backend/regex/regcomp.c b/src/backend/regex/regcomp.c
index 364573e2b5b..dcb95173c06 100644
--- a/src/backend/regex/regcomp.c
+++ b/src/backend/regex/regcomp.c
@@ -1,7 +1,7 @@
 /*-
  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  * Copyright (c) 1992, 1993, 1994
- *	The Regents of the University of California.  All rights reserved.
+ *		The Regents of the University of California.  All rights reserved.
  *
  * This code is derived from software contributed to Berkeley by
  * Henry Spencer.
@@ -10,22 +10,22 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
+ *	  must display the following acknowledgement:
+ *		This product includes software developed by the University of
+ *		California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
+ *	  may be used to endorse or promote products derived from this software
+ *	  without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -34,12 +34,13 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	@(#)regcomp.c	8.5 (Berkeley) 3/20/94
+ *		@(#)regcomp.c	8.5 (Berkeley) 3/20/94
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char sccsid[] = "@(#)regcomp.c	8.5 (Berkeley) 3/20/94";
-#endif /* LIBC_SCCS and not lint */
+static char		sccsid[] = "@(#)regcomp.c	8.5 (Berkeley) 3/20/94";
+
+#endif							/* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
 #include <stdio.h>
@@ -49,7 +50,7 @@ static char sccsid[] = "@(#)regcomp.c	8.5 (Berkeley) 3/20/94";
 #include <stdlib.h>
 #include <assert.h>
 
-#include <regex/regex.h>   
+#include <regex/regex.h>
 #include <regex/utils.h>
 #include <regex/regex2.h>
 #include <regex/cclass.h>
@@ -59,167 +60,179 @@ static char sccsid[] = "@(#)regcomp.c	8.5 (Berkeley) 3/20/94";
  * parse structure, passed up and down to avoid global variables and
  * other clumsinesses
  */
-struct parse {
-	char *next;		/* next character in RE */
-	char *end;		/* end of string (-> NUL normally) */
-	int error;		/* has an error been seen? */
-	sop *strip;		/* malloced strip */
-	sopno ssize;		/* malloced strip size (allocated) */
-	sopno slen;		/* malloced strip length (used) */
-	int ncsalloc;		/* number of csets allocated */
+struct parse
+{
+	char		   *next;		/* next character in RE */
+	char		   *end;		/* end of string (-> NUL normally) */
+	int				error;		/* has an error been seen? */
+	sop			   *strip;		/* malloced strip */
+	sopno			ssize;		/* malloced strip size (allocated) */
+	sopno			slen;		/* malloced strip length (used) */
+	int				ncsalloc;	/* number of csets allocated */
 	struct re_guts *g;
-#	define	NPAREN	10	/* we need to remember () 1-9 for back refs */
-	sopno pbegin[NPAREN];	/* -> ( ([0] unused) */
-	sopno pend[NPAREN];	/* -> ) ([0] unused) */
+#define  NPAREN  10				/* we need to remember () 1-9 for back
+								 * refs */
+	sopno			pbegin[NPAREN];		/* -> ( ([0] unused) */
+	sopno			pend[NPAREN];		/* -> ) ([0] unused) */
 };
 
 /* ========= begin header generated by ./mkh ========= */
 #ifdef __cplusplus
-extern "C" {
+extern			"C"
+{
 #endif
 
 /* === regcomp.c === */
-static void p_ere(struct parse *p, int stop);
-static void p_ere_exp(struct parse *p);
-static void p_str(struct parse *p);
-static void p_bre(struct parse *p, int end1, int end2);
-static int p_simp_re(struct parse *p, int starordinary);
-static int p_count(struct parse *p);
-static void p_bracket(struct parse *p);
-static void p_b_term(struct parse *p, cset *cs);
-static void p_b_cclass(struct parse *p, cset *cs);
-static void p_b_eclass(struct parse *p, cset *cs);
-static char p_b_symbol(struct parse *p);
-static char p_b_coll_elem(struct parse *p, int endc);
-static char othercase(int ch);
-static void bothcases(struct parse *p, int ch);
-static void ordinary(struct parse *p, int ch);
-static void nonnewline(struct parse *p);
-static void repeat(struct parse *p, sopno start, int from, int to);
-static int seterr(struct parse *p, int e);
-static cset *allocset(struct parse *p);
-static void freeset(struct parse *p, cset *cs);
-static int freezeset(struct parse *p, cset *cs);
-static int firstch(struct parse *p, cset *cs);
-static int nch(struct parse *p, cset *cs);
-static void mcadd(struct parse *p, cset *cs, char *cp);
-static void mcinvert(struct parse *p, cset *cs);
-static void mccase(struct parse *p, cset *cs);
-static int isinsets(struct re_guts *g, int c);
-static int samesets(struct re_guts *g, int c1, int c2);
-static void categorize(struct parse *p, struct re_guts *g);
-static sopno dupl(struct parse *p, sopno start, sopno finish);
-static void doemit(struct parse *p, sop op, size_t opnd);
-static void doinsert(struct parse *p, sop op, size_t opnd, sopno pos);
-static void dofwd(struct parse *p, sopno pos, sop value);
-static void enlarge(struct parse *p, sopno size);
-static void stripsnug(struct parse *p, struct re_guts *g);
-static void findmust(struct parse *p, struct re_guts *g);
-static sopno pluscount(struct parse *p, struct re_guts *g);
+	static void		p_ere(struct parse * p, int stop);
+	static void		p_ere_exp(struct parse * p);
+	static void		p_str(struct parse * p);
+	static void		p_bre(struct parse * p, int end1, int end2);
+	static int		p_simp_re(struct parse * p, int starordinary);
+	static int		p_count(struct parse * p);
+	static void		p_bracket(struct parse * p);
+	static void		p_b_term(struct parse * p, cset * cs);
+	static void		p_b_cclass(struct parse * p, cset * cs);
+	static void		p_b_eclass(struct parse * p, cset * cs);
+	static char		p_b_symbol(struct parse * p);
+	static char		p_b_coll_elem(struct parse * p, int endc);
+	static char		othercase(int ch);
+	static void		bothcases(struct parse * p, int ch);
+	static void		ordinary(struct parse * p, int ch);
+	static void		nonnewline(struct parse * p);
+	static void		repeat(struct parse * p, sopno start, int from, int to);
+	static int		seterr(struct parse * p, int e);
+	static cset    *allocset(struct parse * p);
+	static void		freeset(struct parse * p, cset * cs);
+	static int		freezeset(struct parse * p, cset * cs);
+	static int		firstch(struct parse * p, cset * cs);
+	static int		nch(struct parse * p, cset * cs);
+	static void		mcadd(struct parse * p, cset * cs, char *cp);
+	static void		mcinvert(struct parse * p, cset * cs);
+	static void		mccase(struct parse * p, cset * cs);
+	static int		isinsets(struct re_guts * g, int c);
+	static int		samesets(struct re_guts * g, int c1, int c2);
+	static void		categorize(struct parse * p, struct re_guts * g);
+	static sopno	dupl(struct parse * p, sopno start, sopno finish);
+	static void		doemit(struct parse * p, sop op, size_t opnd);
+	static void		doinsert(struct parse * p, sop op, size_t opnd, sopno pos);
+	static void		dofwd(struct parse * p, sopno pos, sop value);
+	static void		enlarge(struct parse * p, sopno size);
+	static void		stripsnug(struct parse * p, struct re_guts * g);
+	static void		findmust(struct parse * p, struct re_guts * g);
+	static sopno	pluscount(struct parse * p, struct re_guts * g);
 
 #ifdef __cplusplus
 }
+
 #endif
 /* ========= end header generated by ./mkh ========= */
 
-static char nuls[10];		/* place to point scanner in event of error */
+static char		nuls[10];		/* place to point scanner in event of
+								 * error */
 
 /*
  * macros for use with parse structure
- * BEWARE:  these know that the parse structure is named `p' !!!
+ * BEWARE:	these know that the parse structure is named `p' !!!
  */
-#define	PEEK()	(*p->next)
-#define	PEEK2()	(*(p->next+1))
-#define	MORE()	(p->next < p->end)
-#define	MORE2()	(p->next+1 < p->end)
-#define	SEE(c)	(MORE() && PEEK() == (c))
-#define	SEETWO(a, b)	(MORE() && MORE2() && PEEK() == (a) && PEEK2() == (b))
-#define	EAT(c)	((SEE(c)) ? (NEXT(), 1) : 0)
-#define	EATTWO(a, b)	((SEETWO(a, b)) ? (NEXT2(), 1) : 0)
-#define	NEXT()	(p->next++)
-#define	NEXT2()	(p->next += 2)
-#define	NEXTn(n)	(p->next += (n))
-#define	GETNEXT()	(*p->next++)
-#define	SETERROR(e)	seterr(p, (e))
-#define	REQUIRE(co, e)	if (!(co)) SETERROR(e)
-#define	MUSTSEE(c, e)	REQUIRE(MORE() && PEEK() == (c), e)
-#define	MUSTEAT(c, e)	REQUIRE(MORE() && GETNEXT() == (c), e)
-#define	MUSTNOTSEE(c, e)	REQUIRE(!MORE() || PEEK() != (c), e)
-#define	EMIT(op, sopnd)	doemit(p, (sop)(op), (size_t)(sopnd))
-#define	INSERT(op, pos)	doinsert(p, (sop)(op), HERE()-(pos)+1, pos)
-#define	AHEAD(pos)		dofwd(p, pos, HERE()-(pos))
-#define	ASTERN(sop, pos)	EMIT(sop, HERE()-pos)
-#define	HERE()		(p->slen)
-#define	THERE()		(p->slen - 1)
-#define	THERETHERE()	(p->slen - 2)
-#define	DROP(n)	(p->slen -= (n))
+#define PEEK()	(*p->next)
+#define PEEK2() (*(p->next+1))
+#define MORE()	(p->next < p->end)
+#define MORE2() (p->next+1 < p->end)
+#define SEE(c)	(MORE() && PEEK() == (c))
+#define SEETWO(a, b)	(MORE() && MORE2() && PEEK() == (a) && PEEK2() == (b))
+#define EAT(c)	((SEE(c)) ? (NEXT(), 1) : 0)
+#define EATTWO(a, b)	((SEETWO(a, b)) ? (NEXT2(), 1) : 0)
+#define NEXT()	(p->next++)
+#define NEXT2() (p->next += 2)
+#define NEXTn(n)		(p->next += (n))
+#define GETNEXT()		(*p->next++)
+#define SETERROR(e)		seterr(p, (e))
+#define REQUIRE(co, e)	if (!(co)) SETERROR(e)
+#define MUSTSEE(c, e)	REQUIRE(MORE() && PEEK() == (c), e)
+#define MUSTEAT(c, e)	REQUIRE(MORE() && GETNEXT() == (c), e)
+#define MUSTNOTSEE(c, e)		REQUIRE(!MORE() || PEEK() != (c), e)
+#define EMIT(op, sopnd) doemit(p, (sop)(op), (size_t)(sopnd))
+#define INSERT(op, pos) doinsert(p, (sop)(op), HERE()-(pos)+1, pos)
+#define AHEAD(pos)				dofwd(p, pos, HERE()-(pos))
+#define ASTERN(sop, pos)		EMIT(sop, HERE()-pos)
+#define HERE()			(p->slen)
+#define THERE()			(p->slen - 1)
+#define THERETHERE()	(p->slen - 2)
+#define DROP(n) (p->slen -= (n))
 
 #ifndef NDEBUG
-static int never = 0;		/* for use in asserts; shuts lint up */
+static int		never = 0;		/* for use in asserts; shuts lint up */
+
 #else
-#define	never	0		/* some <assert.h>s have bugs too */
+#define never	0				/* some <assert.h>s have bugs too */
 #endif
 
 /*
  - regcomp - interface for parser and compilation
  = extern int regcomp(regex_t *, const char *, int);
- = #define	REG_BASIC	0000
- = #define	REG_EXTENDED	0001
- = #define	REG_ICASE	0002
- = #define	REG_NOSUB	0004
- = #define	REG_NEWLINE	0010
- = #define	REG_NOSPEC	0020
- = #define	REG_PEND	0040
- = #define	REG_DUMP	0200
+ = #define		REG_BASIC		0000
+ = #define		REG_EXTENDED	0001
+ = #define		REG_ICASE		0002
+ = #define		REG_NOSUB		0004
+ = #define		REG_NEWLINE		0010
+ = #define		REG_NOSPEC		0020
+ = #define		REG_PEND		0040
+ = #define		REG_DUMP		0200
  */
-int				/* 0 success, otherwise REG_something */
+int								/* 0 success, otherwise REG_something */
 pg95_regcomp(preg, pattern, cflags)
-regex_t *preg;
-const char *pattern;
-int cflags;
+regex_t		   *preg;
+const char	   *pattern;
+int				cflags;
 {
-	struct parse pa;
+	struct parse	pa;
 	register struct re_guts *g;
 	register struct parse *p = &pa;
-	register int i;
+	register int	i;
 	register size_t len;
+
 #ifdef REDEBUG
-#	define	GOODFLAGS(f)	(f)
+#define  GOODFLAGS(f)	 (f)
 #else
-#	define	GOODFLAGS(f)	((f)&~REG_DUMP)
+#define  GOODFLAGS(f)	 ((f)&~REG_DUMP)
 #endif
 
 	cflags = GOODFLAGS(cflags);
-	if ((cflags&REG_EXTENDED) && (cflags&REG_NOSPEC))
-		return(REG_INVARG);
+	if ((cflags & REG_EXTENDED) && (cflags & REG_NOSPEC))
+		return (REG_INVARG);
 
-	if (cflags&REG_PEND) {
+	if (cflags & REG_PEND)
+	{
 		if (preg->re_endp < pattern)
-			return(REG_INVARG);
+			return (REG_INVARG);
 		len = preg->re_endp - pattern;
-	} else
-		len = strlen((char *)pattern);
+	}
+	else
+		len = strlen((char *) pattern);
 
 	/* do the mallocs early so failure handling is easy */
-	g = (struct re_guts *)malloc(sizeof(struct re_guts) +
-							(NC-1)*sizeof(cat_t));
+	g = (struct re_guts *) malloc(sizeof(struct re_guts) +
+								  (NC - 1) * sizeof(cat_t));
 	if (g == NULL)
-		return(REG_ESPACE);
-	p->ssize = len/(size_t)2*(size_t)3 + (size_t)1;	/* ugh */
-	p->strip = (sop *)malloc(p->ssize * sizeof(sop));
+		return (REG_ESPACE);
+	p->ssize = len / (size_t) 2 *(size_t) 3 + (size_t) 1;		/* ugh */
+
+	p->strip = (sop *) malloc(p->ssize * sizeof(sop));
 	p->slen = 0;
-	if (p->strip == NULL) {
-		free((char *)g);
-		return(REG_ESPACE);
+	if (p->strip == NULL)
+	{
+		free((char *) g);
+		return (REG_ESPACE);
 	}
 
 	/* set things up */
 	p->g = g;
-	p->next = (char *)pattern;	/* convenience; we do not modify it */
+	p->next = (char *) pattern; /* convenience; we do not modify it */
 	p->end = p->next + len;
 	p->error = 0;
 	p->ncsalloc = 0;
-	for (i = 0; i < NPAREN; i++) {
+	for (i = 0; i < NPAREN; i++)
+	{
 		p->pbegin[i] = 0;
 		p->pend[i] = 0;
 	}
@@ -234,17 +247,17 @@ int cflags;
 	g->must = NULL;
 	g->mlen = 0;
 	g->nsub = 0;
-	g->ncategories = 1;	/* category 0 is "everything else" */
+	g->ncategories = 1;			/* category 0 is "everything else" */
 	g->categories = &g->catspace[-(CHAR_MIN)];
-	memset((char *)g->catspace, 0, NC*sizeof(cat_t));
+	memset((char *) g->catspace, 0, NC * sizeof(cat_t));
 	g->backrefs = 0;
 
 	/* do it */
 	EMIT(OEND, 0);
 	g->firststate = THERE();
-	if (cflags&REG_EXTENDED)
+	if (cflags & REG_EXTENDED)
 		p_ere(p, OUT);
-	else if (cflags&REG_NOSPEC)
+	else if (cflags & REG_NOSPEC)
 		p_str(p);
 	else
 		p_bre(p, OUT, OUT);
@@ -262,14 +275,14 @@ int cflags;
 	preg->re_magic = MAGIC1;
 #ifndef REDEBUG
 	/* not debugging, so can't rely on the assert() in regexec() */
-	if (g->iflags&BAD)
+	if (g->iflags & BAD)
 		SETERROR(REG_ASSERT);
 #endif
 
 	/* win or lose, we're done */
-	if (p->error != 0)	/* lose */
+	if (p->error != 0)			/* lose */
 		pg95_regfree(preg);
-	return(p->error);
+	return (p->error);
 }
 
 /*
@@ -279,26 +292,28 @@ int cflags;
 static void
 p_ere(p, stop)
 register struct parse *p;
-int stop;			/* character this ERE should end at */
+int				stop;			/* character this ERE should end at */
 {
-	register char c;
-	register sopno prevback = 0;
-	register sopno prevfwd = 0;
-	register sopno conc;
-	register int first = 1;		/* is this the first alternative? */
-
-	for (;;) {
+	register char	c;
+	register sopno	prevback = 0;
+	register sopno	prevfwd = 0;
+	register sopno	conc;
+	register int	first = 1;	/* is this the first alternative? */
+
+	for (;;)
+	{
 		/* do a bunch of concatenated expressions */
 		conc = HERE();
 		while (MORE() && (c = PEEK()) != '|' && c != stop)
 			p_ere_exp(p);
-		REQUIRE(HERE() != conc, REG_EMPTY);	/* require nonempty */
+		REQUIRE(HERE() != conc, REG_EMPTY);		/* require nonempty */
 
 		if (!EAT('|'))
-			break;		/* NOTE BREAK OUT */
+			break;				/* NOTE BREAK OUT */
 
-		if (first) {
-			INSERT(OCH_, conc);	/* offset is wrong */
+		if (first)
+		{
+			INSERT(OCH_, conc); /* offset is wrong */
 			prevfwd = conc;
 			prevback = conc;
 			first = 0;
@@ -310,7 +325,8 @@ int stop;			/* character this ERE should end at */
 		EMIT(OOR2, 0);			/* offset is very wrong */
 	}
 
-	if (!first) {		/* tail-end fixups */
+	if (!first)
+	{							/* tail-end fixups */
 		AHEAD(prevfwd);
 		ASTERN(O_CH, prevback);
 	}
@@ -326,18 +342,19 @@ static void
 p_ere_exp(p)
 register struct parse *p;
 {
-	register char c;
-	register sopno pos;
-	register int count;
-	register int count2;
-	register sopno subno;
-	int wascaret = 0;
-
-	assert(MORE());		/* caller should have ensured this */
+	register char	c;
+	register sopno	pos;
+	register int	count;
+	register int	count2;
+	register sopno	subno;
+	int				wascaret = 0;
+
+	assert(MORE());				/* caller should have ensured this */
 	c = GETNEXT();
 
 	pos = HERE();
-	switch (c) {
+	switch (c)
+	{
 	case '(':
 		REQUIRE(MORE(), REG_EPAREN);
 		p->g->nsub++;
@@ -347,7 +364,8 @@ register struct parse *p;
 		EMIT(OLPAREN, subno);
 		if (!SEE(')'))
 			p_ere(p, ')');
-		if (subno < NPAREN) {
+		if (subno < NPAREN)
+		{
 			p->pend[subno] = HERE();
 			assert(p->pend[subno] != 0);
 		}
@@ -355,13 +373,13 @@ register struct parse *p;
 		MUSTEAT(')', REG_EPAREN);
 		break;
 #ifndef POSIX_MISTAKE
-	case ')':		/* happens only if no current unmatched ( */
+	case ')':					/* happens only if no current unmatched ( */
+
 		/*
-		 * You may ask, why the ifndef?  Because I didn't notice
-		 * this until slightly too late for 1003.2, and none of the
-		 * other 1003.2 regular-expression reviewers noticed it at
-		 * all.  So an unmatched ) is legal POSIX, at least until
-		 * we can get it fixed.
+		 * You may ask, why the ifndef?  Because I didn't notice this
+		 * until slightly too late for 1003.2, and none of the other
+		 * 1003.2 regular-expression reviewers noticed it at all.  So an
+		 * unmatched ) is legal POSIX, at least until we can get it fixed.
 		 */
 		SETERROR(REG_EPAREN);
 		break;
@@ -386,7 +404,7 @@ register struct parse *p;
 		SETERROR(REG_BADRPT);
 		break;
 	case '.':
-		if (p->g->cflags&REG_NEWLINE)
+		if (p->g->cflags & REG_NEWLINE)
 			nonnewline(p);
 		else
 			EMIT(OANY, 0);
@@ -399,7 +417,8 @@ register struct parse *p;
 		c = GETNEXT();
 		ordinary(p, c);
 		break;
-	case '{':		/* okay as ordinary except if digit follows */
+	case '{':					/* okay as ordinary except if digit
+								 * follows */
 		REQUIRE(!MORE() || !isdigit(PEEK()), REG_BADRPT);
 		/* FALLTHROUGH */
 	default:
@@ -411,14 +430,15 @@ register struct parse *p;
 		return;
 	c = PEEK();
 	/* we call { a repetition if followed by a digit */
-	if (!( c == '*' || c == '+' || c == '?' ||
-				(c == '{' && MORE2() && isdigit(PEEK2())) ))
-		return;		/* no repetition, we're done */
+	if (!(c == '*' || c == '+' || c == '?' ||
+		  (c == '{' && MORE2() && isdigit(PEEK2()))))
+		return;					/* no repetition, we're done */
 	NEXT();
 
 	REQUIRE(!wascaret, REG_BADRPT);
-	switch (c) {
-	case '*':	/* implemented as +? */
+	switch (c)
+	{
+	case '*':					/* implemented as +? */
 		/* this case does not require the (y|) trick, noKLUDGE */
 		INSERT(OPLUS_, pos);
 		ASTERN(O_PLUS, pos);
@@ -433,23 +453,30 @@ register struct parse *p;
 		/* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
 		INSERT(OCH_, pos);		/* offset slightly wrong */
 		ASTERN(OOR1, pos);		/* this one's right */
-		AHEAD(pos);			/* fix the OCH_ */
+		AHEAD(pos);				/* fix the OCH_ */
 		EMIT(OOR2, 0);			/* offset very wrong... */
 		AHEAD(THERE());			/* ...so fix it */
 		ASTERN(O_CH, THERETHERE());
 		break;
 	case '{':
 		count = p_count(p);
-		if (EAT(',')) {
-			if (isdigit(PEEK())) {
+		if (EAT(','))
+		{
+			if (isdigit(PEEK()))
+			{
 				count2 = p_count(p);
 				REQUIRE(count <= count2, REG_BADBR);
-			} else		/* single number with comma */
+			}
+			else
+/* single number with comma */
 				count2 = INFINITY;
-		} else		/* just a single number */
+		}
+		else
+/* just a single number */
 			count2 = count;
 		repeat(p, pos, count, count2);
-		if (!EAT('}')) {	/* error heuristics */
+		if (!EAT('}'))
+		{						/* error heuristics */
 			while (MORE() && PEEK() != '}')
 				NEXT();
 			REQUIRE(MORE(), REG_EBRACE);
@@ -461,8 +488,8 @@ register struct parse *p;
 	if (!MORE())
 		return;
 	c = PEEK();
-	if (!( c == '*' || c == '+' || c == '?' ||
-				(c == '{' && MORE2() && isdigit(PEEK2())) ) )
+	if (!(c == '*' || c == '+' || c == '?' ||
+		  (c == '{' && MORE2() && isdigit(PEEK2()))))
 		return;
 	SETERROR(REG_BADRPT);
 }
@@ -483,72 +510,78 @@ register struct parse *p;
 /*
  - p_bre - BRE parser top level, anchoring and concatenation
  == static void p_bre(register struct parse *p, register int end1, \
- ==	register int end2);
+ ==		register int end2);
  * Giving end1 as OUT essentially eliminates the end1/end2 check.
  *
  * This implementation is a bit of a kludge, in that a trailing $ is first
  * taken as an ordinary character and then revised to be an anchor.  The
  * only undesirable side effect is that '$' gets included as a character
- * category in such cases.  This is fairly harmless; not worth fixing.
+ * category in such cases.	This is fairly harmless; not worth fixing.
  * The amount of lookahead needed to avoid this kludge is excessive.
  */
 static void
 p_bre(p, end1, end2)
 register struct parse *p;
-register int end1;		/* first terminating character */
-register int end2;		/* second terminating character */
+register int	end1;			/* first terminating character */
+register int	end2;			/* second terminating character */
 {
-	register sopno start = HERE();
-	register int first = 1;			/* first subexpression? */
-	register int wasdollar = 0;
+	register sopno	start = HERE();
+	register int	first = 1;	/* first subexpression? */
+	register int	wasdollar = 0;
 
-	if (EAT('^')) {
+	if (EAT('^'))
+	{
 		EMIT(OBOL, 0);
 		p->g->iflags |= USEBOL;
 		p->g->nbol++;
 	}
-	while (MORE() && !SEETWO(end1, end2)) {
+	while (MORE() && !SEETWO(end1, end2))
+	{
 		wasdollar = p_simp_re(p, first);
 		first = 0;
 	}
-	if (wasdollar) {	/* oops, that was a trailing anchor */
+	if (wasdollar)
+	{							/* oops, that was a trailing anchor */
 		DROP(1);
 		EMIT(OEOL, 0);
 		p->g->iflags |= USEEOL;
 		p->g->neol++;
 	}
 
-	REQUIRE(HERE() != start, REG_EMPTY);	/* require nonempty */
+	REQUIRE(HERE() != start, REG_EMPTY);		/* require nonempty */
 }
 
 /*
  - p_simp_re - parse a simple RE, an atom possibly followed by a repetition
  == static int p_simp_re(register struct parse *p, int starordinary);
  */
-static int			/* was the simple RE an unbackslashed $? */
+static int						/* was the simple RE an unbackslashed $? */
 p_simp_re(p, starordinary)
 register struct parse *p;
-int starordinary;		/* is a leading * an ordinary character? */
+int				starordinary;	/* is a leading * an ordinary character? */
 {
-	register int c;
-	register int count;
-	register int count2;
-	register sopno pos;
-	register int i;
-	register sopno subno;
-#	define	BACKSL	(1<<CHAR_BIT)
+	register int	c;
+	register int	count;
+	register int	count2;
+	register sopno	pos;
+	register int	i;
+	register sopno	subno;
 
-	pos = HERE();		/* repetion op, if any, covers from here */
+#define  BACKSL  (1<<CHAR_BIT)
 
-	assert(MORE());		/* caller should have ensured this */
+	pos = HERE();				/* repetion op, if any, covers from here */
+
+	assert(MORE());				/* caller should have ensured this */
 	c = GETNEXT();
-	if (c == '\\') {
+	if (c == '\\')
+	{
 		REQUIRE(MORE(), REG_EESCAPE);
-		c = BACKSL | (unsigned char)GETNEXT();
+		c = BACKSL | (unsigned char) GETNEXT();
 	}
-	switch (c) {
+	switch (c)
+	{
 	case '.':
-		if (p->g->cflags&REG_NEWLINE)
+		if (p->g->cflags & REG_NEWLINE)
 			nonnewline(p);
 		else
 			EMIT(OANY, 0);
@@ -556,10 +589,10 @@ int starordinary;		/* is a leading * an ordinary character? */
 	case '[':
 		p_bracket(p);
 		break;
-	case BACKSL|'{':
+	case BACKSL | '{':
 		SETERROR(REG_BADRPT);
 		break;
-	case BACKSL|'(':
+	case BACKSL | '(':
 		p->g->nsub++;
 		subno = p->g->nsub;
 		if (subno < NPAREN)
@@ -568,37 +601,40 @@ int starordinary;		/* is a leading * an ordinary character? */
 		/* the MORE here is an error heuristic */
 		if (MORE() && !SEETWO('\\', ')'))
 			p_bre(p, '\\', ')');
-		if (subno < NPAREN) {
+		if (subno < NPAREN)
+		{
 			p->pend[subno] = HERE();
 			assert(p->pend[subno] != 0);
 		}
 		EMIT(ORPAREN, subno);
 		REQUIRE(EATTWO('\\', ')'), REG_EPAREN);
 		break;
-	case BACKSL|')':	/* should not get here -- must be user */
-	case BACKSL|'}':
+	case BACKSL | ')':			/* should not get here -- must be user */
+	case BACKSL | '}':
 		SETERROR(REG_EPAREN);
 		break;
-	case BACKSL|'1':
-	case BACKSL|'2':
-	case BACKSL|'3':
-	case BACKSL|'4':
-	case BACKSL|'5':
-	case BACKSL|'6':
-	case BACKSL|'7':
-	case BACKSL|'8':
-	case BACKSL|'9':
-		i = (c&~BACKSL) - '0';
+	case BACKSL | '1':
+	case BACKSL | '2':
+	case BACKSL | '3':
+	case BACKSL | '4':
+	case BACKSL | '5':
+	case BACKSL | '6':
+	case BACKSL | '7':
+	case BACKSL | '8':
+	case BACKSL | '9':
+		i = (c & ~BACKSL) - '0';
 		assert(i < NPAREN);
-		if (p->pend[i] != 0) {
+		if (p->pend[i] != 0)
+		{
 			assert(i <= p->g->nsub);
 			EMIT(OBACK_, i);
 			assert(p->pbegin[i] != 0);
 			assert(OP(p->strip[p->pbegin[i]]) == OLPAREN);
 			assert(OP(p->strip[p->pend[i]]) == ORPAREN);
-			dupl(p, p->pbegin[i]+1, p->pend[i]);
+			dupl(p, p->pbegin[i] + 1, p->pend[i]);
 			EMIT(O_BACK, i);
-		} else
+		}
+		else
 			SETERROR(REG_ESUBREG);
 		p->g->backrefs = 1;
 		break;
@@ -606,57 +642,69 @@ int starordinary;		/* is a leading * an ordinary character? */
 		REQUIRE(starordinary, REG_BADRPT);
 		/* FALLTHROUGH */
 	default:
-		ordinary(p, c &~ BACKSL);
+		ordinary(p, c & ~BACKSL);
 		break;
 	}
 
-	if (EAT('*')) {		/* implemented as +? */
+	if (EAT('*'))
+	{							/* implemented as +? */
 		/* this case does not require the (y|) trick, noKLUDGE */
 		INSERT(OPLUS_, pos);
 		ASTERN(O_PLUS, pos);
 		INSERT(OQUEST_, pos);
 		ASTERN(O_QUEST, pos);
-	} else if (EATTWO('\\', '{')) {
+	}
+	else if (EATTWO('\\', '{'))
+	{
 		count = p_count(p);
-		if (EAT(',')) {
-			if (MORE() && isdigit(PEEK())) {
+		if (EAT(','))
+		{
+			if (MORE() && isdigit(PEEK()))
+			{
 				count2 = p_count(p);
 				REQUIRE(count <= count2, REG_BADBR);
-			} else		/* single number with comma */
+			}
+			else
+/* single number with comma */
 				count2 = INFINITY;
-		} else		/* just a single number */
+		}
+		else
+/* just a single number */
 			count2 = count;
 		repeat(p, pos, count, count2);
-		if (!EATTWO('\\', '}')) {	/* error heuristics */
+		if (!EATTWO('\\', '}'))
+		{						/* error heuristics */
 			while (MORE() && !SEETWO('\\', '}'))
 				NEXT();
 			REQUIRE(MORE(), REG_EBRACE);
 			SETERROR(REG_BADBR);
 		}
-	} else if (c == (unsigned char)'$')	/* $ (but not \$) ends it */
-		return(1);
+	}
+	else if (c == (unsigned char) '$')	/* $ (but not \$) ends it */
+		return (1);
 
-	return(0);
+	return (0);
 }
 
 /*
  - p_count - parse a repetition count
  == static int p_count(register struct parse *p);
  */
-static int			/* the value */
+static int						/* the value */
 p_count(p)
 register struct parse *p;
 {
-	register int count = 0;
-	register int ndigits = 0;
+	register int	count = 0;
+	register int	ndigits = 0;
 
-	while (MORE() && isdigit(PEEK()) && count <= DUPMAX) {
-		count = count*10 + (GETNEXT() - '0');
+	while (MORE() && isdigit(PEEK()) && count <= DUPMAX)
+	{
+		count = count * 10 + (GETNEXT() - '0');
 		ndigits++;
 	}
 
 	REQUIRE(ndigits > 0 && count <= DUPMAX, REG_BADBR);
-	return(count);
+	return (count);
 }
 
 /*
@@ -670,23 +718,25 @@ static void
 p_bracket(p)
 register struct parse *p;
 {
-	register cset *cs = allocset(p);
-	register int invert = 0;
+	register cset  *cs = allocset(p);
+	register int	invert = 0;
 
 	/* Dept of Truly Sickening Special-Case Kludges */
-	if (p->next + 5 < p->end && strncmp(p->next, "[:<:]]", 6) == 0) {
+	if (p->next + 5 < p->end && strncmp(p->next, "[:<:]]", 6) == 0)
+	{
 		EMIT(OBOW, 0);
 		NEXTn(6);
 		return;
 	}
-	if (p->next + 5 < p->end && strncmp(p->next, "[:>:]]", 6) == 0) {
+	if (p->next + 5 < p->end && strncmp(p->next, "[:>:]]", 6) == 0)
+	{
 		EMIT(OEOW, 0);
 		NEXTn(6);
 		return;
 	}
 
 	if (EAT('^'))
-		invert++;	/* make note to invert set at end */
+		invert++;				/* make note to invert set at end */
 	if (EAT(']'))
 		CHadd(cs, ']');
 	else if (EAT('-'))
@@ -697,15 +747,17 @@ register struct parse *p;
 		CHadd(cs, '-');
 	MUSTEAT(']', REG_EBRACK);
 
-	if (p->error != 0)	/* don't mess things up further */
+	if (p->error != 0)			/* don't mess things up further */
 		return;
 
-	if (p->g->cflags&REG_ICASE) {
-		register int i;
-		register int ci;
+	if (p->g->cflags & REG_ICASE)
+	{
+		register int	i;
+		register int	ci;
 
 		for (i = p->g->csetsize - 1; i >= 0; i--)
-			if (CHIN(cs, i) && isalpha(i)) {
+			if (CHIN(cs, i) && isalpha(i))
+			{
 				ci = othercase(i);
 				if (ci != i)
 					CHadd(cs, ci);
@@ -713,26 +765,29 @@ register struct parse *p;
 		if (cs->multis != NULL)
 			mccase(p, cs);
 	}
-	if (invert) {
-		register int i;
+	if (invert)
+	{
+		register int	i;
 
 		for (i = p->g->csetsize - 1; i >= 0; i--)
 			if (CHIN(cs, i))
 				CHsub(cs, i);
 			else
 				CHadd(cs, i);
-		if (p->g->cflags&REG_NEWLINE)
+		if (p->g->cflags & REG_NEWLINE)
 			CHsub(cs, '\n');
 		if (cs->multis != NULL)
 			mcinvert(p, cs);
 	}
 
-	assert(cs->multis == NULL);		/* xxx */
+	assert(cs->multis == NULL); /* xxx */
 
-	if (nch(p, cs) == 1) {		/* optimize singleton sets */
+	if (nch(p, cs) == 1)
+	{							/* optimize singleton sets */
 		ordinary(p, firstch(p, cs));
 		freeset(p, cs);
-	} else
+	}
+	else
 		EMIT(OANYOF, freezeset(p, cs));
 }
 
@@ -743,28 +798,31 @@ register struct parse *p;
 static void
 p_b_term(p, cs)
 register struct parse *p;
-register cset *cs;
+register cset  *cs;
 {
-	register char c;
-	register char start, finish;
-	register int i;
+	register char	c;
+	register char	start,
+					finish;
+	register int	i;
 
 	/* classify what we've got */
-	switch ((MORE()) ? PEEK() : '\0') {
+	switch ((MORE()) ? PEEK() : '\0')
+	{
 	case '[':
 		c = (MORE2()) ? PEEK2() : '\0';
 		break;
 	case '-':
 		SETERROR(REG_ERANGE);
-		return;			/* NOTE RETURN */
+		return;					/* NOTE RETURN */
 		break;
 	default:
 		c = '\0';
 		break;
 	}
 
-	switch (c) {
-	case ':':		/* character class */
+	switch (c)
+	{
+	case ':':					/* character class */
 		NEXT2();
 		REQUIRE(MORE(), REG_EBRACK);
 		c = PEEK();
@@ -773,7 +831,7 @@ register cset *cs;
 		REQUIRE(MORE(), REG_EBRACK);
 		REQUIRE(EATTWO(':', ']'), REG_ECTYPE);
 		break;
-	case '=':		/* equivalence class */
+	case '=':					/* equivalence class */
 		NEXT2();
 		REQUIRE(MORE(), REG_EBRACK);
 		c = PEEK();
@@ -782,17 +840,19 @@ register cset *cs;
 		REQUIRE(MORE(), REG_EBRACK);
 		REQUIRE(EATTWO('=', ']'), REG_ECOLLATE);
 		break;
-	default:		/* symbol, ordinary character, or range */
+	default:					/* symbol, ordinary character, or range */
 /* xxx revision needed for multichar stuff */
 		start = p_b_symbol(p);
-		if (SEE('-') && MORE2() && PEEK2() != ']') {
+		if (SEE('-') && MORE2() && PEEK2() != ']')
+		{
 			/* range */
 			NEXT();
 			if (EAT('-'))
 				finish = '-';
 			else
 				finish = p_b_symbol(p);
-		} else
+		}
+		else
 			finish = start;
 /* xxx what about signed chars here... */
 		REQUIRE(start <= finish, REG_ERANGE);
@@ -809,13 +869,13 @@ register cset *cs;
 static void
 p_b_cclass(p, cs)
 register struct parse *p;
-register cset *cs;
+register cset  *cs;
 {
-	register char *sp = p->next;
+	register char  *sp = p->next;
 	register struct cclass *cp;
 	register size_t len;
-	register char *u;
-	register char c;
+	register char  *u;
+	register char	c;
 
 	while (MORE() && isalpha(PEEK()))
 		NEXT();
@@ -823,7 +883,8 @@ register cset *cs;
 	for (cp = cclasses; cp->name != NULL; cp++)
 		if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')
 			break;
-	if (cp->name == NULL) {
+	if (cp->name == NULL)
+	{
 		/* oops, didn't find it */
 		SETERROR(REG_ECTYPE);
 		return;
@@ -845,9 +906,9 @@ register cset *cs;
 static void
 p_b_eclass(p, cs)
 register struct parse *p;
-register cset *cs;
+register cset  *cs;
 {
-	register char c;
+	register char	c;
 
 	c = p_b_coll_elem(p, '=');
 	CHadd(cs, c);
@@ -857,66 +918,68 @@ register cset *cs;
  - p_b_symbol - parse a character or [..]ed multicharacter collating symbol
  == static char p_b_symbol(register struct parse *p);
  */
-static char			/* value of symbol */
+static char						/* value of symbol */
 p_b_symbol(p)
 register struct parse *p;
 {
-	register char value;
+	register char	value;
 
 	REQUIRE(MORE(), REG_EBRACK);
 	if (!EATTWO('[', '.'))
-		return(GETNEXT());
+		return (GETNEXT());
 
 	/* collating symbol */
 	value = p_b_coll_elem(p, '.');
 	REQUIRE(EATTWO('.', ']'), REG_ECOLLATE);
-	return(value);
+	return (value);
 }
 
 /*
  - p_b_coll_elem - parse a collating-element name and look it up
  == static char p_b_coll_elem(register struct parse *p, int endc);
  */
-static char			/* value of collating element */
+static char						/* value of collating element */
 p_b_coll_elem(p, endc)
 register struct parse *p;
-int endc;			/* name ended by endc,']' */
+int				endc;			/* name ended by endc,']' */
 {
-	register char *sp = p->next;
+	register char  *sp = p->next;
 	register struct cname *cp;
-	register int len;
+	register int	len;
 
 	while (MORE() && !SEETWO(endc, ']'))
 		NEXT();
-	if (!MORE()) {
+	if (!MORE())
+	{
 		SETERROR(REG_EBRACK);
-		return(0);
+		return (0);
 	}
 	len = p->next - sp;
 	for (cp = cnames; cp->name != NULL; cp++)
 		if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')
-			return(cp->code);	/* known name */
+			return (cp->code);	/* known name */
 	if (len == 1)
-		return(*sp);	/* single character */
-	SETERROR(REG_ECOLLATE);			/* neither */
-	return(0);
+		return (*sp);			/* single character */
+	SETERROR(REG_ECOLLATE);		/* neither */
+	return (0);
 }
 
 /*
  - othercase - return the case counterpart of an alphabetic
  == static char othercase(int ch);
  */
-static char			/* if no counterpart, return ch */
+static char						/* if no counterpart, return ch */
 othercase(ch)
-int ch;
+int				ch;
 {
 	assert(isalpha(ch));
 	if (isupper(ch))
-		return(tolower(ch));
+		return (tolower(ch));
 	else if (islower(ch))
-		return(toupper(ch));
-	else			/* peculiar, but could happen */
-		return(ch);
+		return (toupper(ch));
+	else
+/* peculiar, but could happen */
+		return (ch);
 }
 
 /*
@@ -928,20 +991,20 @@ int ch;
 static void
 bothcases(p, ch)
 register struct parse *p;
-int ch;
+int				ch;
 {
-	register char *oldnext = p->next;
-	register char *oldend = p->end;
-	char bracket[3];
+	register char  *oldnext = p->next;
+	register char  *oldend = p->end;
+	char			bracket[3];
 
-	assert(othercase(ch) != ch);	/* p_bracket() would recurse */
+	assert(othercase(ch) != ch);/* p_bracket() would recurse */
 	p->next = bracket;
-	p->end = bracket+2;
+	p->end = bracket + 2;
 	bracket[0] = ch;
 	bracket[1] = ']';
 	bracket[2] = '\0';
 	p_bracket(p);
-	assert(p->next == bracket+2);
+	assert(p->next == bracket + 2);
 	p->next = oldnext;
 	p->end = oldend;
 }
@@ -953,14 +1016,15 @@ int ch;
 static void
 ordinary(p, ch)
 register struct parse *p;
-register int ch;
+register int	ch;
 {
 	register cat_t *cap = p->g->categories;
 
-	if ((p->g->cflags&REG_ICASE) && isalpha(ch) && othercase(ch) != ch)
+	if ((p->g->cflags & REG_ICASE) && isalpha(ch) && othercase(ch) != ch)
 		bothcases(p, ch);
-	else {
-		EMIT(OCHAR, (unsigned char)ch);
+	else
+	{
+		EMIT(OCHAR, (unsigned char) ch);
 		if (cap[ch] == 0)
 			cap[ch] = p->g->ncategories++;
 	}
@@ -976,18 +1040,18 @@ static void
 nonnewline(p)
 register struct parse *p;
 {
-	register char *oldnext = p->next;
-	register char *oldend = p->end;
-	char bracket[4];
+	register char  *oldnext = p->next;
+	register char  *oldend = p->end;
+	char			bracket[4];
 
 	p->next = bracket;
-	p->end = bracket+3;
+	p->end = bracket + 3;
 	bracket[0] = '^';
 	bracket[1] = '\n';
 	bracket[2] = ']';
 	bracket[3] = '\0';
 	p_bracket(p);
-	assert(p->next == bracket+3);
+	assert(p->next == bracket + 3);
 	p->next = oldnext;
 	p->end = oldend;
 }
@@ -999,42 +1063,45 @@ register struct parse *p;
 static void
 repeat(p, start, from, to)
 register struct parse *p;
-sopno start;			/* operand from here to end of strip */
-int from;			/* repeated from this number */
-int to;				/* to this number of times (maybe INFINITY) */
+sopno			start;			/* operand from here to end of strip */
+int				from;			/* repeated from this number */
+int				to;				/* to this number of times (maybe
+								 * INFINITY) */
 {
-	register sopno finish = HERE();
-#	define	N	2
-#	define	INF	3
-#	define	REP(f, t)	((f)*8 + (t))
-#	define	MAP(n)	(((n) <= 1) ? (n) : ((n) == INFINITY) ? INF : N)
-	register sopno copy;
-
-	if (p->error != 0)	/* head off possible runaway recursion */
+	register sopno	finish = HERE();
+
+#define  N		 2
+#define  INF	 3
+#define  REP(f, t)		 ((f)*8 + (t))
+#define  MAP(n)  (((n) <= 1) ? (n) : ((n) == INFINITY) ? INF : N)
+	register sopno	copy;
+
+	if (p->error != 0)			/* head off possible runaway recursion */
 		return;
 
 	assert(from <= to);
 
-	switch (REP(MAP(from), MAP(to))) {
-	case REP(0, 0):			/* must be user doing this */
-		DROP(finish-start);	/* drop the operand */
+	switch (REP(MAP(from), MAP(to)))
+	{
+	case REP(0, 0):				/* must be user doing this */
+		DROP(finish - start);	/* drop the operand */
 		break;
-	case REP(0, 1):			/* as x{1,1}? */
-	case REP(0, N):			/* as x{1,n}? */
-	case REP(0, INF):		/* as x{1,}? */
+	case REP(0, 1):				/* as x{1,1}? */
+	case REP(0, N):				/* as x{1,n}? */
+	case REP(0, INF):			/* as x{1,}? */
 		/* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
-		INSERT(OCH_, start);		/* offset is wrong... */
-		repeat(p, start+1, 1, to);
+		INSERT(OCH_, start);	/* offset is wrong... */
+		repeat(p, start + 1, 1, to);
 		ASTERN(OOR1, start);
 		AHEAD(start);			/* ... fix it */
 		EMIT(OOR2, 0);
 		AHEAD(THERE());
 		ASTERN(O_CH, THERETHERE());
 		break;
-	case REP(1, 1):			/* trivial case */
+	case REP(1, 1):				/* trivial case */
 		/* done */
 		break;
-	case REP(1, N):			/* as x?x{1,n-1} */
+	case REP(1, N):				/* as x?x{1,n-1} */
 		/* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
 		INSERT(OCH_, start);
 		ASTERN(OOR1, start);
@@ -1042,23 +1109,23 @@ int to;				/* to this number of times (maybe INFINITY) */
 		EMIT(OOR2, 0);			/* offset very wrong... */
 		AHEAD(THERE());			/* ...so fix it */
 		ASTERN(O_CH, THERETHERE());
-		copy = dupl(p, start+1, finish+1);
-		assert(copy == finish+4);
-		repeat(p, copy, 1, to-1);
+		copy = dupl(p, start + 1, finish + 1);
+		assert(copy == finish + 4);
+		repeat(p, copy, 1, to - 1);
 		break;
-	case REP(1, INF):		/* as x+ */
+	case REP(1, INF):			/* as x+ */
 		INSERT(OPLUS_, start);
 		ASTERN(O_PLUS, start);
 		break;
-	case REP(N, N):			/* as xx{m-1,n-1} */
+	case REP(N, N):				/* as xx{m-1,n-1} */
 		copy = dupl(p, start, finish);
-		repeat(p, copy, from-1, to-1);
+		repeat(p, copy, from - 1, to - 1);
 		break;
-	case REP(N, INF):		/* as xx{n-1,INF} */
+	case REP(N, INF):			/* as xx{n-1,INF} */
 		copy = dupl(p, start, finish);
-		repeat(p, copy, from-1, to);
+		repeat(p, copy, from - 1, to);
 		break;
-	default:			/* "can't happen" */
+	default:					/* "can't happen" */
 		SETERROR(REG_ASSERT);	/* just in case */
 		break;
 	}
@@ -1068,71 +1135,74 @@ int to;				/* to this number of times (maybe INFINITY) */
  - seterr - set an error condition
  == static int seterr(register struct parse *p, int e);
  */
-static int			/* useless but makes type checking happy */
+static int						/* useless but makes type checking happy */
 seterr(p, e)
 register struct parse *p;
-int e;
+int				e;
 {
-	if (p->error == 0)	/* keep earliest error condition */
+	if (p->error == 0)			/* keep earliest error condition */
 		p->error = e;
-	p->next = nuls;		/* try to bring things to a halt */
+	p->next = nuls;				/* try to bring things to a halt */
 	p->end = nuls;
-	return(0);		/* make the return value well-defined */
+	return (0);					/* make the return value well-defined */
 }
 
 /*
  - allocset - allocate a set of characters for []
  == static cset *allocset(register struct parse *p);
  */
-static cset *
+static cset    *
 allocset(p)
 register struct parse *p;
 {
-	register int no = p->g->ncsets++;
+	register int	no = p->g->ncsets++;
 	register size_t nc;
 	register size_t nbytes;
-	register cset *cs;
-	register size_t css = (size_t)p->g->csetsize;
-	register int i;
+	register cset  *cs;
+	register size_t css = (size_t) p->g->csetsize;
+	register int	i;
 
-	if (no >= p->ncsalloc) {	/* need another column of space */
+	if (no >= p->ncsalloc)
+	{							/* need another column of space */
 		p->ncsalloc += CHAR_BIT;
 		nc = p->ncsalloc;
 		assert(nc % CHAR_BIT == 0);
 		nbytes = nc / CHAR_BIT * css;
 		if (p->g->sets == NULL)
-			p->g->sets = (cset *)malloc(nc * sizeof(cset));
+			p->g->sets = (cset *) malloc(nc * sizeof(cset));
 		else
-			p->g->sets = (cset *)realloc((char *)p->g->sets,
-							nc * sizeof(cset));
+			p->g->sets = (cset *) realloc((char *) p->g->sets,
+										  nc * sizeof(cset));
 		if (p->g->setbits == NULL)
-			p->g->setbits = (uch *)malloc(nbytes);
-		else {
-			p->g->setbits = (uch *)realloc((char *)p->g->setbits,
-								nbytes);
+			p->g->setbits = (uch *) malloc(nbytes);
+		else
+		{
+			p->g->setbits = (uch *) realloc((char *) p->g->setbits,
+											nbytes);
 			/* xxx this isn't right if setbits is now NULL */
 			for (i = 0; i < no; i++)
-				p->g->sets[i].ptr = p->g->setbits + css*(i/CHAR_BIT);
+				p->g->sets[i].ptr = p->g->setbits + css * (i / CHAR_BIT);
 		}
 		if (p->g->sets != NULL && p->g->setbits != NULL)
-			memset((char *)p->g->setbits + (nbytes - css),
-								0, css);
-		else {
+			memset((char *) p->g->setbits + (nbytes - css),
+				   0, css);
+		else
+		{
 			no = 0;
 			SETERROR(REG_ESPACE);
 			/* caller's responsibility not to do set ops */
 		}
 	}
 
-	assert(p->g->sets != NULL);	/* xxx */
+	assert(p->g->sets != NULL); /* xxx */
 	cs = &p->g->sets[no];
-	cs->ptr = p->g->setbits + css*((no)/CHAR_BIT);
+	cs->ptr = p->g->setbits + css * ((no) / CHAR_BIT);
 	cs->mask = 1 << ((no) % CHAR_BIT);
 	cs->hash = 0;
 	cs->smultis = 0;
 	cs->multis = NULL;
 
-	return(cs);
+	return (cs);
 }
 
 /*
@@ -1142,15 +1212,15 @@ register struct parse *p;
 static void
 freeset(p, cs)
 register struct parse *p;
-register cset *cs;
+register cset  *cs;
 {
-	register int i;
-	register cset *top = &p->g->sets[p->g->ncsets];
-	register size_t css = (size_t)p->g->csetsize;
+	register int	i;
+	register cset  *top = &p->g->sets[p->g->ncsets];
+	register size_t css = (size_t) p->g->csetsize;
 
 	for (i = 0; i < css; i++)
 		CHsub(cs, i);
-	if (cs == top-1)	/* recover only the easy case */
+	if (cs == top - 1)			/* recover only the easy case */
 		p->g->ncsets--;
 }
 
@@ -1160,24 +1230,25 @@ register cset *cs;
  *
  * The main task here is merging identical sets.  This is usually a waste
  * of time (although the hash code minimizes the overhead), but can win
- * big if REG_ICASE is being used.  REG_ICASE, by the way, is why the hash
+ * big if REG_ICASE is being used.	REG_ICASE, by the way, is why the hash
  * is done using addition rather than xor -- all ASCII [aA] sets xor to
  * the same value!
  */
-static int			/* set number */
+static int						/* set number */
 freezeset(p, cs)
 register struct parse *p;
-register cset *cs;
+register cset  *cs;
 {
-	register uch h = cs->hash;
-	register int i;
-	register cset *top = &p->g->sets[p->g->ncsets];
-	register cset *cs2;
-	register size_t css = (size_t)p->g->csetsize;
+	register uch	h = cs->hash;
+	register int	i;
+	register cset  *top = &p->g->sets[p->g->ncsets];
+	register cset  *cs2;
+	register size_t css = (size_t) p->g->csetsize;
 
 	/* look for an earlier one which is the same */
 	for (cs2 = &p->g->sets[0]; cs2 < top; cs2++)
-		if (cs2->hash == h && cs2 != cs) {
+		if (cs2->hash == h && cs2 != cs)
+		{
 			/* maybe */
 			for (i = 0; i < css; i++)
 				if (!!CHIN(cs2, i) != !!CHIN(cs, i))
@@ -1186,31 +1257,32 @@ register cset *cs;
 				break;			/* yes */
 		}
 
-	if (cs2 < top) {	/* found one */
+	if (cs2 < top)
+	{							/* found one */
 		freeset(p, cs);
 		cs = cs2;
 	}
 
-	return((int)(cs - p->g->sets));
+	return ((int) (cs - p->g->sets));
 }
 
 /*
  - firstch - return first character in a set (which must have at least one)
  == static int firstch(register struct parse *p, register cset *cs);
  */
-static int			/* character; there is no "none" value */
+static int						/* character; there is no "none" value */
 firstch(p, cs)
 register struct parse *p;
-register cset *cs;
+register cset  *cs;
 {
-	register int i;
-	register size_t css = (size_t)p->g->csetsize;
+	register int	i;
+	register size_t css = (size_t) p->g->csetsize;
 
 	for (i = 0; i < css; i++)
 		if (CHIN(cs, i))
-			return((char)i);
+			return ((char) i);
 	assert(never);
-	return(0);		/* arbitrary */
+	return (0);					/* arbitrary */
 }
 
 /*
@@ -1220,28 +1292,28 @@ register cset *cs;
 static int
 nch(p, cs)
 register struct parse *p;
-register cset *cs;
+register cset  *cs;
 {
-	register int i;
-	register size_t css = (size_t)p->g->csetsize;
-	register int n = 0;
+	register int	i;
+	register size_t css = (size_t) p->g->csetsize;
+	register int	n = 0;
 
 	for (i = 0; i < css; i++)
 		if (CHIN(cs, i))
 			n++;
-	return(n);
+	return (n);
 }
 
 /*
  - mcadd - add a collating element to a cset
  == static void mcadd(register struct parse *p, register cset *cs, \
- ==	register char *cp);
+ ==		register char *cp);
  */
 static void
 mcadd(p, cs, cp)
 register struct parse *p;
-register cset *cs;
-register char *cp;
+register cset  *cs;
+register char  *cp;
 {
 	register size_t oldend = cs->smultis;
 
@@ -1250,7 +1322,8 @@ register char *cp;
 		cs->multis = malloc(cs->smultis);
 	else
 		cs->multis = realloc(cs->multis, cs->smultis);
-	if (cs->multis == NULL) {
+	if (cs->multis == NULL)
+	{
 		SETERROR(REG_ESPACE);
 		return;
 	}
@@ -1269,22 +1342,22 @@ mcsub(cs, cp)
 register cset *cs;
 register char *cp;
 {
-	register char *fp = mcfind(cs, cp);
-	register size_t len = strlen(fp);
-
-	assert(fp != NULL);
-	memmove(fp, fp + len + 1,
-				cs->smultis - (fp + len + 1 - cs->multis));
-	cs->smultis -= len;
-
-	if (cs->smultis == 0) {
-		free(cs->multis);
-		cs->multis = NULL;
-		return;
-	}
+		register char *fp = mcfind(cs, cp);
+		register size_t len = strlen(fp);
+
+		assert(fp != NULL);
+		memmove(fp, fp + len + 1,
+								cs->smultis - (fp + len + 1 - cs->multis));
+		cs->smultis -= len;
+
+		if (cs->smultis == 0) {
+				free(cs->multis);
+				cs->multis = NULL;
+				return;
+		}
 
-	cs->multis = realloc(cs->multis, cs->smultis);
-	assert(cs->multis != NULL);
+		cs->multis = realloc(cs->multis, cs->smultis);
+		assert(cs->multis != NULL);
 }
 */
 
@@ -1298,7 +1371,7 @@ mcin(cs, cp)
 register cset *cs;
 register char *cp;
 {
-	return(mcfind(cs, cp) != NULL);
+		return(mcfind(cs, cp) != NULL);
 }
 */
 
@@ -1312,14 +1385,14 @@ mcfind(cs, cp)
 register cset *cs;
 register char *cp;
 {
-	register char *p;
+		register char *p;
 
-	if (cs->multis == NULL)
+		if (cs->multis == NULL)
+				return(NULL);
+		for (p = cs->multis; *p != '\0'; p += strlen(p) + 1)
+				if (strcmp(cp, p) == 0)
+						return(p);
 		return(NULL);
-	for (p = cs->multis; *p != '\0'; p += strlen(p) + 1)
-		if (strcmp(cp, p) == 0)
-			return(p);
-	return(NULL);
 }
 */
 /*
@@ -1332,9 +1405,9 @@ register char *cp;
 static void
 mcinvert(p, cs)
 register struct parse *p;
-register cset *cs;
+register cset  *cs;
 {
-	assert(cs->multis == NULL);	/* xxx */
+	assert(cs->multis == NULL); /* xxx */
 }
 
 /*
@@ -1347,51 +1420,51 @@ register cset *cs;
 static void
 mccase(p, cs)
 register struct parse *p;
-register cset *cs;
+register cset  *cs;
 {
-	assert(cs->multis == NULL);	/* xxx */
+	assert(cs->multis == NULL); /* xxx */
 }
 
 /*
  - isinsets - is this character in any sets?
  == static int isinsets(register struct re_guts *g, int c);
  */
-static int			/* predicate */
+static int						/* predicate */
 isinsets(g, c)
 register struct re_guts *g;
-int c;
+int				c;
 {
-	register uch *col;
-	register int i;
-	register int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
-	register unsigned uc = (unsigned char)c;
+	register uch   *col;
+	register int	i;
+	register int	ncols = (g->ncsets + (CHAR_BIT - 1)) / CHAR_BIT;
+	register unsigned uc = (unsigned char) c;
 
 	for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
 		if (col[uc] != 0)
-			return(1);
-	return(0);
+			return (1);
+	return (0);
 }
 
 /*
  - samesets - are these two characters in exactly the same sets?
  == static int samesets(register struct re_guts *g, int c1, int c2);
  */
-static int			/* predicate */
+static int						/* predicate */
 samesets(g, c1, c2)
 register struct re_guts *g;
-int c1;
-int c2;
+int				c1;
+int				c2;
 {
-	register uch *col;
-	register int i;
-	register int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
-	register unsigned uc1 = (unsigned char)c1;
-	register unsigned uc2 = (unsigned char)c2;
+	register uch   *col;
+	register int	i;
+	register int	ncols = (g->ncsets + (CHAR_BIT - 1)) / CHAR_BIT;
+	register unsigned uc1 = (unsigned char) c1;
+	register unsigned uc2 = (unsigned char) c2;
 
 	for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
 		if (col[uc1] != col[uc2])
-			return(0);
-	return(1);
+			return (0);
+	return (1);
 }
 
 /*
@@ -1400,23 +1473,24 @@ int c2;
  */
 static void
 categorize(p, g)
-struct parse *p;
+struct parse   *p;
 register struct re_guts *g;
 {
 	register cat_t *cats = g->categories;
-	register int c;
-	register int c2;
-	register cat_t cat;
+	register int	c;
+	register int	c2;
+	register cat_t	cat;
 
 	/* avoid making error situations worse */
 	if (p->error != 0)
 		return;
 
 	for (c = CHAR_MIN; c <= CHAR_MAX; c++)
-		if (cats[c] == 0 && isinsets(g, c)) {
+		if (cats[c] == 0 && isinsets(g, c))
+		{
 			cat = g->ncategories++;
 			cats[c] = cat;
-			for (c2 = c+1; c2 <= CHAR_MAX; c2++)
+			for (c2 = c + 1; c2 <= CHAR_MAX; c2++)
 				if (cats[c2] == 0 && samesets(g, c, c2))
 					cats[c2] = cat;
 		}
@@ -1426,24 +1500,24 @@ register struct re_guts *g;
  - dupl - emit a duplicate of a bunch of sops
  == static sopno dupl(register struct parse *p, sopno start, sopno finish);
  */
-static sopno			/* start of duplicate */
+static			sopno			/* start of duplicate */
 dupl(p, start, finish)
 register struct parse *p;
-sopno start;			/* from here */
-sopno finish;			/* to this less one */
+sopno			start;			/* from here */
+sopno			finish;			/* to this less one */
 {
-	register sopno ret = HERE();
-	register sopno len = finish - start;
+	register sopno	ret = HERE();
+	register sopno	len = finish - start;
 
 	assert(finish >= start);
 	if (len == 0)
-		return(ret);
-	enlarge(p, p->ssize + len);	/* this many unexpected additions */
+		return (ret);
+	enlarge(p, p->ssize + len); /* this many unexpected additions */
 	assert(p->ssize >= p->slen + len);
-	memcpy((char *)(p->strip + p->slen),
-		(char *)(p->strip + start), (size_t)len*sizeof(sop));
+	memcpy((char *) (p->strip + p->slen),
+		   (char *) (p->strip + start), (size_t) len * sizeof(sop));
 	p->slen += len;
-	return(ret);
+	return (ret);
 }
 
 /*
@@ -1457,19 +1531,19 @@ sopno finish;			/* to this less one */
 static void
 doemit(p, op, opnd)
 register struct parse *p;
-sop op;
-size_t opnd;
+sop				op;
+size_t			opnd;
 {
 	/* avoid making error situations worse */
 	if (p->error != 0)
 		return;
 
 	/* deal with oversize operands ("can't happen", more or less) */
-	assert(opnd < 1<<OPSHIFT);
+	assert(opnd < 1 << OPSHIFT);
 
 	/* deal with undersized strip */
 	if (p->slen >= p->ssize)
-		enlarge(p, (p->ssize+1) / 2 * 3);	/* +50% */
+		enlarge(p, (p->ssize + 1) / 2 * 3);		/* +50% */
 	assert(p->slen < p->ssize);
 
 	/* finally, it's all reduced to the easy case */
@@ -1483,36 +1557,39 @@ size_t opnd;
 static void
 doinsert(p, op, opnd, pos)
 register struct parse *p;
-sop op;
-size_t opnd;
-sopno pos;
+sop				op;
+size_t			opnd;
+sopno			pos;
 {
-	register sopno sn;
-	register sop s;
-	register int i;
+	register sopno	sn;
+	register sop	s;
+	register int	i;
 
 	/* avoid making error situations worse */
 	if (p->error != 0)
 		return;
 
 	sn = HERE();
-	EMIT(op, opnd);		/* do checks, ensure space */
-	assert(HERE() == sn+1);
+	EMIT(op, opnd);				/* do checks, ensure space */
+	assert(HERE() == sn + 1);
 	s = p->strip[sn];
 
 	/* adjust paren pointers */
 	assert(pos > 0);
-	for (i = 1; i < NPAREN; i++) {
-		if (p->pbegin[i] >= pos) {
+	for (i = 1; i < NPAREN; i++)
+	{
+		if (p->pbegin[i] >= pos)
+		{
 			p->pbegin[i]++;
 		}
-		if (p->pend[i] >= pos) {
+		if (p->pend[i] >= pos)
+		{
 			p->pend[i]++;
 		}
 	}
 
-	memmove((char *)&p->strip[pos+1], (char *)&p->strip[pos],
-						(HERE()-pos-1)*sizeof(sop));
+	memmove((char *) &p->strip[pos + 1], (char *) &p->strip[pos],
+			(HERE() - pos - 1) * sizeof(sop));
 	p->strip[pos] = s;
 }
 
@@ -1523,14 +1600,14 @@ sopno pos;
 static void
 dofwd(p, pos, value)
 register struct parse *p;
-register sopno pos;
-sop value;
+register sopno	pos;
+sop				value;
 {
 	/* avoid making error situations worse */
 	if (p->error != 0)
 		return;
 
-	assert(value < 1<<OPSHIFT);
+	assert(value < 1 << OPSHIFT);
 	p->strip[pos] = OP(p->strip[pos]) | value;
 }
 
@@ -1541,15 +1618,16 @@ sop value;
 static void
 enlarge(p, size)
 register struct parse *p;
-register sopno size;
+register sopno	size;
 {
-	register sop *sp;
+	register sop   *sp;
 
 	if (p->ssize >= size)
 		return;
 
-	sp = (sop *)realloc(p->strip, size*sizeof(sop));
-	if (sp == NULL) {
+	sp = (sop *) realloc(p->strip, size * sizeof(sop));
+	if (sp == NULL)
+	{
 		SETERROR(REG_ESPACE);
 		return;
 	}
@@ -1567,8 +1645,9 @@ register struct parse *p;
 register struct re_guts *g;
 {
 	g->nstates = p->slen;
-	g->strip = (sop *)realloc((char *)p->strip, p->slen * sizeof(sop));
-	if (g->strip == NULL) {
+	g->strip = (sop *) realloc((char *) p->strip, p->slen * sizeof(sop));
+	if (g->strip == NULL)
+	{
 		SETERROR(REG_ESPACE);
 		g->strip = p->strip;
 	}
@@ -1586,16 +1665,16 @@ register struct re_guts *g;
  */
 static void
 findmust(p, g)
-struct parse *p;
+struct parse   *p;
 register struct re_guts *g;
 {
-	register sop *scan;
-	sop *start = 0;
-	register sop *newstart = 0;
-	register sopno newlen;
-	register sop s;
-	register char *cp;
-	register sopno i;
+	register sop   *scan;
+	sop			   *start = 0;
+	register sop   *newstart = 0;
+	register sopno	newlen;
+	register sop	s;
+	register char  *cp;
+	register sopno	i;
 
 	/* avoid making error situations worse */
 	if (p->error != 0)
@@ -1604,34 +1683,39 @@ register struct re_guts *g;
 	/* find the longest OCHAR sequence in strip */
 	newlen = 0;
 	scan = g->strip + 1;
-	do {
+	do
+	{
 		s = *scan++;
-		switch (OP(s)) {
-		case OCHAR:		/* sequence member */
-			if (newlen == 0)		/* new sequence */
+		switch (OP(s))
+		{
+		case OCHAR:				/* sequence member */
+			if (newlen == 0)	/* new sequence */
 				newstart = scan - 1;
 			newlen++;
 			break;
-		case OPLUS_:		/* things that don't break one */
+		case OPLUS_:			/* things that don't break one */
 		case OLPAREN:
 		case ORPAREN:
 			break;
-		case OQUEST_:		/* things that must be skipped */
+		case OQUEST_:			/* things that must be skipped */
 		case OCH_:
 			scan--;
-			do {
+			do
+			{
 				scan += OPND(s);
 				s = *scan;
 				/* assert() interferes w debug printouts */
 				if (OP(s) != O_QUEST && OP(s) != O_CH &&
-							OP(s) != OOR2) {
+					OP(s) != OOR2)
+				{
 					g->iflags |= BAD;
 					return;
 				}
 			} while (OP(s) != O_QUEST && OP(s) != O_CH);
 			/* fallthrough */
-		default:		/* things that break a sequence */
-			if (newlen > g->mlen) {		/* ends one */
+		default:				/* things that break a sequence */
+			if (newlen > g->mlen)
+			{					/* ends one */
 				start = newstart;
 				g->mlen = newlen;
 			}
@@ -1640,48 +1724,52 @@ register struct re_guts *g;
 		}
 	} while (OP(s) != OEND);
 
-	if (g->mlen == 0)		/* there isn't one */
+	if (g->mlen == 0)			/* there isn't one */
 		return;
 
 	/* turn it into a character string */
-	g->must = malloc((size_t)g->mlen + 1);
-	if (g->must == NULL) {		/* argh; just forget it */
+	g->must = malloc((size_t) g->mlen + 1);
+	if (g->must == NULL)
+	{							/* argh; just forget it */
 		g->mlen = 0;
 		return;
 	}
 	cp = g->must;
 	scan = start;
-	for (i = g->mlen; i > 0; i--) {
+	for (i = g->mlen; i > 0; i--)
+	{
 		while (OP(s = *scan++) != OCHAR)
 			continue;
 		assert(cp < g->must + g->mlen);
-		*cp++ = (char)OPND(s);
+		*cp++ = (char) OPND(s);
 	}
 	assert(cp == g->must + g->mlen);
-	*cp++ = '\0';		/* just on general principles */
+	*cp++ = '\0';				/* just on general principles */
 }
 
 /*
  - pluscount - count + nesting
  == static sopno pluscount(register struct parse *p, register struct re_guts *g);
  */
-static sopno			/* nesting depth */
+static			sopno			/* nesting depth */
 pluscount(p, g)
-struct parse *p;
+struct parse   *p;
 register struct re_guts *g;
 {
-	register sop *scan;
-	register sop s;
-	register sopno plusnest = 0;
-	register sopno maxnest = 0;
+	register sop   *scan;
+	register sop	s;
+	register sopno	plusnest = 0;
+	register sopno	maxnest = 0;
 
 	if (p->error != 0)
-		return(0);	/* there may not be an OEND */
+		return (0);				/* there may not be an OEND */
 
 	scan = g->strip + 1;
-	do {
+	do
+	{
 		s = *scan++;
-		switch (OP(s)) {
+		switch (OP(s))
+		{
 		case OPLUS_:
 			plusnest++;
 			break;
@@ -1694,5 +1782,5 @@ register struct re_guts *g;
 	} while (OP(s) != OEND);
 	if (plusnest != 0)
 		g->iflags |= BAD;
-	return(maxnest);
+	return (maxnest);
 }
diff --git a/src/backend/regex/regerror.c b/src/backend/regex/regerror.c
index 7d1d06cbc90..9e6e0e02179 100644
--- a/src/backend/regex/regerror.c
+++ b/src/backend/regex/regerror.c
@@ -1,7 +1,7 @@
 /*-
  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  * Copyright (c) 1992, 1993, 1994
- *	The Regents of the University of California.  All rights reserved.
+ *		The Regents of the University of California.  All rights reserved.
  *
  * This code is derived from software contributed to Berkeley by
  * Henry Spencer.
@@ -10,22 +10,22 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
+ *	  must display the following acknowledgement:
+ *		This product includes software developed by the University of
+ *		California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
+ *	  may be used to endorse or promote products derived from this software
+ *	  without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -34,12 +34,13 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	@(#)regerror.c	8.4 (Berkeley) 3/20/94
+ *		@(#)regerror.c	8.4 (Berkeley) 3/20/94
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char sccsid[] = "@(#)regerror.c	8.4 (Berkeley) 3/20/94";
-#endif /* LIBC_SCCS and not lint */
+static char		sccsid[] = "@(#)regerror.c	8.4 (Berkeley) 3/20/94";
+
+#endif							/* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
 #include <stdio.h>
@@ -54,58 +55,97 @@ static char sccsid[] = "@(#)regerror.c	8.4 (Berkeley) 3/20/94";
 
 /* ========= begin header generated by ./mkh ========= */
 #ifdef __cplusplus
-extern "C" {
+extern			"C"
+{
 #endif
 
 /* === regerror.c === */
-static char *regatoi(const regex_t *preg, char *localbuf);
+	static char    *regatoi(const regex_t * preg, char *localbuf);
 
 #ifdef __cplusplus
 }
+
 #endif
 /* ========= end header generated by ./mkh ========= */
 /*
- = #define	REG_NOMATCH	 1
- = #define	REG_BADPAT	 2
- = #define	REG_ECOLLATE	 3
- = #define	REG_ECTYPE	 4
- = #define	REG_EESCAPE	 5
- = #define	REG_ESUBREG	 6
- = #define	REG_EBRACK	 7
- = #define	REG_EPAREN	 8
- = #define	REG_EBRACE	 9
- = #define	REG_BADBR	10
- = #define	REG_ERANGE	11
- = #define	REG_ESPACE	12
- = #define	REG_BADRPT	13
- = #define	REG_EMPTY	14
- = #define	REG_ASSERT	15
- = #define	REG_INVARG	16
- = #define	REG_ATOI	255	// convert name to number (!)
- = #define	REG_ITOA	0400	// convert number to name (!)
+ = #define		REG_NOMATCH		 1
+ = #define		REG_BADPAT		 2
+ = #define		REG_ECOLLATE	 3
+ = #define		REG_ECTYPE		 4
+ = #define		REG_EESCAPE		 5
+ = #define		REG_ESUBREG		 6
+ = #define		REG_EBRACK		 7
+ = #define		REG_EPAREN		 8
+ = #define		REG_EBRACE		 9
+ = #define		REG_BADBR		10
+ = #define		REG_ERANGE		11
+ = #define		REG_ESPACE		12
+ = #define		REG_BADRPT		13
+ = #define		REG_EMPTY		14
+ = #define		REG_ASSERT		15
+ = #define		REG_INVARG		16
+ = #define		REG_ATOI		255		// convert name to number (!)
+ = #define		REG_ITOA		0400	// convert number to name (!)
  */
-static struct rerr {
-	int code;
-	char *name;
-	char *explain;
-} rerrs[] = {
-	{REG_NOMATCH,	"REG_NOMATCH",	"regexec() failed to match"},
-	{REG_BADPAT,	"REG_BADPAT",	"invalid regular expression"},
-	{REG_ECOLLATE,	"REG_ECOLLATE",	"invalid collating element"},
-	{REG_ECTYPE,	"REG_ECTYPE",	"invalid character class"},
-	{REG_EESCAPE,	"REG_EESCAPE",	"trailing backslash (\\)"},
-	{REG_ESUBREG,	"REG_ESUBREG",	"invalid backreference number"},
-	{REG_EBRACK,	"REG_EBRACK",	"brackets ([ ]) not balanced"},
-	{REG_EPAREN,	"REG_EPAREN",	"parentheses not balanced"},
-	{REG_EBRACE,	"REG_EBRACE",	"braces not balanced"},
-	{REG_BADBR,	"REG_BADBR",	"invalid repetition count(s)"},
-	{REG_ERANGE,	"REG_ERANGE",	"invalid character range"},
-	{REG_ESPACE,	"REG_ESPACE",	"out of memory"},
-	{REG_BADRPT,	"REG_BADRPT",	"repetition-operator operand invalid"},
-	{REG_EMPTY,	"REG_EMPTY",	"empty (sub)expression"},
-	{REG_ASSERT,	"REG_ASSERT",	"\"can't happen\" -- you found a bug"},
-	{REG_INVARG,	"REG_INVARG",	"invalid argument to regex routine"},
-	{0,		"",		"*** unknown regexp error code ***"}
+static struct rerr
+{
+	int				code;
+	char		   *name;
+	char		   *explain;
+}				rerrs[] =
+
+{
+	{
+		REG_NOMATCH, "REG_NOMATCH", "regexec() failed to match"
+	},
+	{
+		REG_BADPAT, "REG_BADPAT", "invalid regular expression"
+	},
+	{
+		REG_ECOLLATE, "REG_ECOLLATE", "invalid collating element"
+	},
+	{
+		REG_ECTYPE, "REG_ECTYPE", "invalid character class"
+	},
+	{
+		REG_EESCAPE, "REG_EESCAPE", "trailing backslash (\\)"
+	},
+	{
+		REG_ESUBREG, "REG_ESUBREG", "invalid backreference number"
+	},
+	{
+		REG_EBRACK, "REG_EBRACK", "brackets ([ ]) not balanced"
+	},
+	{
+		REG_EPAREN, "REG_EPAREN", "parentheses not balanced"
+	},
+	{
+		REG_EBRACE, "REG_EBRACE", "braces not balanced"
+	},
+	{
+		REG_BADBR, "REG_BADBR", "invalid repetition count(s)"
+	},
+	{
+		REG_ERANGE, "REG_ERANGE", "invalid character range"
+	},
+	{
+		REG_ESPACE, "REG_ESPACE", "out of memory"
+	},
+	{
+		REG_BADRPT, "REG_BADRPT", "repetition-operator operand invalid"
+	},
+	{
+		REG_EMPTY, "REG_EMPTY", "empty (sub)expression"
+	},
+	{
+		REG_ASSERT, "REG_ASSERT", "\"can't happen\" -- you found a bug"
+	},
+	{
+		REG_INVARG, "REG_INVARG", "invalid argument to regex routine"
+	},
+	{
+		0, "", "*** unknown regexp error code ***"
+	}
 };
 
 /*
@@ -115,56 +155,61 @@ static struct rerr {
 /* ARGSUSED */
 size_t
 pg95_regerror(errcode, preg, errbuf, errbuf_size)
-int errcode;
-const regex_t *preg;
-char *errbuf;
-size_t errbuf_size;
+int				errcode;
+const regex_t  *preg;
+char		   *errbuf;
+size_t			errbuf_size;
 {
 	register struct rerr *r;
 	register size_t len;
-	register int target = errcode &~ REG_ITOA;
-	register char *s;
-	char convbuf[50];
+	register int	target = errcode & ~REG_ITOA;
+	register char  *s;
+	char			convbuf[50];
 
 	if (errcode == REG_ATOI)
 		s = regatoi(preg, convbuf);
-	else {
+	else
+	{
 		for (r = rerrs; r->code != 0; r++)
 			if (r->code == target)
 				break;
-	
-		if (errcode&REG_ITOA) {
+
+		if (errcode & REG_ITOA)
+		{
 			if (r->code != 0)
 				strcpy(convbuf, r->name);
 			else
 				sprintf(convbuf, "REG_0x%x", target);
 			assert(strlen(convbuf) < sizeof(convbuf));
 			s = convbuf;
-		} else
+		}
+		else
 			s = r->explain;
 	}
 
 	len = strlen(s) + 1;
-	if (errbuf_size > 0) {
+	if (errbuf_size > 0)
+	{
 		if (errbuf_size > len)
 			strcpy(errbuf, s);
-		else {
-			strncpy(errbuf, s, errbuf_size-1);
-			errbuf[errbuf_size-1] = '\0';
+		else
+		{
+			strncpy(errbuf, s, errbuf_size - 1);
+			errbuf[errbuf_size - 1] = '\0';
 		}
 	}
 
-	return(len);
+	return (len);
 }
 
 /*
  - regatoi - internal routine to implement REG_ATOI
  == static char *regatoi(const regex_t *preg, char *localbuf);
  */
-static char *
+static char    *
 regatoi(preg, localbuf)
-const regex_t *preg;
-char *localbuf;
+const regex_t  *preg;
+char		   *localbuf;
 {
 	register struct rerr *r;
 
@@ -172,8 +217,8 @@ char *localbuf;
 		if (strcmp(r->name, preg->re_endp) == 0)
 			break;
 	if (r->code == 0)
-		return("0");
+		return ("0");
 
 	sprintf(localbuf, "%d", r->code);
-	return(localbuf);
+	return (localbuf);
 }
diff --git a/src/backend/regex/regexec.c b/src/backend/regex/regexec.c
index 115a17667bb..5e0021f4299 100644
--- a/src/backend/regex/regexec.c
+++ b/src/backend/regex/regexec.c
@@ -1,7 +1,7 @@
 /*-
  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  * Copyright (c) 1992, 1993, 1994
- *	The Regents of the University of California.  All rights reserved.
+ *		The Regents of the University of California.  All rights reserved.
  *
  * This code is derived from software contributed to Berkeley by
  * Henry Spencer.
@@ -10,22 +10,22 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
+ *	  must display the following acknowledgement:
+ *		This product includes software developed by the University of
+ *		California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
+ *	  may be used to endorse or promote products derived from this software
+ *	  without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -34,12 +34,13 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	@(#)regexec.c	8.3 (Berkeley) 3/20/94
+ *		@(#)regexec.c	8.3 (Berkeley) 3/20/94
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char sccsid[] = "@(#)regexec.c	8.3 (Berkeley) 3/20/94";
-#endif /* LIBC_SCCS and not lint */
+static char		sccsid[] = "@(#)regexec.c	8.3 (Berkeley) 3/20/94";
+
+#endif							/* LIBC_SCCS and not lint */
 
 /*
  * the outer shell of regexec()
@@ -60,32 +61,32 @@ static char sccsid[] = "@(#)regexec.c	8.3 (Berkeley) 3/20/94";
 #include <regex/utils.h>
 #include <regex/regex2.h>
 
-static int nope = 0;		/* for use in asserts; shuts lint up */
+static int		nope = 0;		/* for use in asserts; shuts lint up */
 
 /* macros for manipulating states, small version */
-#define	states	long
-#define	states1	states		/* for later use in regexec() decision */
-#define	CLEAR(v)	((v) = 0)
-#define	SET0(v, n)	((v) &= ~(1 << (n)))
-#define	SET1(v, n)	((v) |= 1 << (n))
-#define	ISSET(v, n)	((v) & (1 << (n)))
-#define	ASSIGN(d, s)	((d) = (s))
-#define	EQ(a, b)	((a) == (b))
-#define	STATEVARS	int dummy	/* dummy version */
-#define	STATESETUP(m, n)	/* nothing */
-#define	STATETEARDOWN(m)	/* nothing */
-#define	SETUP(v)	((v) = 0)
-#define	onestate	int
-#define	INIT(o, n)	((o) = (unsigned)1 << (n))
-#define	INC(o)	((o) <<= 1)
-#define	ISSTATEIN(v, o)	((v) & (o))
+#define states	long
+#define states1 states			/* for later use in regexec() decision */
+#define CLEAR(v)		((v) = 0)
+#define SET0(v, n)		((v) &= ~(1 << (n)))
+#define SET1(v, n)		((v) |= 1 << (n))
+#define ISSET(v, n)		((v) & (1 << (n)))
+#define ASSIGN(d, s)	((d) = (s))
+#define EQ(a, b)		((a) == (b))
+#define STATEVARS		int dummy		/* dummy version */
+#define STATESETUP(m, n)		/* nothing */
+#define STATETEARDOWN(m)		/* nothing */
+#define SETUP(v)		((v) = 0)
+#define onestate		int
+#define INIT(o, n)		((o) = (unsigned)1 << (n))
+#define INC(o)	((o) <<= 1)
+#define ISSTATEIN(v, o) ((v) & (o))
 /* some abbreviations; note that some of these know variable names! */
 /* do "if I'm here, I can also be there" etc without branches */
-#define	FWD(dst, src, n)	((dst) |= ((unsigned)(src)&(here)) << (n))
-#define	BACK(dst, src, n)	((dst) |= ((unsigned)(src)&(here)) >> (n))
-#define	ISSETBACK(v, n)	((v) & ((unsigned)here >> (n)))
+#define FWD(dst, src, n)		((dst) |= ((unsigned)(src)&(here)) << (n))
+#define BACK(dst, src, n)		((dst) |= ((unsigned)(src)&(here)) >> (n))
+#define ISSETBACK(v, n) ((v) & ((unsigned)here >> (n)))
 /* function names */
-#define SNAMES			/* engine.c looks after details */
+#define SNAMES					/* engine.c looks after details */
 
 #include "engine.c"
 
@@ -111,72 +112,73 @@ static int nope = 0;		/* for use in asserts; shuts lint up */
 #undef	SNAMES
 
 /* macros for manipulating states, large version */
-#define	states	char *
-#define	CLEAR(v)	memset(v, 0, m->g->nstates)
-#define	SET0(v, n)	((v)[n] = 0)
-#define	SET1(v, n)	((v)[n] = 1)
-#define	ISSET(v, n)	((v)[n])
-#define	ASSIGN(d, s)	memcpy(d, s, m->g->nstates)
-#define	EQ(a, b)	(memcmp(a, b, m->g->nstates) == 0)
-#define	STATEVARS	int vn; char *space
-#define	STATESETUP(m, nv)	{ (m)->space = malloc((nv)*(m)->g->nstates); \
-				if ((m)->space == NULL) return(REG_ESPACE); \
-				(m)->vn = 0; }
-#define	STATETEARDOWN(m)	{ free((m)->space); }
-#define	SETUP(v)	((v) = &m->space[m->vn++ * m->g->nstates])
-#define	onestate	int
-#define	INIT(o, n)	((o) = (n))
-#define	INC(o)	((o)++)
-#define	ISSTATEIN(v, o)	((v)[o])
+#define states	char *
+#define CLEAR(v)		memset(v, 0, m->g->nstates)
+#define SET0(v, n)		((v)[n] = 0)
+#define SET1(v, n)		((v)[n] = 1)
+#define ISSET(v, n)		((v)[n])
+#define ASSIGN(d, s)	memcpy(d, s, m->g->nstates)
+#define EQ(a, b)		(memcmp(a, b, m->g->nstates) == 0)
+#define STATEVARS		int vn; char *space
+#define STATESETUP(m, nv)		{ (m)->space = malloc((nv)*(m)->g->nstates); \
+								if ((m)->space == NULL) return(REG_ESPACE); \
+								(m)->vn = 0; }
+#define STATETEARDOWN(m)		{ free((m)->space); }
+#define SETUP(v)		((v) = &m->space[m->vn++ * m->g->nstates])
+#define onestate		int
+#define INIT(o, n)		((o) = (n))
+#define INC(o)	((o)++)
+#define ISSTATEIN(v, o) ((v)[o])
 /* some abbreviations; note that some of these know variable names! */
 /* do "if I'm here, I can also be there" etc without branches */
-#define	FWD(dst, src, n)	((dst)[here+(n)] |= (src)[here])
-#define	BACK(dst, src, n)	((dst)[here-(n)] |= (src)[here])
-#define	ISSETBACK(v, n)	((v)[here - (n)])
+#define FWD(dst, src, n)		((dst)[here+(n)] |= (src)[here])
+#define BACK(dst, src, n)		((dst)[here-(n)] |= (src)[here])
+#define ISSETBACK(v, n) ((v)[here - (n)])
 /* function names */
-#define	LNAMES			/* flag */
+#define LNAMES					/* flag */
 
 #include "engine.c"
 
 /*
  - regexec - interface for matching
  = extern int regexec(const regex_t *, const char *, size_t, \
- =					regmatch_t [], int);
- = #define	REG_NOTBOL	00001
- = #define	REG_NOTEOL	00002
- = #define	REG_STARTEND	00004
- = #define	REG_TRACE	00400	// tracing of execution
- = #define	REG_LARGE	01000	// force large representation
- = #define	REG_BACKR	02000	// force use of backref code
+ =										regmatch_t [], int);
+ = #define		REG_NOTBOL		00001
+ = #define		REG_NOTEOL		00002
+ = #define		REG_STARTEND	00004
+ = #define		REG_TRACE		00400	// tracing of execution
+ = #define		REG_LARGE		01000	// force large representation
+ = #define		REG_BACKR		02000	// force use of backref code
  *
  * We put this here so we can exploit knowledge of the state representation
  * when choosing which matcher to call.  Also, by this point the matchers
  * have been prototyped.
  */
-int				/* 0 success, REG_NOMATCH failure */
+int								/* 0 success, REG_NOMATCH failure */
 pg95_regexec(preg, string, nmatch, pmatch, eflags)
-const regex_t *preg;
-const char *string;
-size_t nmatch;
-regmatch_t pmatch[];
-int eflags;
+const regex_t  *preg;
+const char	   *string;
+size_t			nmatch;
+regmatch_t		pmatch[];
+int				eflags;
 {
 	register struct re_guts *g = preg->re_g;
+
 #ifdef REDEBUG
-#	define	GOODFLAGS(f)	(f)
+#define  GOODFLAGS(f)	 (f)
 #else
-#	define	GOODFLAGS(f)	((f)&(REG_NOTBOL|REG_NOTEOL|REG_STARTEND))
+#define  GOODFLAGS(f)	 ((f)&(REG_NOTBOL|REG_NOTEOL|REG_STARTEND))
 #endif
 
 	if (preg->re_magic != MAGIC1 || g->magic != MAGIC2)
-		return(REG_BADPAT);
-	assert(!(g->iflags&BAD));
-	if (g->iflags&BAD)		/* backstop for no-debug case */
-		return(REG_BADPAT);
+		return (REG_BADPAT);
+	assert(!(g->iflags & BAD));
+	if (g->iflags & BAD)		/* backstop for no-debug case */
+		return (REG_BADPAT);
 	eflags = GOODFLAGS(eflags);
 
-	if (g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags&REG_LARGE))
-		return(smatcher(g, (char *)string, nmatch, pmatch, eflags));
+	if (g->nstates <= CHAR_BIT * sizeof(states1) && !(eflags & REG_LARGE))
+		return (smatcher(g, (char *) string, nmatch, pmatch, eflags));
 	else
-		return(lmatcher(g, (char *)string, nmatch, pmatch, eflags));
+		return (lmatcher(g, (char *) string, nmatch, pmatch, eflags));
 }
diff --git a/src/backend/regex/regfree.c b/src/backend/regex/regfree.c
index 9a7ff5cb5e1..26ca8863ed6 100644
--- a/src/backend/regex/regfree.c
+++ b/src/backend/regex/regfree.c
@@ -1,7 +1,7 @@
 /*-
  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  * Copyright (c) 1992, 1993, 1994
- *	The Regents of the University of California.  All rights reserved.
+ *		The Regents of the University of California.  All rights reserved.
  *
  * This code is derived from software contributed to Berkeley by
  * Henry Spencer.
@@ -10,22 +10,22 @@
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
+ *	  notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
+ *	  must display the following acknowledgement:
+ *		This product includes software developed by the University of
+ *		California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
+ *	  may be used to endorse or promote products derived from this software
+ *	  without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED.	IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -34,12 +34,13 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	@(#)regfree.c	8.3 (Berkeley) 3/20/94
+ *		@(#)regfree.c	8.3 (Berkeley) 3/20/94
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char sccsid[] = "@(#)regfree.c	8.3 (Berkeley) 3/20/94";
-#endif /* LIBC_SCCS and not lint */
+static char		sccsid[] = "@(#)regfree.c	8.3 (Berkeley) 3/20/94";
+
+#endif							/* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
 #include <stdio.h>
@@ -55,26 +56,26 @@ static char sccsid[] = "@(#)regfree.c	8.3 (Berkeley) 3/20/94";
  */
 void
 pg95_regfree(preg)
-regex_t *preg;
+regex_t		   *preg;
 {
 	register struct re_guts *g;
 
-	if (preg->re_magic != MAGIC1)	/* oops */
-		return;			/* nice to complain, but hard */
+	if (preg->re_magic != MAGIC1)		/* oops */
+		return;					/* nice to complain, but hard */
 
 	g = preg->re_g;
-	if (g == NULL || g->magic != MAGIC2)	/* oops again */
+	if (g == NULL || g->magic != MAGIC2)		/* oops again */
 		return;
-	preg->re_magic = 0;		/* mark it invalid */
-	g->magic = 0;			/* mark it invalid */
+	preg->re_magic = 0;			/* mark it invalid */
+	g->magic = 0;				/* mark it invalid */
 
 	if (g->strip != NULL)
-		free((char *)g->strip);
+		free((char *) g->strip);
 	if (g->sets != NULL)
-		free((char *)g->sets);
+		free((char *) g->sets);
 	if (g->setbits != NULL)
-		free((char *)g->setbits);
+		free((char *) g->setbits);
 	if (g->must != NULL)
 		free(g->must);
-	free((char *)g);
+	free((char *) g);
 }