Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.

5 files changed, 1023 insertions, 1022 deletions

diff --git a/src/backend/regex/engine.c b/src/backend/regex/engine.c
index 6e0e7012140..1d86dcc7bd9 100644
--- a/src/backend/regex/engine.c
+++ b/src/backend/regex/engine.c
@@ -71,43 +71,43 @@
 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,
+				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,
+	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)
@@ -120,16 +120,16 @@ extern			"C"
 #define NNONCHAR		(CODEMAX-CHAR_MAX)
 #ifdef REDEBUG
 	static void
-					print(struct match * m, char *caption, states st, int ch, FILE * d);
+				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);
+				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
@@ -156,20 +156,20 @@ extern			"C"
 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 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)
@@ -336,27 +336,27 @@ int				eflags;
  == static char *dissect(register struct match *m, char *start, \
  ==		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;
@@ -366,164 +366,164 @@ sopno			stopst;
 		es = ss;
 		switch (OP(m->g->strip[es]))
 		{
-		case OPLUS_:
-		case OQUEST_:
-			es += OPND(m->g->strip[es]);
-			break;
-		case OCH_:
-			while (OP(m->g->strip[es]) != O_CH)
+			case OPLUS_:
+			case OQUEST_:
 				es += OPND(m->g->strip[es]);
-			break;
+				break;
+			case OCH_:
+				while (OP(m->g->strip[es]) != O_CH)
+					es += OPND(m->g->strip[es]);
+				break;
 		}
 		es++;
 
 		/* figure out what it matched */
 		switch (OP(m->g->strip[ss]))
 		{
-		case OEND:
-			assert(nope);
-			break;
-		case OCHAR:
-			sp++;
-			break;
-		case OBOL:
-		case OEOL:
-		case OBOW:
-		case OEOW:
-			break;
-		case OANY:
-		case OANYOF:
-			sp++;
-			break;
-		case OBACK_:
-		case O_BACK:
-			assert(nope);
-			break;
-			/* cases where length of match is hard to find */
-		case OQUEST_:
-			stp = stop;
-			for (;;)
-			{
-				/* how long could this one be? */
-				rest = slow(m, sp, stp, ss, es);
-				assert(rest != NULL);	/* it did match */
-				/* could the rest match the rest? */
-				tail = slow(m, rest, stop, es, stopst);
-				if (tail == stop)
-					break;		/* yes! */
-				/* no -- try a shorter match for this one */
-				stp = rest - 1;
-				assert(stp >= sp);		/* it did work */
-			}
-			ssub = ss + 1;
-			esub = es - 1;
-			/* did innards match? */
-			if (slow(m, sp, rest, ssub, esub) != NULL)
-			{
-				dp = dissect(m, sp, rest, ssub, esub);
-				assert(dp == rest);
-			}
-			else
+			case OEND:
+				assert(nope);
+				break;
+			case OCHAR:
+				sp++;
+				break;
+			case OBOL:
+			case OEOL:
+			case OBOW:
+			case OEOW:
+				break;
+			case OANY:
+			case OANYOF:
+				sp++;
+				break;
+			case OBACK_:
+			case O_BACK:
+				assert(nope);
+				break;
+				/* cases where length of match is hard to find */
+			case OQUEST_:
+				stp = stop;
+				for (;;)
+				{
+					/* how long could this one be? */
+					rest = slow(m, sp, stp, ss, es);
+					assert(rest != NULL);		/* it did match */
+					/* could the rest match the rest? */
+					tail = slow(m, rest, stop, es, stopst);
+					if (tail == stop)
+						break;	/* yes! */
+					/* no -- try a shorter match for this one */
+					stp = rest - 1;
+					assert(stp >= sp);	/* it did work */
+				}
+				ssub = ss + 1;
+				esub = es - 1;
+				/* did innards match? */
+				if (slow(m, sp, rest, ssub, esub) != NULL)
+				{
+					dp = dissect(m, sp, rest, ssub, esub);
+					assert(dp == rest);
+				}
+				else
 /* no */
-				assert(sp == rest);
-			sp = rest;
-			break;
-		case OPLUS_:
-			stp = stop;
-			for (;;)
-			{
-				/* how long could this one be? */
-				rest = slow(m, sp, stp, ss, es);
-				assert(rest != NULL);	/* it did match */
-				/* could the rest match the rest? */
-				tail = slow(m, rest, stop, es, stopst);
-				if (tail == stop)
-					break;		/* yes! */
-				/* no -- try a shorter match for this one */
-				stp = rest - 1;
-				assert(stp >= sp);		/* it did work */
-			}
-			ssub = ss + 1;
-			esub = es - 1;
-			ssp = sp;
-			oldssp = ssp;
-			for (;;)
-			{					/* find last match of innards */
-				sep = slow(m, ssp, rest, ssub, esub);
-				if (sep == NULL || sep == ssp)
-					break;		/* failed or matched null */
-				oldssp = ssp;	/* on to next try */
-				ssp = sep;
-			}
-			if (sep == NULL)
-			{
-				/* last successful match */
-				sep = ssp;
-				ssp = oldssp;
-			}
-			assert(sep == rest);/* must exhaust substring */
-			assert(slow(m, ssp, sep, ssub, esub) == rest);
-			dp = dissect(m, ssp, sep, ssub, esub);
-			assert(dp == sep);
-			sp = rest;
-			break;
-		case OCH_:
-			stp = stop;
-			for (;;)
-			{
-				/* how long could this one be? */
-				rest = slow(m, sp, stp, ss, es);
-				assert(rest != NULL);	/* it did match */
-				/* could the rest match the rest? */
-				tail = slow(m, rest, stop, es, stopst);
-				if (tail == stop)
-					break;		/* yes! */
-				/* no -- try a shorter match for this one */
-				stp = rest - 1;
-				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 */
-				if (slow(m, sp, rest, ssub, esub) == rest)
-					break;		/* it matched all of it */
-				/* that one missed, try next one */
+					assert(sp == rest);
+				sp = rest;
+				break;
+			case OPLUS_:
+				stp = stop;
+				for (;;)
+				{
+					/* how long could this one be? */
+					rest = slow(m, sp, stp, ss, es);
+					assert(rest != NULL);		/* it did match */
+					/* could the rest match the rest? */
+					tail = slow(m, rest, stop, es, stopst);
+					if (tail == stop)
+						break;	/* yes! */
+					/* no -- try a shorter match for this one */
+					stp = rest - 1;
+					assert(stp >= sp);	/* it did work */
+				}
+				ssub = ss + 1;
+				esub = es - 1;
+				ssp = sp;
+				oldssp = ssp;
+				for (;;)
+				{				/* find last match of innards */
+					sep = slow(m, ssp, rest, ssub, esub);
+					if (sep == NULL || sep == ssp)
+						break;	/* failed or matched null */
+					oldssp = ssp;		/* on to next try */
+					ssp = sep;
+				}
+				if (sep == NULL)
+				{
+					/* last successful match */
+					sep = ssp;
+					ssp = oldssp;
+				}
+				assert(sep == rest);	/* must exhaust substring */
+				assert(slow(m, ssp, sep, ssub, esub) == rest);
+				dp = dissect(m, ssp, sep, ssub, esub);
+				assert(dp == sep);
+				sp = rest;
+				break;
+			case OCH_:
+				stp = stop;
+				for (;;)
+				{
+					/* how long could this one be? */
+					rest = slow(m, sp, stp, ss, es);
+					assert(rest != NULL);		/* it did match */
+					/* could the rest match the rest? */
+					tail = slow(m, rest, stop, es, stopst);
+					if (tail == stop)
+						break;	/* yes! */
+					/* no -- try a shorter match for this one */
+					stp = rest - 1;
+					assert(stp >= sp);	/* it did work */
+				}
+				ssub = ss + 1;
+				esub = ss + OPND(m->g->strip[ss]) - 1;
 				assert(OP(m->g->strip[esub]) == OOR1);
-				esub++;
-				assert(OP(m->g->strip[esub]) == OOR2);
-				ssub = esub + 1;
-				esub += OPND(m->g->strip[esub]);
-				if (OP(m->g->strip[esub]) == OOR2)
-					esub--;
-				else
-					assert(OP(m->g->strip[esub]) == O_CH);
-			}
-			dp = dissect(m, sp, rest, ssub, esub);
-			assert(dp == rest);
-			sp = rest;
-			break;
-		case O_PLUS:
-		case O_QUEST:
-		case OOR1:
-		case OOR2:
-		case O_CH:
-			assert(nope);
-			break;
-		case OLPAREN:
-			i = OPND(m->g->strip[ss]);
-			assert(0 < i && i <= m->g->nsub);
-			m->pmatch[i].rm_so = sp - m->offp;
-			break;
-		case ORPAREN:
-			i = OPND(m->g->strip[ss]);
-			assert(0 < i && i <= m->g->nsub);
-			m->pmatch[i].rm_eo = sp - m->offp;
-			break;
-		default:				/* uh oh */
-			assert(nope);
-			break;
+				for (;;)
+				{				/* find first matching branch */
+					if (slow(m, sp, rest, ssub, esub) == rest)
+						break;	/* it matched all of it */
+					/* that one missed, try next one */
+					assert(OP(m->g->strip[esub]) == OOR1);
+					esub++;
+					assert(OP(m->g->strip[esub]) == OOR2);
+					ssub = esub + 1;
+					esub += OPND(m->g->strip[esub]);
+					if (OP(m->g->strip[esub]) == OOR2)
+						esub--;
+					else
+						assert(OP(m->g->strip[esub]) == O_CH);
+				}
+				dp = dissect(m, sp, rest, ssub, esub);
+				assert(dp == rest);
+				sp = rest;
+				break;
+			case O_PLUS:
+			case O_QUEST:
+			case OOR1:
+			case OOR2:
+			case O_CH:
+				assert(nope);
+				break;
+			case OLPAREN:
+				i = OPND(m->g->strip[ss]);
+				assert(0 < i && i <= m->g->nsub);
+				m->pmatch[i].rm_so = sp - m->offp;
+				break;
+			case ORPAREN:
+				i = OPND(m->g->strip[ss]);
+				assert(0 < i && i <= m->g->nsub);
+				m->pmatch[i].rm_eo = sp - m->offp;
+				break;
+			default:			/* uh oh */
+				assert(nope);
+				break;
 		}
 	}
 
