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

1 files changed, 481 insertions, 480 deletions

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)