@@ -536,27 +536,27 @@ sopno			stopst;
  == static char *backref(register struct match *m, char *start, \
  ==		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;
@@ -566,76 +566,76 @@ sopno			lev;			/* PLUS nesting level */
 	for (ss = startst; !hard && ss < stopst; ss++)
 		switch (OP(s = m->g->strip[ss]))
 		{
-		case OCHAR:
-			if (sp == stop || *sp++ != (char) OPND(s))
-				return (NULL);
-			break;
-		case OANY:
-			if (sp == stop)
-				return (NULL);
-			sp++;
-			break;
-		case OANYOF:
-			cs = &m->g->sets[OPND(s)];
-			if (sp == stop || !CHIN(cs, *sp++))
-				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 */
-			}
-			else
-				return (NULL);
-			break;
-		case OEOL:
-			if ((sp == m->endp && !(m->eflags & REG_NOTEOL)) ||
-				(sp < m->endp && *sp == '\n' &&
-				 (m->g->cflags & REG_NEWLINE)))
-			{					/* yes */
-			}
-			else
-				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 */
-			}
-			else
-				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 */
-			}
-			else
-				return (NULL);
-			break;
-		case O_QUEST:
-			break;
-		case OOR1:				/* matches null but needs to skip */
-			ss++;
-			s = m->g->strip[ss];
-			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 */
-			hard = 1;
-			break;
+			case OCHAR:
+				if (sp == stop || *sp++ != (char) OPND(s))
+					return (NULL);
+				break;
+			case OANY:
+				if (sp == stop)
+					return (NULL);
+				sp++;
+				break;
+			case OANYOF:
+				cs = &m->g->sets[OPND(s)];
+				if (sp == stop || !CHIN(cs, *sp++))
+					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 */
+				}
+				else
+					return (NULL);
+				break;
+			case OEOL:
+				if ((sp == m->endp && !(m->eflags & REG_NOTEOL)) ||
+					(sp < m->endp && *sp == '\n' &&
+					 (m->g->cflags & REG_NEWLINE)))
+				{				/* yes */
+				}
+				else
+					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 */
+				}
+				else
+					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 */
+				}
+				else
+					return (NULL);
+				break;
+			case O_QUEST:
+				break;
+			case OOR1:			/* matches null but needs to skip */
+				ss++;
+				s = m->g->strip[ss];
+				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 */
+				hard = 1;
+				break;
 		}
 	if (!hard)
 	{							/* that was it! */
@@ -650,93 +650,93 @@ sopno			lev;			/* PLUS nesting level */
 	s = m->g->strip[ss];
 	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);
-		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 */
-		ssp = m->offp + m->pmatch[i].rm_so;
-		if (memcmp(sp, ssp, len) != 0)
+		case OBACK_:			/* the vilest depths */
+			i = OPND(s);
+			assert(0 < i && i <= m->g->nsub);
+			if (m->pmatch[i].rm_eo == -1)
+				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 */
+			ssp = m->offp + m->pmatch[i].rm_so;
+			if (memcmp(sp, ssp, len) != 0)
+				return (NULL);
+			while (m->g->strip[ss] != SOP(O_BACK, i))
+				ss++;
+			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);
+			if (dp != NULL)
+				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));
+			break;
+		case O_PLUS:
+			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);
+			if (dp == NULL)
+				return (backref(m, sp, stop, ss + 1, stopst, lev - 1));
+			else
+				return (dp);
+			break;
+		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 */
+				dp = backref(m, sp, stop, ssub, esub, lev);
+				if (dp != NULL)
+					return (dp);
+				/* that one missed, try next one */
+				if (OP(m->g->strip[esub]) == O_CH)
+					return (NULL);		/* there is none */
+				esub++;
+				assert(OP(m->g->strip[esub]) == OOR2);
+				ssub = esub + 1;
+				esub += OPND(m->g->strip[esub]);
+				if (OP(m->g->strip[esub]) == OOR2)
+					esub--;
+				else
+					assert(OP(m->g->strip[esub]) == O_CH);
+			}
+			break;
+		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);
+			if (dp != NULL)
+				return (dp);
+			m->pmatch[i].rm_so = offsave;
 			return (NULL);
-		while (m->g->strip[ss] != SOP(O_BACK, i))
-			ss++;
-		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);
-		if (dp != NULL)
-			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));
-		break;
-	case O_PLUS:
-		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);
-		if (dp == NULL)
-			return (backref(m, sp, stop, ss + 1, stopst, lev - 1));
-		else
-			return (dp);
-		break;
-	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 */
-			dp = backref(m, sp, stop, ssub, esub, lev);
+			break;
+		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);
 			if (dp != NULL)
 				return (dp);
-			/* that one missed, try next one */
-			if (OP(m->g->strip[esub]) == O_CH)
-				return (NULL);	/* there is none */
-			esub++;
-			assert(OP(m->g->strip[esub]) == OOR2);
-			ssub = esub + 1;
-			esub += OPND(m->g->strip[esub]);
-			if (OP(m->g->strip[esub]) == OOR2)
-				esub--;
-			else
-				assert(OP(m->g->strip[esub]) == O_CH);
-		}
-		break;
-	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);
-		if (dp != NULL)
-			return (dp);
-		m->pmatch[i].rm_so = offsave;
-		return (NULL);
-		break;
-	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);
-		if (dp != NULL)
-			return (dp);
-		m->pmatch[i].rm_eo = offsave;
-		return (NULL);
-		break;
-	default:					/* uh oh */
-		assert(nope);
-		break;
+			m->pmatch[i].rm_eo = offsave;
+			return (NULL);
+			break;
+		default:				/* uh oh */
+			assert(nope);
+			break;
 	}
 
 	/* "can't happen" */
@@ -750,23 +750,23 @@ sopno			lev;			/* PLUS nesting level */
  == static char *fast(register struct match *m, char *start, \
  ==		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
+	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);
@@ -849,23 +849,23 @@ sopno			stopst;
  == static char *slow(register struct match *m, char *start, \
  ==		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);
@@ -952,119 +952,119 @@ sopno			stopst;
  == #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 */
+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 */
+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))
 	{
 		s = g->strip[pc];
 		switch (OP(s))
 		{
-		case OEND:
-			assert(pc == stop - 1);
-			break;
-		case OCHAR:
-			/* only characters can match */
-			assert(!NONCHAR(ch) || ch != (char) OPND(s));
-			if (ch == (char) OPND(s))
-				FWD(aft, bef, 1);
-			break;
-		case OBOL:
-			if (ch == BOL || ch == BOLEOL)
-				FWD(aft, bef, 1);
-			break;
-		case OEOL:
-			if (ch == EOL || ch == BOLEOL)
-				FWD(aft, bef, 1);
-			break;
-		case OBOW:
-			if (ch == BOW)
-				FWD(aft, bef, 1);
-			break;
-		case OEOW:
-			if (ch == EOW)
-				FWD(aft, bef, 1);
-			break;
-		case OANY:
-			if (!NONCHAR(ch))
-				FWD(aft, bef, 1);
-			break;
-		case OANYOF:
-			cs = &g->sets[OPND(s)];
-			if (!NONCHAR(ch) && CHIN(cs, ch))
-				FWD(aft, bef, 1);
-			break;
-		case OBACK_:			/* ignored here */
-		case O_BACK:
-			FWD(aft, aft, 1);
-			break;
-		case OPLUS_:			/* forward, this is just an empty */
-			FWD(aft, aft, 1);
-			break;
-		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)))
-			{
-				/* oho, must reconsider loop body */
-				pc -= OPND(s) + 1;
-				INIT(here, pc);
-			}
-			break;
-		case OQUEST_:			/* two branches, both forward */
-			FWD(aft, aft, 1);
-			FWD(aft, aft, OPND(s));
-			break;
-		case O_QUEST:			/* just an empty */
-			FWD(aft, aft, 1);
-			break;
-		case OLPAREN:			/* not significant here */
-		case ORPAREN:
-			FWD(aft, aft, 1);
-			break;
-		case OCH_:				/* mark the first two branches */
-			FWD(aft, aft, 1);
-			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))
-			{
-				for (look = 1;
-					 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 */
-			FWD(aft, aft, 1);
-			if (OP(g->strip[pc + OPND(s)]) != O_CH)
-			{
+			case OEND:
+				assert(pc == stop - 1);
+				break;
+			case OCHAR:
+				/* only characters can match */
+				assert(!NONCHAR(ch) || ch != (char) OPND(s));
+				if (ch == (char) OPND(s))
+					FWD(aft, bef, 1);
+				break;
+			case OBOL:
+				if (ch == BOL || ch == BOLEOL)
+					FWD(aft, bef, 1);
+				break;
+			case OEOL:
+				if (ch == EOL || ch == BOLEOL)
+					FWD(aft, bef, 1);
+				break;
+			case OBOW:
+				if (ch == BOW)
+					FWD(aft, bef, 1);
+				break;
+			case OEOW:
+				if (ch == EOW)
+					FWD(aft, bef, 1);
+				break;
+			case OANY:
+				if (!NONCHAR(ch))
+					FWD(aft, bef, 1);
+				break;
+			case OANYOF:
+				cs = &g->sets[OPND(s)];
+				if (!NONCHAR(ch) && CHIN(cs, ch))
+					FWD(aft, bef, 1);
+				break;
+			case OBACK_:		/* ignored here */
+			case O_BACK:
+				FWD(aft, aft, 1);
+				break;
+			case OPLUS_:		/* forward, this is just an empty */
+				FWD(aft, aft, 1);
+				break;
+			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)))
+				{
+					/* oho, must reconsider loop body */
+					pc -= OPND(s) + 1;
+					INIT(here, pc);
+				}
+				break;
+			case OQUEST_:		/* two branches, both forward */
+				FWD(aft, aft, 1);
+				FWD(aft, aft, OPND(s));
+				break;
+			case O_QUEST:		/* just an empty */
+				FWD(aft, aft, 1);
+				break;
+			case OLPAREN:		/* not significant here */
+			case ORPAREN:
+				FWD(aft, aft, 1);
+				break;
+			case OCH_:			/* mark the first two branches */
+				FWD(aft, aft, 1);
 				assert(OP(g->strip[pc + OPND(s)]) == OOR2);
 				FWD(aft, aft, OPND(s));
-			}
-			break;
-		case O_CH:				/* just empty */
-			FWD(aft, aft, 1);
-			break;
-		default:				/* ooooops... */
-			assert(nope);
-			break;
+				break;
+			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))
+						assert(OP(s) == OOR2);
+					FWD(aft, aft, look);
+				}
+				break;
+			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);
+					FWD(aft, aft, OPND(s));
+				}
+				break;
+			case O_CH:			/* just empty */
+				FWD(aft, aft, 1);
+				break;
+			default:			/* ooooops... */
+				assert(nope);
+				break;
 		}
 	}
 
@@ -1081,15 +1081,15 @@ register states aft;			/* states already known reachable after */
  */
 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))
 		return;
@@ -1115,12 +1115,12 @@ FILE		   *d;
  */
 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))
 		return;
@@ -1143,11 +1143,11 @@ sopno			stopst;
  * 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);
diff --git a/src/backend/regex/regcomp.c b/src/backend/regex/regcomp.c
index dcb95173c06..da4f2020ce3 100644
--- a/src/backend/regex/regcomp.c
+++ b/src/backend/regex/regcomp.c
@@ -38,7 +38,7 @@
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char		sccsid[] = "@(#)regcomp.c	8.5 (Berkeley) 3/20/94";
+static char sccsid[] = "@(#)regcomp.c	8.5 (Berkeley) 3/20/94";
 
 #endif							/* LIBC_SCCS and not lint */
 
@@ -62,64 +62,64 @@ static char		sccsid[] = "@(#)regcomp.c	8.5 (Berkeley) 3/20/94";
  */
 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 */
+	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) */
+	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
 }
@@ -127,7 +127,7 @@ extern			"C"
 #endif
 /* ========= end header generated by ./mkh ========= */
 
-static char		nuls[10];		/* place to point scanner in event of
+static char nuls[10];			/* place to point scanner in event of
 								 * error */
 
 /*
@@ -161,7 +161,7 @@ static char		nuls[10];		/* place to point scanner in event of
 #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 */
@@ -181,14 +181,14 @@ static int		never = 0;		/* for use in asserts; shuts lint up */
  */
 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
@@ -292,13 +292,13 @@ 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? */
+	register char c;
+	register sopno prevback = 0;
+	register sopno prevfwd = 0;
+	register sopno conc;
+	register int first = 1;		/* is this the first alternative? */
 
 	for (;;)
 	{
@@ -342,12 +342,12 @@ 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;
+	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();
@@ -355,75 +355,76 @@ register struct parse *p;
 	pos = HERE();
 	switch (c)
 	{
-	case '(':
-		REQUIRE(MORE(), REG_EPAREN);
-		p->g->nsub++;
-		subno = p->g->nsub;
-		if (subno < NPAREN)
-			p->pbegin[subno] = HERE();
-		EMIT(OLPAREN, subno);
-		if (!SEE(')'))
-			p_ere(p, ')');
-		if (subno < NPAREN)
-		{
-			p->pend[subno] = HERE();
-			assert(p->pend[subno] != 0);
-		}
-		EMIT(ORPAREN, subno);
-		MUSTEAT(')', REG_EPAREN);
-		break;
+		case '(':
+			REQUIRE(MORE(), REG_EPAREN);
+			p->g->nsub++;
+			subno = p->g->nsub;
+			if (subno < NPAREN)
+				p->pbegin[subno] = HERE();
+			EMIT(OLPAREN, subno);
+			if (!SEE(')'))
+				p_ere(p, ')');
+			if (subno < NPAREN)
+			{
+				p->pend[subno] = HERE();
+				assert(p->pend[subno] != 0);
+			}
+			EMIT(ORPAREN, subno);
+			MUSTEAT(')', REG_EPAREN);
+			break;
 #ifndef POSIX_MISTAKE
-	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.
-		 */
-		SETERROR(REG_EPAREN);
-		break;
+		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.
+			 */
+			SETERROR(REG_EPAREN);
+			break;
 #endif
-	case '^':
-		EMIT(OBOL, 0);
-		p->g->iflags |= USEBOL;
-		p->g->nbol++;
-		wascaret = 1;
-		break;
-	case '$':
-		EMIT(OEOL, 0);
-		p->g->iflags |= USEEOL;
-		p->g->neol++;
-		break;
-	case '|':
-		SETERROR(REG_EMPTY);
-		break;
-	case '*':
-	case '+':
-	case '?':
-		SETERROR(REG_BADRPT);
-		break;
-	case '.':
-		if (p->g->cflags & REG_NEWLINE)
-			nonnewline(p);
-		else
-			EMIT(OANY, 0);
-		break;
-	case '[':
-		p_bracket(p);
-		break;
-	case '\\':
-		REQUIRE(MORE(), REG_EESCAPE);
-		c = GETNEXT();
-		ordinary(p, c);
-		break;
-	case '{':					/* okay as ordinary except if digit
+		case '^':
+			EMIT(OBOL, 0);
+			p->g->iflags |= USEBOL;
+			p->g->nbol++;
+			wascaret = 1;
+			break;
+		case '$':
+			EMIT(OEOL, 0);
+			p->g->iflags |= USEEOL;
+			p->g->neol++;
+			break;
+		case '|':
+			SETERROR(REG_EMPTY);
+			break;
+		case '*':
+		case '+':
+		case '?':
+			SETERROR(REG_BADRPT);
+			break;
+		case '.':
+			if (p->g->cflags & REG_NEWLINE)
+				nonnewline(p);
+			else
+				EMIT(OANY, 0);
+			break;
+		case '[':
+			p_bracket(p);
+			break;
+		case '\\':
+			REQUIRE(MORE(), REG_EESCAPE);
+			c = GETNEXT();
+			ordinary(p, c);
+			break;
+		case '{':				/* okay as ordinary except if digit
 								 * follows */
-		REQUIRE(!MORE() || !isdigit(PEEK()), REG_BADRPT);
-		/* FALLTHROUGH */
-	default:
-		ordinary(p, c);
-		break;
+			REQUIRE(!MORE() || !isdigit(PEEK()), REG_BADRPT);
+			/* FALLTHROUGH */
+		default:
+			ordinary(p, c);
+			break;
 	}
 
 	if (!MORE())
@@ -438,51 +439,51 @@ register struct parse *p;
 	REQUIRE(!wascaret, REG_BADRPT);
 	switch (c)
 	{
-	case '*':					/* 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);
-		break;
-	case '+':
-		INSERT(OPLUS_, pos);
-		ASTERN(O_PLUS, pos);
-		break;
-	case '?':
-		/* 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_ */
-		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()))
+		case '*':				/* 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);
+			break;
+		case '+':
+			INSERT(OPLUS_, pos);
+			ASTERN(O_PLUS, pos);
+			break;
+		case '?':
+			/* 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_ */
+			EMIT(OOR2, 0);		/* offset very wrong... */
+			AHEAD(THERE());		/* ...so fix it */
+			ASTERN(O_CH, THERETHERE());
+			break;
+		case '{':
+			count = p_count(p);
+			if (EAT(','))
 			{
-				count2 = p_count(p);
-				REQUIRE(count <= count2, REG_BADBR);
+				if (isdigit(PEEK()))
+				{
+					count2 = p_count(p);
+					REQUIRE(count <= count2, REG_BADBR);
+				}
+				else
+/* single number with comma */
+					count2 = INFINITY;
 			}
 			else
-/* single number with comma */
-				count2 = INFINITY;
-		}
-		else
 /* just a single number */
-			count2 = count;
-		repeat(p, pos, count, count2);
-		if (!EAT('}'))
-		{						/* error heuristics */
-			while (MORE() && PEEK() != '}')
-				NEXT();
-			REQUIRE(MORE(), REG_EBRACE);
-			SETERROR(REG_BADBR);
-		}
-		break;
+				count2 = count;
+			repeat(p, pos, count, count2);
+			if (!EAT('}'))
+			{					/* error heuristics */
+				while (MORE() && PEEK() != '}')
+					NEXT();
+				REQUIRE(MORE(), REG_EBRACE);
+				SETERROR(REG_BADBR);
+			}
+			break;
 	}
 
 	if (!MORE())
@@ -522,12 +523,12 @@ register struct parse *p;
 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('^'))
 	{
@@ -558,14 +559,14 @@ register int	end2;			/* second terminating character */
 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;
+	register int c;
+	register int count;
+	register int count2;
+	register sopno pos;
+	register int i;
+	register sopno subno;
 
 #define  BACKSL  (1<<CHAR_BIT)
 
@@ -580,70 +581,70 @@ int				starordinary;	/* is a leading * an ordinary character? */
 	}
 	switch (c)
 	{
-	case '.':
-		if (p->g->cflags & REG_NEWLINE)
-			nonnewline(p);
-		else
-			EMIT(OANY, 0);
-		break;
-	case '[':
-		p_bracket(p);
-		break;
-	case BACKSL | '{':
-		SETERROR(REG_BADRPT);
-		break;
-	case BACKSL | '(':
-		p->g->nsub++;
-		subno = p->g->nsub;
-		if (subno < NPAREN)
-			p->pbegin[subno] = HERE();
-		EMIT(OLPAREN, subno);
-		/* the MORE here is an error heuristic */
-		if (MORE() && !SEETWO('\\', ')'))
-			p_bre(p, '\\', ')');
-		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 | '}':
-		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';
-		assert(i < NPAREN);
-		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]);
-			EMIT(O_BACK, i);
-		}
-		else
-			SETERROR(REG_ESUBREG);
-		p->g->backrefs = 1;
-		break;
-	case '*':
-		REQUIRE(starordinary, REG_BADRPT);
-		/* FALLTHROUGH */
-	default:
-		ordinary(p, c & ~BACKSL);
-		break;
+		case '.':
+			if (p->g->cflags & REG_NEWLINE)
+				nonnewline(p);
+			else
+				EMIT(OANY, 0);
+			break;
+		case '[':
+			p_bracket(p);
+			break;
+		case BACKSL | '{':
+			SETERROR(REG_BADRPT);
+			break;
+		case BACKSL | '(':
+			p->g->nsub++;
+			subno = p->g->nsub;
+			if (subno < NPAREN)
+				p->pbegin[subno] = HERE();
+			EMIT(OLPAREN, subno);
+			/* the MORE here is an error heuristic */
+			if (MORE() && !SEETWO('\\', ')'))
+				p_bre(p, '\\', ')');
+			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 | '}':
+			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';
+			assert(i < NPAREN);
+			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]);
+				EMIT(O_BACK, i);
+			}
+			else
+				SETERROR(REG_ESUBREG);
+			p->g->backrefs = 1;
+			break;
+		case '*':
+			REQUIRE(starordinary, REG_BADRPT);
+			/* FALLTHROUGH */
+		default:
+			ordinary(p, c & ~BACKSL);
+			break;
 	}
 
 	if (EAT('*'))
@@ -694,8 +695,8 @@ 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)
 	{
@@ -718,8 +719,8 @@ 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)
@@ -752,8 +753,8 @@ register struct parse *p;
 
 	if (p->g->cflags & REG_ICASE)
 	{
-		register int	i;
-		register int	ci;
+		register int i;
+		register int ci;
 
 		for (i = p->g->csetsize - 1; i >= 0; i--)
 			if (CHIN(cs, i) && isalpha(i))
@@ -767,7 +768,7 @@ register struct parse *p;
 	}
 	if (invert)
 	{
-		register int	i;
+		register int i;
 
 		for (i = p->g->csetsize - 1; i >= 0; i--)
 			if (CHIN(cs, i))
@@ -798,67 +799,67 @@ 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')
 	{
-	case '[':
-		c = (MORE2()) ? PEEK2() : '\0';
-		break;
-	case '-':
-		SETERROR(REG_ERANGE);
-		return;					/* NOTE RETURN */
-		break;
-	default:
-		c = '\0';
-		break;
+		case '[':
+			c = (MORE2()) ? PEEK2() : '\0';
+			break;
+		case '-':
+			SETERROR(REG_ERANGE);
+			return;				/* NOTE RETURN */
+			break;
+		default:
+			c = '\0';
+			break;
 	}
 
 	switch (c)
 	{
-	case ':':					/* character class */
-		NEXT2();
-		REQUIRE(MORE(), REG_EBRACK);
-		c = PEEK();
-		REQUIRE(c != '-' && c != ']', REG_ECTYPE);
-		p_b_cclass(p, cs);
-		REQUIRE(MORE(), REG_EBRACK);
-		REQUIRE(EATTWO(':', ']'), REG_ECTYPE);
-		break;
-	case '=':					/* equivalence class */
-		NEXT2();
-		REQUIRE(MORE(), REG_EBRACK);
-		c = PEEK();
-		REQUIRE(c != '-' && c != ']', REG_ECOLLATE);
-		p_b_eclass(p, cs);
-		REQUIRE(MORE(), REG_EBRACK);
-		REQUIRE(EATTWO('=', ']'), REG_ECOLLATE);
-		break;
-	default:					/* symbol, ordinary character, or range */
+		case ':':				/* character class */
+			NEXT2();
+			REQUIRE(MORE(), REG_EBRACK);
+			c = PEEK();
+			REQUIRE(c != '-' && c != ']', REG_ECTYPE);
+			p_b_cclass(p, cs);
+			REQUIRE(MORE(), REG_EBRACK);
+			REQUIRE(EATTWO(':', ']'), REG_ECTYPE);
+			break;
+		case '=':				/* equivalence class */
+			NEXT2();
+			REQUIRE(MORE(), REG_EBRACK);
+			c = PEEK();
+			REQUIRE(c != '-' && c != ']', REG_ECOLLATE);
+			p_b_eclass(p, cs);
+			REQUIRE(MORE(), REG_EBRACK);
+			REQUIRE(EATTWO('=', ']'), REG_ECOLLATE);
+			break;
+		default:				/* symbol, ordinary character, or range */
 /* xxx revision needed for multichar stuff */
-		start = p_b_symbol(p);
-		if (SEE('-') && MORE2() && PEEK2() != ']')
-		{
-			/* range */
-			NEXT();
-			if (EAT('-'))
-				finish = '-';
+			start = p_b_symbol(p);
+			if (SEE('-') && MORE2() && PEEK2() != ']')
+			{
+				/* range */
+				NEXT();
+				if (EAT('-'))
+					finish = '-';
+				else
+					finish = p_b_symbol(p);
+			}
 			else
-				finish = p_b_symbol(p);
-		}
-		else
-			finish = start;
+				finish = start;
 /* xxx what about signed chars here... */
-		REQUIRE(start <= finish, REG_ERANGE);
-		for (i = start; i <= finish; i++)
-			CHadd(cs, i);
-		break;
+			REQUIRE(start <= finish, REG_ERANGE);
+			for (i = start; i <= finish; i++)
+				CHadd(cs, i);
+			break;
 	}
 }
 
@@ -869,13 +870,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();
@@ -906,9 +907,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);
@@ -922,7 +923,7 @@ 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('[', '.'))
@@ -941,11 +942,11 @@ register struct parse *p;
 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();
@@ -970,7 +971,7 @@ int				endc;			/* name ended by endc,']' */
  */
 static char						/* if no counterpart, return ch */
 othercase(ch)
-int				ch;
+int			ch;
 {
 	assert(isalpha(ch));
 	if (isupper(ch))
@@ -991,11 +992,11 @@ 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 */
 	p->next = bracket;
@@ -1016,7 +1017,7 @@ int				ch;
 static void
 ordinary(p, ch)
 register struct parse *p;
-register int	ch;
+register int ch;
 {
 	register cat_t *cap = p->g->categories;
 
@@ -1040,9 +1041,9 @@ 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;
@@ -1063,18 +1064,18 @@ 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
+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();
+	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;
+	register sopno copy;
 
 	if (p->error != 0)			/* head off possible runaway recursion */
 		return;
@@ -1083,51 +1084,51 @@ int				to;				/* to this number of times (maybe
 
 	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,}? */
-		/* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
-		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 */
-		/* done */
-		break;
-	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);
-		AHEAD(start);
-		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);
-		break;
-	case REP(1, INF):			/* as x+ */
-		INSERT(OPLUS_, start);
-		ASTERN(O_PLUS, start);
-		break;
-	case REP(N, N):				/* as xx{m-1,n-1} */
-		copy = dupl(p, start, finish);
-		repeat(p, copy, from - 1, to - 1);
-		break;
-	case REP(N, INF):			/* as xx{n-1,INF} */
-		copy = dupl(p, start, finish);
-		repeat(p, copy, from - 1, to);
-		break;
-	default:					/* "can't happen" */
-		SETERROR(REG_ASSERT);	/* just in case */
-		break;
+		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,}? */
+			/* KLUDGE: emit y? as (y|) until subtle bug gets fixed */
+			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 */
+			/* done */
+			break;
+		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);
+			AHEAD(start);
+			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);
+			break;
+		case REP(1, INF):		/* as x+ */
+			INSERT(OPLUS_, start);
+			ASTERN(O_PLUS, start);
+			break;
+		case REP(N, N): /* as xx{m-1,n-1} */
+			copy = dupl(p, start, finish);
+			repeat(p, copy, from - 1, to - 1);
+			break;
+		case REP(N, INF):		/* as xx{n-1,INF} */
+			copy = dupl(p, start, finish);
+			repeat(p, copy, from - 1, to);
+			break;
+		default:				/* "can't happen" */
+			SETERROR(REG_ASSERT);		/* just in case */
+			break;
 	}
 }
 
@@ -1138,7 +1139,7 @@ int				to;				/* to this number of times (maybe
 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 */
 		p->error = e;
@@ -1151,16 +1152,16 @@ int				e;
  - 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 cset *cs;
 	register size_t css = (size_t) p->g->csetsize;
-	register int	i;
+	register int i;
 
 	if (no >= p->ncsalloc)
 	{							/* need another column of space */
@@ -1212,10 +1213,10 @@ 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 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++)
@@ -1237,12 +1238,12 @@ register cset  *cs;
 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 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 */
@@ -1273,9 +1274,9 @@ register cset  *cs;
 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 int i;
 	register size_t css = (size_t) p->g->csetsize;
 
 	for (i = 0; i < css; i++)
@@ -1292,11 +1293,11 @@ register cset  *cs;
 static int
 nch(p, cs)
 register struct parse *p;
-register cset  *cs;
+register cset *cs;
 {
-	register int	i;
+	register int i;
 	register size_t css = (size_t) p->g->csetsize;
-	register int	n = 0;
+	register int n = 0;
 
 	for (i = 0; i < css; i++)
 		if (CHIN(cs, i))
@@ -1312,8 +1313,8 @@ register cset  *cs;
 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;
 
@@ -1405,7 +1406,7 @@ register char *cp;
 static void
 mcinvert(p, cs)
 register struct parse *p;
-register cset  *cs;
+register cset *cs;
 {
 	assert(cs->multis == NULL); /* xxx */
 }
@@ -1420,7 +1421,7 @@ register cset  *cs;
 static void
 mccase(p, cs)
 register struct parse *p;
-register cset  *cs;
+register cset *cs;
 {
 	assert(cs->multis == NULL); /* xxx */
 }
@@ -1432,11 +1433,11 @@ register cset  *cs;
 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 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)
@@ -1452,12 +1453,12 @@ int				c;
 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 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;
 
@@ -1473,13 +1474,13 @@ 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)
@@ -1500,14 +1501,14 @@ 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)
@@ -1531,8 +1532,8 @@ 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)
@@ -1557,13 +1558,13 @@ 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)
@@ -1600,8 +1601,8 @@ 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)
@@ -1618,9 +1619,9 @@ 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;
@@ -1665,16 +1666,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)
@@ -1688,39 +1689,39 @@ register struct re_guts *g;
 		s = *scan++;
 		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 OLPAREN:
-		case ORPAREN:
-			break;
-		case OQUEST_:			/* things that must be skipped */
-		case OCH_:
-			scan--;
-			do
-			{
-				scan += OPND(s);
-				s = *scan;
-				/* assert() interferes w debug printouts */
-				if (OP(s) != O_QUEST && OP(s) != O_CH &&
-					OP(s) != OOR2)
+			case OCHAR: /* sequence member */
+				if (newlen == 0)/* new sequence */
+					newstart = scan - 1;
+				newlen++;
+				break;
+			case OPLUS_:		/* things that don't break one */
+			case OLPAREN:
+			case ORPAREN:
+				break;
+			case OQUEST_:		/* things that must be skipped */
+			case OCH_:
+				scan--;
+				do
 				{
-					g->iflags |= BAD;
-					return;
+					scan += OPND(s);
+					s = *scan;
+					/* assert() interferes w debug printouts */
+					if (OP(s) != O_QUEST && OP(s) != O_CH &&
+						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 */
+					start = newstart;
+					g->mlen = newlen;
 				}
-			} while (OP(s) != O_QUEST && OP(s) != O_CH);
-			/* fallthrough */
-		default:				/* things that break a sequence */
-			if (newlen > g->mlen)
-			{					/* ends one */
-				start = newstart;
-				g->mlen = newlen;
-			}
-			newlen = 0;
-			break;
+				newlen = 0;
+				break;
 		}
 	} while (OP(s) != OEND);
 
@@ -1751,15 +1752,15 @@ register struct re_guts *g;
  - 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 */
@@ -1770,14 +1771,14 @@ register struct re_guts *g;
 		s = *scan++;
 		switch (OP(s))
 		{
-		case OPLUS_:
-			plusnest++;
-			break;
-		case O_PLUS:
-			if (plusnest > maxnest)
-				maxnest = plusnest;
-			plusnest--;
-			break;
+			case OPLUS_:
+				plusnest++;
+				break;
+			case O_PLUS:
+				if (plusnest > maxnest)
+					maxnest = plusnest;
+				plusnest--;
+				break;
 		}
 	} while (OP(s) != OEND);
 	if (plusnest != 0)
diff --git a/src/backend/regex/regerror.c b/src/backend/regex/regerror.c
index 9e6e0e02179..d5f92559836 100644
--- a/src/backend/regex/regerror.c
+++ b/src/backend/regex/regerror.c
@@ -38,7 +38,7 @@
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char		sccsid[] = "@(#)regerror.c	8.4 (Berkeley) 3/20/94";
+static char sccsid[] = "@(#)regerror.c	8.4 (Berkeley) 3/20/94";
 
 #endif							/* LIBC_SCCS and not lint */
 
@@ -55,12 +55,12 @@ 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
 }
@@ -89,10 +89,10 @@ extern			"C"
  */
 static struct rerr
 {
-	int				code;
-	char		   *name;
-	char		   *explain;
-}				rerrs[] =
+	int			code;
+	char	   *name;
+	char	   *explain;
+}			rerrs[] =
 
 {
 	{
@@ -155,16 +155,16 @@ 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);
@@ -206,10 +206,10 @@ size_t			errbuf_size;
  - 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;
 
diff --git a/src/backend/regex/regexec.c b/src/backend/regex/regexec.c
index 5e0021f4299..224856afec0 100644
--- a/src/backend/regex/regexec.c
+++ b/src/backend/regex/regexec.c
@@ -38,7 +38,7 @@
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char		sccsid[] = "@(#)regexec.c	8.3 (Berkeley) 3/20/94";
+static char sccsid[] = "@(#)regexec.c	8.3 (Berkeley) 3/20/94";
 
 #endif							/* LIBC_SCCS and not lint */
 
@@ -61,7 +61,7 @@ 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
@@ -156,11 +156,11 @@ static int		nope = 0;		/* for use in asserts; shuts lint up */
  */
 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;
 
diff --git a/src/backend/regex/regfree.c b/src/backend/regex/regfree.c
index 26ca8863ed6..15735fa663e 100644
--- a/src/backend/regex/regfree.c
+++ b/src/backend/regex/regfree.c
@@ -38,7 +38,7 @@
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char		sccsid[] = "@(#)regfree.c	8.3 (Berkeley) 3/20/94";
+static char sccsid[] = "@(#)regfree.c	8.3 (Berkeley) 3/20/94";
 
 #endif							/* LIBC_SCCS and not lint */
 
@@ -56,7 +56,7 @@ 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;