 @@ -1,14 +1,14 @@
-/*	$NetBSD: engine.c,v 1.2 2013/11/22 15:52:06 christos Exp $ */
+/*	$NetBSD: engine.c,v 1.3 2014/01/07 21:48:12 christos Exp $ */
 /*-
  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  * Copyright (c) 1992, 1993, 1994
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Henry Spencer of the University of Toronto.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -120,44 +120,44 @@ static char *pchar __P((int ch));
 #ifdef REDEBUG
 #define	SP(t, s, c)	print(m, t, s, c, stdout)
 #define	AT(t, p1, p2, s1, s2)	at(m, t, p1, p2, s1, s2)
 #define	NOTE(str)	{ if (m->eflags&REG_TRACE) printf("=%s\n", (str)); }
 #else
 #define	SP(t, s, c)	/* nothing */
 #define	AT(t, p1, p2, s1, s2)	/* nothing */
 #define	NOTE(s)	/* nothing */
 #endif
 /*
  - matcher - the actual matching engine
- == static int matcher(register struct re_guts *g, RCHAR_T *string, \
+ == static int matcher(struct re_guts *g, RCHAR_T *string, \
  ==	size_t nmatch, regmatch_t pmatch[], int eflags);
  */
 static int			/* 0 success, REG_NOMATCH failure */
 matcher(g, string, nmatch, pmatch, eflags)
-register struct re_guts *g;
+struct re_guts *g;
 RCHAR_T *string;
 size_t nmatch;
 regmatch_t pmatch[];
 int eflags;
+{
-	register RCHAR_T *endp;
+	RCHAR_T *endp;
-	register size_t i;
+	size_t i;
 	struct match mv;
-	register struct match *m = &mv;
+	struct match *m = &mv;
-	register RCHAR_T *dp;
+	RCHAR_T *dp;
-	register const sopno gf = g->firststate+1;	/* +1 for OEND */
+	const sopno gf = g->firststate+1;	/* +1 for OEND */
-	register const sopno gl = g->laststate;
+	const sopno gl = g->laststate;
 	RCHAR_T *start;
 	RCHAR_T *stop;
 	/* simplify the situation where possible */
 	if (g->cflags&REG_NOSUB)
 		nmatch = 0;
 	if (eflags&REG_STARTEND) {
 		start = string + pmatch[0].rm_so;
 		stop = string + pmatch[0].rm_eo;
 	} else {
 		start = string;
 		stop = start + STRLEN(start);
+	}
 @@ -286,50 +286,50 @@ int eflags;
+			}
+	}
 	if (m->pmatch != NULL)
 		free((char *)m->pmatch);
 	if (m->lastpos != NULL)
 		free((char *)m->lastpos);
 	STATETEARDOWN(m);
 	return(0);
+}
 /*
  - dissect - figure out what matched what, no back references
- == static RCHAR_T *dissect(register struct match *m, RCHAR_T *start, \
+ == static RCHAR_T *dissect(struct match *m, RCHAR_T *start, \
  ==	RCHAR_T *stop, sopno startst, sopno stopst);
  */
 static RCHAR_T *			/* == stop (success) always */
 dissect(m, start, stop, startst, stopst)
-register struct match *m;
+struct match *m;
 RCHAR_T *start;
 RCHAR_T *stop;
 sopno startst;
 sopno stopst;
+{
-	register int i;
+	int i;
-	register sopno ss;	/* start sop of current subRE */
+	sopno ss;	/* start sop of current subRE */
-	register sopno es;	/* end sop of current subRE */
+	sopno es;	/* end sop of current subRE */
-	register RCHAR_T *sp;	/* start of string matched by it */
+	RCHAR_T *sp;	/* start of string matched by it */
-	register RCHAR_T *stp;	/* string matched by it cannot pass here */
+	RCHAR_T *stp;	/* string matched by it cannot pass here */
-	register RCHAR_T *rest;	/* start of rest of string */
+	RCHAR_T *rest;	/* start of rest of string */
-	register RCHAR_T *tail;	/* string unmatched by rest of RE */
+	RCHAR_T *tail;	/* string unmatched by rest of RE */
-	register sopno ssub;	/* start sop of subsubRE */
+	sopno ssub;	/* start sop of subsubRE */
-	register sopno esub;	/* end sop of subsubRE */
+	sopno esub;	/* end sop of subsubRE */
-	register RCHAR_T *ssp;	/* start of string matched by subsubRE */
+	RCHAR_T *ssp;	/* start of string matched by subsubRE */
-	register RCHAR_T *sep;	/* end of string matched by subsubRE */
+	RCHAR_T *sep;	/* end of string matched by subsubRE */
-	register RCHAR_T *oldssp;	/* previous ssp */
+	RCHAR_T *oldssp;	/* previous ssp */
-	register RCHAR_T *dp;
+	RCHAR_T *dp;
 	AT("diss", start, stop, startst, stopst);
 	sp = start;
 	for (ss = startst; ss < stopst; ss = es) {
 		/* identify end of subRE */
 		es = ss;
 		switch (m->g->strip[es]) {
 		case OPLUS_:
 		case OQUEST_:
 			es += m->g->stripdata[es];
 			break;
 		case OCH_:
 			while (m->g->strip[es] != O_CH)
 @@ -475,51 +475,51 @@ sopno stopst;
 			break;
 		default:		/* uh oh */
 			assert(nope);
 			break;
+		}
+	}
 	assert(sp == stop);
 	return(sp);
+}
 /*
  - backref - figure out what matched what, figuring in back references
- == static RCHAR_T *backref(register struct match *m, RCHAR_T *start, \
+ == static RCHAR_T *backref(struct match *m, RCHAR_T *start, \
  ==	RCHAR_T *stop, sopno startst, sopno stopst, sopno lev);
  */
 static RCHAR_T *			/* == stop (success) or NULL (failure) */
 backref(m, start, stop, startst, stopst, lev)
-register struct match *m;
+struct match *m;
 RCHAR_T *start;
 RCHAR_T *stop;
 sopno startst;
 sopno stopst;
 sopno lev;			/* PLUS nesting level */
+{
-	register int i;
+	int i;
-	register sopno ss;	/* start sop of current subRE */
+	sopno ss;	/* start sop of current subRE */
-	register RCHAR_T *sp;	/* start of string matched by it */
+	RCHAR_T *sp;	/* start of string matched by it */
-	register sopno ssub;	/* start sop of subsubRE */
+	sopno ssub;	/* start sop of subsubRE */
-	register sopno esub;	/* end sop of subsubRE */
+	sopno esub;	/* end sop of subsubRE */
-	register RCHAR_T *ssp;	/* start of string matched by subsubRE */
+	RCHAR_T *ssp;	/* start of string matched by subsubRE */
-	register RCHAR_T *dp;
+	RCHAR_T *dp;
-	register size_t len;
+	size_t len;
-	register int hard;
+	int hard;
-	register sop s;
+	sop s;
-	register RCHAR_T d;
+	RCHAR_T d;
-	register regoff_t offsave;
+	regoff_t offsave;
-	register cset *cs;
+	cset *cs;
 	AT("back", start, stop, startst, stopst);
 	sp = start;
 	/* get as far as we can with easy stuff */
 	hard = 0;
 	for (ss = startst; !hard && ss < stopst; ss++) {
 		s = m->g->strip[ss];
 		d = m->g->stripdata[ss];
 		switch (s) {
 		case OCHAR:
 			if (sp == stop || *sp++ != d)
 				return(NULL);
 @@ -688,46 +688,46 @@ sopno lev;			/* PLUS nesting level */
 	default:		/* uh oh */
 		assert(nope);
 		break;
+	}
 	/* "can't happen" */
 	assert(nope);
 	/* NOTREACHED */
 	return NULL;
+}
 /*
  - fast - step through the string at top speed
- == static RCHAR_T *fast(register struct match *m, RCHAR_T *start, \
+ == static RCHAR_T *fast(struct match *m, RCHAR_T *start, \
  ==	RCHAR_T *stop, sopno startst, sopno stopst);
  */
 static RCHAR_T *			/* where tentative match ended, or NULL */
 fast(m, start, stop, startst, stopst)
-register struct match *m;
+struct match *m;
 RCHAR_T *start;
 RCHAR_T *stop;
 sopno startst;
 sopno stopst;
+{
-	register states st = m->st;
+	states st = m->st;
-	register states fresh = m->fresh;
+	states fresh = m->fresh;
-	register states tmp = m->tmp;
+	states tmp = m->tmp;
-	register RCHAR_T *p = start;
+	RCHAR_T *p = start;
-	register RCHAR_T c = (start == m->beginp) ? OUT : *(start-1);
+	RCHAR_T c = (start == m->beginp) ? OUT : *(start-1);
-	register RCHAR_T lastc;	/* previous c */
+	RCHAR_T lastc;	/* previous c */
-	register int flag;
+	int flag;
-	register int i;
+	int i;
-	register RCHAR_T *coldp;	/* last p after which no match was underway */
+	RCHAR_T *coldp;	/* last p after which no match was underway */
 	CLEAR(st);
 	SET1(st, startst);
 	st = step(m->g, startst, stopst, st, NOTHING, OUT, st);
 	ASSIGN(fresh, st);
 	SP("start", st, *p);
 	coldp = NULL;
 	for (;;) {
 		/* next character */
 		lastc = c;
 		c = (p == m->endp) ? OUT : *p;
 		if (EQ(st, fresh))
 			coldp = p;
 @@ -779,46 +779,46 @@ sopno stopst;
 		p++;
+	}
 	assert(coldp != NULL);
 	m->coldp = coldp;
 	if (ISSET(st, stopst))
 		return(p+1);
 	else
 		return(NULL);
+}
 /*
  - slow - step through the string more deliberately
- == static RCHAR_T *slow(register struct match *m, RCHAR_T *start, \
+ == static RCHAR_T *slow(struct match *m, RCHAR_T *start, \
  ==	RCHAR_T *stop, sopno startst, sopno stopst);
  */
 static RCHAR_T *			/* where it ended */
 slow(m, start, stop, startst, stopst)
-register struct match *m;
+struct match *m;
 RCHAR_T *start;
 RCHAR_T *stop;
 sopno startst;
 sopno stopst;
+{
-	register states st = m->st;
+	states st = m->st;
-	register states empty = m->empty;
+	states empty = m->empty;
-	register states tmp = m->tmp;
+	states tmp = m->tmp;
-	register RCHAR_T *p = start;
+	RCHAR_T *p = start;
-	register RCHAR_T c = (start == m->beginp) ? OUT : *(start-1);
+	RCHAR_T c = (start == m->beginp) ? OUT : *(start-1);
-	register RCHAR_T lastc;	/* previous c */
+	RCHAR_T lastc;	/* previous c */
-	register int flag;
+	int flag;
-	register int i;
+	int i;
-	register RCHAR_T *matchp;	/* last p at which a match ended */
+	RCHAR_T *matchp;	/* last p at which a match ended */
 	AT("slow", start, stop, startst, stopst);
 	CLEAR(st);
 	SET1(st, startst);
 	SP("sstart", st, *p);
 	st = step(m->g, startst, stopst, st, NOTHING, OUT, st);
 	matchp = NULL;
 	for (;;) {
 		/* next character */
 		lastc = c;
 		c = (p == m->endp) ? OUT : *p;
 		/* is there an EOL and/or BOL between lastc and c? */
 @@ -866,52 +866,52 @@ sopno stopst;
 		assert(c != OUT);
 		st = step(m->g, startst, stopst, tmp, 0, c, st);
 		SP("saft", st, c);
 		assert(EQ(step(m->g, startst, stopst, st, NOTHING, OUT, st), st));
 		p++;
+	}
 	return(matchp);
+}
 /*
  - step - map set of states reachable before char to set reachable after
- == static states step(register struct re_guts *g, sopno start, sopno stop, \
+ == static states step(struct re_guts *g, sopno start, sopno stop, \
- ==	register states bef, int flag, RCHAR_T ch, register states aft);
+ ==	states bef, int flag, RCHAR_T ch, states aft);
  == #define	BOL	(1)
  == #define	EOL	(BOL+1)
  == #define	BOLEOL	(BOL+2)
  == #define	NOTHING	(BOL+3)
  == #define	BOW	(BOL+4)
  == #define	EOW	(BOL+5)
  */
 static states
 step(g, start, stop, bef, flag, ch, aft)
-register struct re_guts *g;
+struct re_guts *g;
 sopno start;			/* start state within strip */
 sopno stop;			/* state after stop state within strip */
-register states bef;		/* states reachable before */
+states bef;		/* states reachable before */
 int flag;			/* NONCHAR flag */
 RCHAR_T ch;			/* character code */
-register states aft;		/* states already known reachable after */
+states aft;		/* states already known reachable after */
+{
-	register cset *cs;
+	cset *cs;
-	register sop s;
+	sop s;
-	register RCHAR_T d;
+	RCHAR_T d;
-	register sopno pc;
+	sopno pc;
-	register onestate here;		/* note, macros know this name */
+	onestate here;		/* note, macros know this name */
-	register sopno look;
+	sopno look;
-	register int i;
+	int i;
 	for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) {
 		s = g->strip[pc];
 		d = g->stripdata[pc];
 		switch (s) {
 		case OEND:
 			assert(pc == stop-1);
 			break;
 		case OCHAR:
 			/* only characters can match */
 			assert(!flag || ch != d);
 			if (ch == d)
 				FWD(aft, bef, 1);
 @@ -1011,29 +1011,29 @@ register states aft;		/* states already
  == #ifdef REDEBUG
  == static void print(struct match *m, char *caption, states st, \
  ==	int ch, FILE *d);
  == #endif
  */
 static void
 print(m, caption, st, ch, d)
 struct match *m;
 char *caption;
 states st;
 int ch;
 FILE *d;
+{
-	register struct re_guts *g = m->g;
+	struct re_guts *g = m->g;
-	register int i;
+	int i;
-	register int first = 1;
+	int first = 1;
 	if (!(m->eflags&REG_TRACE))
 		return;
 	fprintf(d, "%s", caption);
 	if (ch != '\0')
 		fprintf(d, " %s", pchar(ch));
 	for (i = 0; i < g->nstates; i++)
 		if (ISSET(st, i)) {
 			fprintf(d, "%s%d", (first) ? "\t" : ", ", i);
 			first = 0;
+		}
 	fprintf(d, "\n");

 @@ -1,14 +1,14 @@
-/*	$NetBSD: regcomp.c,v 1.2 2013/11/22 15:52:06 christos Exp $ */
+/*	$NetBSD: regcomp.c,v 1.3 2014/01/07 21:48:12 christos Exp $ */
 /*-
  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  * Copyright (c) 1992, 1993, 1994
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Henry Spencer of the University of Toronto.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -182,30 +182,30 @@ static int never = 0;		/* for use in ass
  = #define	REG_BASIC	0000
  = #define	REG_EXTENDED	0001
  = #define	REG_ICASE	0002
  = #define	REG_NOSUB	0004
  = #define	REG_NEWLINE	0010
  = #define	REG_NOSPEC	0020
  = #define	REG_PEND	0040
  = #define	REG_DUMP	0200
  */
 int				/* 0 success, otherwise REG_something */
 regcomp(regex_t *preg, const RCHAR_T *pattern, int cflags)
+{
 	struct parse pa;
-	register struct re_guts *g;
+	struct re_guts *g;
-	register struct parse *p = &pa;
+	struct parse *p = &pa;
-	register int i;
+	int i;
-	register size_t len;
+	size_t len;
 #ifdef REDEBUG
 #	define	GOODFLAGS(f)	(f)
 #else
 #	define	GOODFLAGS(f)	((f)&~REG_DUMP)
 #endif
 	cflags = GOODFLAGS(cflags);
 	if ((cflags&REG_EXTENDED) && (cflags&REG_NOSPEC))
 		return(REG_INVARG);
 	if (cflags&REG_PEND) {
 		if (preg->re_endp < pattern)
 			return(REG_INVARG);
 @@ -285,38 +285,38 @@ regcomp(regex_t *preg, const RCHAR_T *pa
 	/* not debugging, so can't rely on the assert() in regexec() */
 	if (g->iflags&BAD)
 		SETERROR(REG_ASSERT);
 #endif
 	/* win or lose, we're done */
 	if (p->error != 0)	/* lose */
 		regfree(preg);
 	return(p->error);
+}
 /*
  - p_ere - ERE parser top level, concatenation and alternation
- == static void p_ere(register struct parse *p, int stop, size_t reclimit);
+ == static void p_ere(struct parse *p, int stop, size_t reclimit);
  */
 static void
-p_ere(register struct parse *p, int stop, size_t reclimit)
+p_ere(struct parse *p, int stop, size_t reclimit)
          			/* character this ERE should end at */
+{
-	register char c;
+	char c;
-	register sopno prevback = 0;
+	sopno prevback = 0;
-	register sopno prevfwd = 0;
+	sopno prevfwd = 0;
-	register sopno conc;
+	sopno conc;
-	register int first = 1;		/* is this the first alternative? */
+	int first = 1;		/* is this the first alternative? */
 	if (reclimit++ > RECLIMIT || p->error == REG_ESPACE) {
 		p->error = REG_ESPACE;
 		return;
+	}
 	for (;;) {
 		/* do a bunch of concatenated expressions */
 		conc = HERE();
 		while (MORE() && (c = PEEK()) != '|' && c != stop)
 			p_ere_exp(p, reclimit);
 		(void)REQUIRE(HERE() != conc, REG_EMPTY);	/* require nonempty */
 @@ -336,36 +336,36 @@ p_ere(register struct parse *p, int stop
 		EMIT(OOR2, 0);			/* offset is very wrong */
+	}
 	if (!first) {		/* tail-end fixups */
 		AHEAD(prevfwd);
 		ASTERN(O_CH, prevback);
+	}
 	assert(!MORE() || SEE(stop));
+}
 /*
  - p_ere_exp - parse one subERE, an atom possibly followed by a repetition op
- == static void p_ere_exp(register struct parse *p);
+ == static void p_ere_exp(struct parse *p);
  */
 static void
-p_ere_exp(register struct parse *p, size_t reclimit)
+p_ere_exp(struct parse *p, size_t reclimit)
+{
-	register char c;
+	char c;
-	register sopno pos;
+	sopno pos;
-	register int count;
+	int count;
-	register int count2;
+	int count2;
-	register sopno subno;
+	sopno subno;
 	int wascaret = 0;
 	assert(MORE());		/* caller should have ensured this */
 	c = GETNEXT();
 	pos = HERE();
 	switch (c) {
 	case '(':
 		(void)REQUIRE(MORE(), REG_EPAREN);
 		p->g->nsub++;
 		subno = p->g->nsub;
 		if (subno < NPAREN)
 			p->pbegin[subno] = HERE();
 @@ -484,57 +484,57 @@ p_ere_exp(register struct parse *p, size
+	}
 	if (!MORE())
 		return;
 	c = PEEK();
 	if (!( c == '*' || c == '+' || c == '?' ||
 				(c == '{' && MORE2() && ISDIGIT((UCHAR_T)PEEK2())) ) )
 		return;
 	SETERROR(REG_BADRPT);
+}
 /*
  - p_str - string (no metacharacters) "parser"
- == static void p_str(register struct parse *p);
+ == static void p_str(struct parse *p);
  */
 static void
-p_str(register struct parse *p)
+p_str(struct parse *p)
+{
 	(void)REQUIRE(MORE(), REG_EMPTY);
 	while (MORE())
 		ordinary(p, GETNEXT());
+}
 /*
  - p_bre - BRE parser top level, anchoring and concatenation
- == static void p_bre(register struct parse *p, register int end1, \
+ == static void p_bre(struct parse *p, int end1, \
- ==	register int end2, size_t reclimit);
+ ==	int end2, size_t reclimit);
  * Giving end1 as OUT essentially eliminates the end1/end2 check.
+ *
  * This implementation is a bit of a kludge, in that a trailing $ is first
  * taken as an ordinary character and then revised to be an anchor.  The
  * only undesirable side effect is that '$' gets included as a character
  * category in such cases.  This is fairly harmless; not worth fixing.
  * The amount of lookahead needed to avoid this kludge is excessive.
  */
 static void
-p_bre(register struct parse *p, register int end1, register int end2, size_t reclimit)
+p_bre(struct parse *p, int end1, int end2, size_t reclimit)
                   		/* first terminating character */
                   		/* second terminating character */
+{
-	register sopno start;
+	sopno start;
-	register int first = 1;			/* first subexpression? */
+	int first = 1;			/* first subexpression? */
-	register int wasdollar = 0;
+	int wasdollar = 0;
 	if (reclimit++ > RECLIMIT || p->error == REG_ESPACE) {
 		p->error = REG_ESPACE;
 		return;
+	}
 	start = HERE();
 	if (EAT('^')) {
 		EMIT(OBOL, 0);
 		p->g->iflags |= USEBOL;
 		p->g->nbol++;
+	}
 @@ -544,39 +544,39 @@ p_bre(register struct parse *p, register
+	}
 	if (wasdollar) {	/* oops, that was a trailing anchor */
 		DROP(1);
 		EMIT(OEOL, 0);
 		p->g->iflags |= USEEOL;
 		p->g->neol++;
+	}
 	(void)REQUIRE(HERE() != start, REG_EMPTY);	/* require nonempty */
+}
 /*
  - p_simp_re - parse a simple RE, an atom possibly followed by a repetition
- == static int p_simp_re(register struct parse *p, int starordinary, size_t reclimit);
+ == static int p_simp_re(struct parse *p, int starordinary, size_t reclimit);
  */
 static int			/* was the simple RE an unbackslashed $? */
-p_simp_re(register struct parse *p, int starordinary, size_t reclimit)
+p_simp_re(struct parse *p, int starordinary, size_t reclimit)
                  		/* is a leading * an ordinary character? */
+{
-	register int c;
+	int c;
-	register int count;
+	int count;
-	register int count2;
+	int count2;
-	register sopno pos;
+	sopno pos;
-	register int i;
+	int i;
-	register sopno subno;
+	sopno subno;
 	int backsl;
 	pos = HERE();		/* repetion op, if any, covers from here */
 	assert(MORE());		/* caller should have ensured this */
 	c = GETNEXT();
 	backsl = c == '\\';
 	if (backsl) {
 		(void)REQUIRE(MORE(), REG_EESCAPE);
 		c = (unsigned char)GETNEXT();
 		switch (c) {
 		case '{':
 			SETERROR(REG_BADRPT);
 @@ -669,55 +669,55 @@ p_simp_re(register struct parse *p, int
 			while (MORE() && !SEETWO('\\', '}'))
 				NEXT();
 			(void)REQUIRE(MORE(), REG_EBRACE);
 			SETERROR(REG_BADBR);
+		}
 	} else if (!backsl && c == (unsigned char)'$')	/* $ (but not \$) ends it */
 		return(1);
 	return(0);
+}
 /*
  - p_count - parse a repetition count
- == static int p_count(register struct parse *p);
+ == static int p_count(struct parse *p);
  */
 static int			/* the value */
-p_count(register struct parse *p)
+p_count(struct parse *p)
+{
-	register int count = 0;
+	int count = 0;
-	register int ndigits = 0;
+	int ndigits = 0;
 	while (MORE() && ISDIGIT((UCHAR_T)PEEK()) && count <= DUPMAX) {
 		count = count*10 + (GETNEXT() - '0');
 		ndigits++;
+	}
 	(void)REQUIRE(ndigits > 0 && count <= DUPMAX, REG_BADBR);
 	return(count);
+}
 /*
  - p_bracket - parse a bracketed character list
- == static void p_bracket(register struct parse *p);
+ == static void p_bracket(struct parse *p);
+ *
  * Note a significant property of this code:  if the allocset() did SETERROR,
  * no set operations are done.
  */
 static void
-p_bracket(register struct parse *p)
+p_bracket(struct parse *p)
+{
-	register cset *cs;
+	cset *cs;
-	register int invert = 0;
+	int invert = 0;
 	static RCHAR_T bow[] = { '[', ':', '<', ':', ']', ']' };
 	static RCHAR_T eow[] = { '[', ':', '>', ':', ']', ']' };
 	cs = allocset(p);
 	if (cs == NULL)
 		return;
 	/* Dept of Truly Sickening Special-Case Kludges */
 	if (p->next + 5 < p->end && MEMCMP(p->next, bow, 6) == 0) {
 		EMIT(OBOW, 0);
 		NEXTn(6);
 		return;
+	}
 @@ -733,71 +733,71 @@ p_bracket(register struct parse *p)
 		CHadd(cs, ']');
 	else if (EAT('-'))
 		CHadd(cs, '-');
 	while (MORE() && PEEK() != ']' && !SEETWO('-', ']'))
 		p_b_term(p, cs);
 	if (EAT('-'))
 		CHadd(cs, '-');
 	(void)MUSTEAT(']', REG_EBRACK);
 	if (p->error != 0)	/* don't mess things up further */
 		return;
 	if (p->g->cflags&REG_ICASE) {
-		register int i;
+		int i;
-		register int ci;
+		int ci;
 		for (i = p->g->csetsize - 1; i >= 0; i--)
 			if (CHIN(cs, i) && isalpha(i)) {
 				ci = othercase(i);
 				if (ci != i)
 					CHadd(cs, ci);
+			}
 		if (cs->multis != NULL)
 			mccase(p, cs);
+	}
 	if (invert) {
-		register int i;
+		int i;
 		for (i = p->g->csetsize - 1; i >= 0; i--)
 			if (CHIN(cs, i))
 				CHsub(cs, i);
 			else
 				CHadd(cs, i);
 		if (p->g->cflags&REG_NEWLINE)
 			CHsub(cs, '\n');
 		if (cs->multis != NULL)
 			mcinvert(p, cs);
+	}
 	assert(cs->multis == NULL);		/* xxx */
 	if (nch(p, cs) == 1) {		/* optimize singleton sets */
 		ordinary(p, firstch(p, cs));
 		freeset(p, cs);
 	} else
 		EMIT(OANYOF, freezeset(p, cs));
+}
 /*
  - p_b_term - parse one term of a bracketed character list
- == static void p_b_term(register struct parse *p, register cset *cs);
+ == static void p_b_term(struct parse *p, cset *cs);
  */
 static void
-p_b_term(register struct parse *p, register cset *cs)
+p_b_term(struct parse *p, cset *cs)
+{
-	register char c;
+	char c;
-	register char start, finish;
+	char start, finish;
-	register int i;
+	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;
 @@ -834,102 +834,102 @@ p_b_term(register struct parse *p, regis
 				finish = p_b_symbol(p);
 		} else
 			finish = start;
 /* xxx what about signed chars here... */
 		(void)REQUIRE(start <= finish, REG_ERANGE);
 		for (i = start; i <= finish; i++)
 			CHadd(cs, i);
 		break;
+	}
+}
 /*
  - p_b_cclass - parse a character-class name and deal with it
- == static void p_b_cclass(register struct parse *p, register cset *cs);
+ == static void p_b_cclass(struct parse *p, cset *cs);
  */
 static void
-p_b_cclass(register struct parse *p, register cset *cs)
+p_b_cclass(struct parse *p, cset *cs)
+{
-	register RCHAR_T *sp = p->next;
+	RCHAR_T *sp = p->next;
-	register struct cclass *cp;
+	struct cclass *cp;
-	register size_t len;
+	size_t len;
-	register const char *u;
+	const char *u;
-	register char c;
+	char c;
 	while (MORE() && isalpha(PEEK()))
 		NEXT();
 	len = p->next - sp;
 	for (cp = cclasses; cp->name != NULL; cp++)
 		if (STRLEN(cp->name) == len && !MEMCMP(cp->name, sp, len))
 			break;
 	if (cp->name == NULL) {
 		/* oops, didn't find it */
 		SETERROR(REG_ECTYPE);
 		return;
+	}
 	u = cp->chars;
 	while ((c = *u++) != '\0')
 		CHadd(cs, c);
 	for (u = cp->multis; *u != '\0'; u += strlen(u) + 1)
 		MCadd(p, cs, u);
+}
 /*
  - p_b_eclass - parse an equivalence-class name and deal with it
- == static void p_b_eclass(register struct parse *p, register cset *cs);
+ == static void p_b_eclass(struct parse *p, cset *cs);
+ *
  * This implementation is incomplete. xxx
  */
 static void
-p_b_eclass(register struct parse *p, register cset *cs)
+p_b_eclass(struct parse *p, cset *cs)
+{
-	register char c;
+	char c;
 	c = p_b_coll_elem(p, '=');
 	CHadd(cs, c);
+}
 /*
  - p_b_symbol - parse a character or [..]ed multicharacter collating symbol
- == static char p_b_symbol(register struct parse *p);
+ == static char p_b_symbol(struct parse *p);
  */
 static char			/* value of symbol */
-p_b_symbol(register struct parse *p)
+p_b_symbol(struct parse *p)
+{
-	register char value;
+	char value;
 	(void)REQUIRE(MORE(), REG_EBRACK);
 	if (!EATTWO('[', '.'))
 		return(GETNEXT());
 	/* collating symbol */
 	value = p_b_coll_elem(p, '.');
 	(void)REQUIRE(EATTWO('.', ']'), REG_ECOLLATE);
 	return(value);
+}
 /*
  - p_b_coll_elem - parse a collating-element name and look it up
- == static char p_b_coll_elem(register struct parse *p, int endc);
+ == static char p_b_coll_elem(struct parse *p, int endc);
  */
 static char			/* value of collating element */
-p_b_coll_elem(register struct parse *p, int endc)
+p_b_coll_elem(struct parse *p, int endc)
          			/* name ended by endc,']' */
+{
-	register RCHAR_T *sp = p->next;
+	RCHAR_T *sp = p->next;
-	register struct cname *cp;
+	struct cname *cp;
-	register size_t len;
+	size_t len;
 	while (MORE() && !SEETWO(endc, ']'))
 		NEXT();
 	if (!MORE()) {
 		SETERROR(REG_EBRACK);
 		return(0);
+	}
 	len = p->next - sp;
 	for (cp = cnames; cp->name != NULL; cp++)
 		if (STRLEN(cp->name) == len && MEMCMP(cp->name, sp, len))
 			return(cp->code);	/* known name */
 	if (len == 1)
 		return(*sp);	/* single character */
 @@ -945,113 +945,113 @@ static char			/* if no counterpart, retu
 othercase(int ch)
+{
 	assert(isalpha(ch));
 	if (isupper(ch))
 		return(tolower(ch));
 	else if (islower(ch))
 		return(toupper(ch));
 	else			/* peculiar, but could happen */
 		return(ch);
+}
 /*
  - bothcases - emit a dualcase version of a two-case character
- == static void bothcases(register struct parse *p, int ch);
+ == static void bothcases(struct parse *p, int ch);
+ *
  * Boy, is this implementation ever a kludge...
  */
 static void
-bothcases(register struct parse *p, int ch)
+bothcases(struct parse *p, int ch)
+{
-	register RCHAR_T *oldnext = p->next;
+	RCHAR_T *oldnext = p->next;
-	register RCHAR_T *oldend = p->end;
+	RCHAR_T *oldend = p->end;
 	RCHAR_T bracket[3];
 	assert(othercase(ch) != ch);	/* p_bracket() would recurse */
 	p->next = bracket;
 	p->end = bracket+2;
 	bracket[0] = ch;
 	bracket[1] = ']';
 	bracket[2] = '\0';
 	p_bracket(p);
 	assert(p->next == bracket+2);
 	p->next = oldnext;
 	p->end = oldend;
+}
 /*
  - ordinary - emit an ordinary character
- == static void ordinary(register struct parse *p, register int ch);
+ == static void ordinary(struct parse *p, int ch);
  */
 static void
-ordinary(register struct parse *p, register int ch)
+ordinary(struct parse *p, int ch)
+{
 /*
-	register cat_t *cap = p->g->categories;
+	cat_t *cap = p->g->categories;
 */
 	if ((p->g->cflags&REG_ICASE) && isalpha(ch) && othercase(ch) != ch)
 		bothcases(p, ch);
 	else {
 		EMIT(OCHAR, (UCHAR_T)ch);
 /*
 		if (cap[ch] == 0)
 			cap[ch] = p->g->ncategories++;
 */
+	}
+}
 /*
  - nonnewline - emit REG_NEWLINE version of OANY
- == static void nonnewline(register struct parse *p);
+ == static void nonnewline(struct parse *p);
+ *
  * Boy, is this implementation ever a kludge...
  */
 static void
-nonnewline(register struct parse *p)
+nonnewline(struct parse *p)
+{
-	register RCHAR_T *oldnext = p->next;
+	RCHAR_T *oldnext = p->next;
-	register RCHAR_T *oldend = p->end;
+	RCHAR_T *oldend = p->end;
 	RCHAR_T bracket[4];
 	p->next = bracket;
 	p->end = bracket+3;
 	bracket[0] = '^';
 	bracket[1] = '\n';
 	bracket[2] = ']';
 	bracket[3] = '\0';
 	p_bracket(p);
 	assert(p->next == bracket+3);
 	p->next = oldnext;
 	p->end = oldend;
+}
 /*
  - repeat - generate code for a bounded repetition, recursively if needed
- == static void repeat(register struct parse *p, sopno start, int from, int to, size_t reclimit);
+ == static void repeat(struct parse *p, sopno start, int from, int to, size_t reclimit);
  */
 static void
-repeat(register struct parse *p, sopno start, int from, int to, size_t reclimit)
+repeat(struct parse *p, sopno start, int from, int to, size_t reclimit)
             			/* operand from here to end of strip */
          			/* repeated from this number */
        				/* to this number of times (maybe INFINITY) */
+{
-	register sopno finish;
+	sopno finish;
 #	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;
+	sopno copy;
 	if (reclimit++ > RECLIMIT)
 		p->error = REG_ESPACE;
 	if (p->error)
 		return;
 	finish = HERE();
 	assert(from <= to);
 	switch (REP(MAP(from), MAP(to))) {
 	case REP(0, 0):			/* must be user doing this */
 		DROP(finish-start);	/* drop the operand */
 @@ -1093,51 +1093,51 @@ repeat(register struct parse *p, sopno s
 		break;
 	case REP(N, INF):		/* as xx{n-1,INF} */
 		copy = dupl(p, start, finish);
 		repeat(p, copy, from-1, to, reclimit);
 		break;
 	default:			/* "can't happen" */
 		SETERROR(REG_ASSERT);	/* just in case */
 		break;
+	}
+}
 /*
  - seterr - set an error condition
- == static int seterr(register struct parse *p, int e);
+ == static int seterr(struct parse *p, int e);
  */
 static int			/* useless but makes type checking happy */
-seterr(register struct parse *p, int e)
+seterr(struct parse *p, int e)
+{
 	if (p->error == 0)	/* keep earliest error condition */
 		p->error = e;
 	p->next = nuls;		/* try to bring things to a halt */
 	p->end = nuls;
 	return(0);		/* make the return value well-defined */
+}
 /*
  - allocset - allocate a set of characters for []
- == static cset *allocset(register struct parse *p);
+ == static cset *allocset(struct parse *p);
  */
 static cset *
-allocset(register struct parse *p)
+allocset(struct parse *p)
+{
-	register int no = p->g->ncsets++;
+	int no = p->g->ncsets++;
-	register size_t nc;
+	size_t nc;
-	register size_t nbytes;
+	size_t nbytes;
-	register cset *cs;
+	cset *cs;
-	register size_t css = (size_t)p->g->csetsize;
+	size_t css = (size_t)p->g->csetsize;
-	register int i;
+	int i;
 	if (no >= p->ncsalloc) {	/* need another column of space */
 		p->ncsalloc += CHAR_BIT;
 		nc = p->ncsalloc;
 		assert(nc % CHAR_BIT == 0);
 		nbytes = nc / CHAR_BIT * css;
 		if (MEMSIZE(p) > MEMLIMIT)
 			goto oomem;
 		if (p->g->sets == NULL)
 			p->g->sets = (cset *)malloc(nc * sizeof(cset));
 		else
 			p->g->sets = (cset *)realloc((char *)p->g->sets,
 							nc * sizeof(cset));
 @@ -1164,351 +1164,351 @@ oomem:
 	cs = &p->g->sets[no];
 	cs->ptr = p->g->setbits + css*((no)/CHAR_BIT);
 	cs->mask = 1 << ((no) % CHAR_BIT);
 	cs->hash = 0;
 	cs->smultis = 0;
 	cs->multis = NULL;
 	return(cs);
+}
 /*
  - freeset - free a now-unused set
- == static void freeset(register struct parse *p, register cset *cs);
+ == static void freeset(struct parse *p, cset *cs);
  */
 static void
-freeset(register struct parse *p, register cset *cs)
+freeset(struct parse *p, cset *cs)
+{
-	register size_t i;
+	size_t i;
-	register cset *top = &p->g->sets[p->g->ncsets];
+	cset *top = &p->g->sets[p->g->ncsets];
-	register size_t css = (size_t)p->g->csetsize;
+	size_t css = (size_t)p->g->csetsize;
 	for (i = 0; i < css; i++)
 		CHsub(cs, i);
 	if (cs == top-1)	/* recover only the easy case */
 		p->g->ncsets--;
+}
 /*
  - freezeset - final processing on a set of characters
- == static int freezeset(register struct parse *p, register cset *cs);
+ == static int freezeset(struct parse *p, cset *cs);
+ *
  * The main task here is merging identical sets.  This is usually a waste
  * of time (although the hash code minimizes the overhead), but can win
  * big if REG_ICASE is being used.  REG_ICASE, by the way, is why the hash
  * is done using addition rather than xor -- all ASCII [aA] sets xor to
  * the same value!
  */
 static int			/* set number */
-freezeset(register struct parse *p, register cset *cs)
+freezeset(struct parse *p, cset *cs)
+{
-	register uch h = cs->hash;
+	uch h = cs->hash;
-	register size_t i;
+	size_t i;
-	register cset *top = &p->g->sets[p->g->ncsets];
+	cset *top = &p->g->sets[p->g->ncsets];
-	register cset *cs2;
+	cset *cs2;
-	register size_t css = (size_t)p->g->csetsize;
+	size_t css = (size_t)p->g->csetsize;
 	/* look for an earlier one which is the same */
 	for (cs2 = &p->g->sets[0]; cs2 < top; cs2++)
 		if (cs2->hash == h && cs2 != cs) {
 			/* maybe */
 			for (i = 0; i < css; i++)
 				if (!!CHIN(cs2, i) != !!CHIN(cs, i))
 					break;		/* no */
 			if (i == css)
 				break;			/* yes */
+		}
 	if (cs2 < top) {	/* found one */
 		freeset(p, cs);
 		cs = cs2;
+	}
 	return((int)(cs - p->g->sets));
+}
 /*
  - firstch - return first character in a set (which must have at least one)
- == static int firstch(register struct parse *p, register cset *cs);
+ == static int firstch(struct parse *p, cset *cs);
  */
 static int			/* character; there is no "none" value */
-firstch(register struct parse *p, register cset *cs)
+firstch(struct parse *p, cset *cs)
+{
-	register size_t i;
+	size_t i;
-	register size_t css = (size_t)p->g->csetsize;
+	size_t css = (size_t)p->g->csetsize;
 	for (i = 0; i < css; i++)
 		if (CHIN(cs, i))
 			return((char)i);
 	assert(never);
 	return(0);		/* arbitrary */
+}
 /*
  - nch - number of characters in a set
- == static int nch(register struct parse *p, register cset *cs);
+ == static int nch(struct parse *p, cset *cs);
  */
 static int
-nch(register struct parse *p, register cset *cs)
+nch(struct parse *p, cset *cs)
+{
-	register size_t i;
+	size_t i;
-	register size_t css = (size_t)p->g->csetsize;
+	size_t css = (size_t)p->g->csetsize;
-	register int n = 0;
+	int n = 0;
 	for (i = 0; i < css; i++)
 		if (CHIN(cs, i))
 			n++;
 	return(n);
+}
 /*
  - mcadd - add a collating element to a cset
- == static void mcadd(register struct parse *p, register cset *cs, \
+ == static void mcadd(struct parse *p, cset *cs, \
- ==	register char *cp);
+ ==	char *cp);
  */
 static void
-mcadd(register struct parse *p, register cset *cs, register const char *cp)
+mcadd(struct parse *p, cset *cs, const char *cp)
+{
-	register size_t oldend = cs->smultis;
+	size_t oldend = cs->smultis;
 	cs->smultis += strlen(cp) + 1;
 	if (cs->multis == NULL)
 		cs->multis = malloc(cs->smultis);
 	else
 		cs->multis = realloc(cs->multis, cs->smultis);
 	if (cs->multis == NULL) {
 		SETERROR(REG_ESPACE);
 		return;
+	}
 	(void) strcpy(cs->multis + oldend - 1, cp);
 	cs->multis[cs->smultis - 1] = '\0';
+}
 #ifdef notdef
 /*
  - mcsub - subtract a collating element from a cset
- == static void mcsub(register cset *cs, register char *cp);
+ == static void mcsub(cset *cs, char *cp);
  */
 static void
-mcsub(register cset *cs, register char *cp)
+mcsub(cset *cs, char *cp)
+{
-	register char *fp = mcfind(cs, cp);
+	char *fp = mcfind(cs, cp);
-	register size_t len = strlen(fp);
+	size_t len = strlen(fp);
 	assert(fp != NULL);
 	(void) memmove(fp, fp + len + 1,
 				cs->smultis - (fp + len + 1 - cs->multis));
 	cs->smultis -= len;
 	if (cs->smultis == 0) {
 		free(cs->multis);
 		cs->multis = NULL;
 		return;
+	}
 	cs->multis = realloc(cs->multis, cs->smultis);
 	assert(cs->multis != NULL);
+}
 /*
  - mcin - is a collating element in a cset?
- == static int mcin(register cset *cs, register char *cp);
+ == static int mcin(cset *cs, char *cp);
  */
 static int
-mcin(register cset *cs, register char *cp)
+mcin(cset *cs, char *cp)
+{
 	return(mcfind(cs, cp) != NULL);
+}
 /*
  - mcfind - find a collating element in a cset
- == static char *mcfind(register cset *cs, register char *cp);
+ == static char *mcfind(cset *cs, char *cp);
  */
 static char *
-mcfind(register cset *cs, register char *cp)
+mcfind(cset *cs, char *cp)
+{
-	register char *p;
+	char *p;
 	if (cs->multis == NULL)
 		return(NULL);
 	for (p = cs->multis; *p != '\0'; p += strlen(p) + 1)
 		if (strcmp(cp, p) == 0)
 			return(p);
 	return(NULL);
+}
 #endif
 /*
  - mcinvert - invert the list of collating elements in a cset
- == static void mcinvert(register struct parse *p, register cset *cs);
+ == static void mcinvert(struct parse *p, cset *cs);
+ *
  * This would have to know the set of possibilities.  Implementation
  * is deferred.
  */
 static void
-mcinvert(register struct parse *p, register cset *cs)
+mcinvert(struct parse *p, cset *cs)
+{
 	assert(cs->multis == NULL);	/* xxx */
+}
 /*
  - mccase - add case counterparts of the list of collating elements in a cset
- == static void mccase(register struct parse *p, register cset *cs);
+ == static void mccase(struct parse *p, cset *cs);
+ *
  * This would have to know the set of possibilities.  Implementation
  * is deferred.
  */
 static void
-mccase(register struct parse *p, register cset *cs)
+mccase(struct parse *p, cset *cs)
+{
 	assert(cs->multis == NULL);	/* xxx */
+}
 #ifdef notdef
 /*
  - isinsets - is this character in any sets?
- == static int isinsets(register struct re_guts *g, int c);
+ == static int isinsets(struct re_guts *g, int c);
  */
 static int			/* predicate */
-isinsets(register struct re_guts *g, int c)
+isinsets(struct re_guts *g, int c)
+{
-	register uch *col;
+	uch *col;
-	register int i;
+	int i;
-	register int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
+	int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
-	register unsigned uc = (unsigned char)c;
+	unsigned uc = (unsigned char)c;
 	for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
 		if (col[uc] != 0)
 			return(1);
 	return(0);
+}
 /*
  - samesets - are these two characters in exactly the same sets?
- == static int samesets(register struct re_guts *g, int c1, int c2);
+ == static int samesets(struct re_guts *g, int c1, int c2);
  */
 static int			/* predicate */
-samesets(register struct re_guts *g, int c1, int c2)
+samesets(struct re_guts *g, int c1, int c2)
+{
-	register uch *col;
+	uch *col;
-	register int i;
+	int i;
-	register int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
+	int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
-	register unsigned uc1 = (unsigned char)c1;
+	unsigned uc1 = (unsigned char)c1;
-	register unsigned uc2 = (unsigned char)c2;
+	unsigned uc2 = (unsigned char)c2;
 	for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
 		if (col[uc1] != col[uc2])
 			return(0);
 	return(1);
+}
 #endif
 /*
  - categorize - sort out character categories
- == static void categorize(struct parse *p, register struct re_guts *g);
+ == static void categorize(struct parse *p, struct re_guts *g);
  */
 static void
-categorize(struct parse *p, register struct re_guts *g)
+categorize(struct parse *p, struct re_guts *g)
+{
 #ifdef notdef
-	register cat_t *cats = g->categories;
+	cat_t *cats = g->categories;
-	register int c;
+	int c;
-	register int c2;
+	int c2;
-	register cat_t cat;
+	cat_t cat;
 	/* avoid making error situations worse */
 	if (p->error != 0)
 		return;
 	for (c = CHAR_MIN; c <= CHAR_MAX; c++)
 		if (cats[c] == 0 && isinsets(g, c)) {
 			cat = g->ncategories++;
 			cats[c] = cat;
 			for (c2 = c+1; c2 <= CHAR_MAX; c2++)
 				if (cats[c2] == 0 && samesets(g, c, c2))
 					cats[c2] = cat;
+		}
 #endif
+}
 /*
  - dupl - emit a duplicate of a bunch of sops
- == static sopno dupl(register struct parse *p, sopno start, sopno finish);
+ == static sopno dupl(struct parse *p, sopno start, sopno finish);
  */
 static sopno			/* start of duplicate */
-dupl(register struct parse *p, sopno start, sopno finish)
+dupl(struct parse *p, sopno start, sopno finish)
             			/* from here */
              			/* to this less one */
+{
-	register sopno ret = HERE();
+	sopno ret = HERE();
-	register sopno len = finish - start;
+	sopno len = finish - start;
 	assert(finish >= start);
 	if (len == 0)
 		return(ret);
 	if (!enlarge(p, p->ssize + len))	/* this many unexpected additions */
 		return ret;
 	assert(p->ssize >= p->slen + len);
 	(void) memcpy((char *)(p->strip + p->slen),
 		(char *)(p->strip + start), (size_t)len*sizeof(sop));
 	(void) memcpy((char *)(p->stripdata + p->slen),
 		(char *)(p->stripdata + start), (size_t)len*sizeof(RCHAR_T));
 	p->slen += len;
 	return(ret);
+}
 /*
  - doemit - emit a strip operator
- == static void doemit(register struct parse *p, sop op, size_t opnd);
+ == static void doemit(struct parse *p, sop op, size_t opnd);
+ *
  * It might seem better to implement this as a macro with a function as
  * hard-case backup, but it's just too big and messy unless there are
  * some changes to the data structures.  Maybe later.
  */
 static void
-doemit(register struct parse *p, sop op, size_t opnd)
+doemit(struct parse *p, sop op, size_t opnd)
+{
 	/* avoid making error situations worse */
 	if (p->error != 0)
 		return;
 	/* deal with oversize operands ("can't happen", more or less) */
 	assert(opnd < 1);
 	/* deal with undersized strip */
 	if (p->slen >= p->ssize)
 		if (!enlarge(p, (p->ssize+1) / 2 * 3))	/* +50% */
 			return;
 	/* finally, it's all reduced to the easy case */
 	p->strip[p->slen] = op;
 	p->stripdata[p->slen] = opnd;
 	p->slen++;
+}
 /*
  - doinsert - insert a sop into the strip
- == static void doinsert(register struct parse *p, sop op, size_t opnd, sopno pos);
+ == static void doinsert(struct parse *p, sop op, size_t opnd, sopno pos);
  */
 static void
-doinsert(register struct parse *p, sop op, size_t opnd, sopno pos)
+doinsert(struct parse *p, sop op, size_t opnd, sopno pos)
+{
-	register sopno sn;
+	sopno sn;
-	register sop s;
+	sop s;
-	register RCHAR_T d;
+	RCHAR_T d;
-	register int i;
+	int i;
 	/* avoid making error situations worse */
 	if (p->error != 0)
 		return;
 	sn = HERE();
 	EMIT(op, opnd);		/* do checks, ensure space */
 	assert(HERE() == sn+1);
 	s = p->strip[sn];
 	d = p->stripdata[sn];
 	/* adjust paren pointers */
 	assert(pos > 0);
 @@ -1521,118 +1521,118 @@ doinsert(register struct parse *p, sop o
+		}
+	}
 	memmove((char *)&p->strip[pos+1], (char *)&p->strip[pos],
 						(HERE()-pos-1)*sizeof(sop));
 	memmove((char *)&p->stripdata[pos+1], (char *)&p->stripdata[pos],
 						(HERE()-pos-1)*sizeof(RCHAR_T));
 	p->strip[pos] = s;
 	p->stripdata[pos] = d;
+}
 /*
  - dofwd - complete a forward reference
- == static void dofwd(register struct parse *p, sopno pos, sop value);
+ == static void dofwd(struct parse *p, sopno pos, sop value);
  */
 static void
-dofwd(register struct parse *p, register sopno pos, sop value)
+dofwd(struct parse *p, sopno pos, sop value)
+{
 	/* avoid making error situations worse */
 	if (p->error != 0)
 		return;
 	assert(value < 1);
 	p->stripdata[pos] = value;
+}
 /*
  - enlarge - enlarge the strip
- == static int enlarge(register struct parse *p, sopno size);
+ == static int enlarge(struct parse *p, sopno size);
  */
 static int
-enlarge(register struct parse *p, register sopno size)
+enlarge(struct parse *p, sopno size)
+{
-	register sop *sp;
+	sop *sp;
-	register RCHAR_T *dp;
+	RCHAR_T *dp;
 	sopno osize;
 	if (p->ssize >= size)
 		return 1;
 	osize = p->ssize;
 	p->ssize = size;
 	if (MEMSIZE(p) > MEMLIMIT)
 		goto oomem;
 	sp = realloc(p->strip, p->ssize * sizeof(sop));
 	if (sp == NULL)
 		goto oomem;
 	p->strip = sp;
 	dp = realloc(p->stripdata, p->ssize * sizeof(RCHAR_T));
 	if (dp == NULL) {
 oomem:
 		p->ssize = osize;
 		SETERROR(REG_ESPACE);
 		return 0;
+	}
 	p->stripdata = dp;
 	return 1;
+}
 /*
  - stripsnug - compact the strip
- == static void stripsnug(register struct parse *p, register struct re_guts *g);
+ == static void stripsnug(struct parse *p, struct re_guts *g);
  */
 static void
-stripsnug(register struct parse *p, register struct re_guts *g)
+stripsnug(struct parse *p, struct re_guts *g)
+{
 	g->nstates = p->slen;
 	g->strip = (sop *)realloc((char *)p->strip,
 	    p->slen * sizeof(sop));
 	if (g->strip == NULL) {
 		SETERROR(REG_ESPACE);
 		g->strip = p->strip;
+	}
 	g->stripdata = (RCHAR_T *)realloc((char *)p->stripdata,
 	    p->slen * sizeof(RCHAR_T));
 	if (g->stripdata == NULL) {
 		SETERROR(REG_ESPACE);
 		g->stripdata = p->stripdata;
+	}
+}
 /*
  - findmust - fill in must and mlen with longest mandatory literal string
- == static void findmust(register struct parse *p, register struct re_guts *g);
+ == static void findmust(struct parse *p, struct re_guts *g);
+ *
  * This algorithm could do fancy things like analyzing the operands of |
  * for common subsequences.  Someday.  This code is simple and finds most
  * of the interesting cases.
+ *
  * Note that must and mlen got initialized during setup.
  */
 static void
-findmust(struct parse *p, register struct re_guts *g)
+findmust(struct parse *p, struct re_guts *g)
+{
-	register sop *scans;
+	sop *scans;
-	register RCHAR_T *scand;
+	RCHAR_T *scand;
 	sop *starts = 0;
 	RCHAR_T *startd = NULL;
-	register sop *newstarts = 0;
+	sop *newstarts = 0;
-	register RCHAR_T *newstartd = NULL;
+	RCHAR_T *newstartd = NULL;
-	register sopno newlen;
+	sopno newlen;
-	register sop s;
+	sop s;
-	register RCHAR_T d;
+	RCHAR_T d;
-	register RCHAR_T *cp;
+	RCHAR_T *cp;
-	register sopno i;
+	sopno i;
 	/* avoid making error situations worse */
 	if (p->error != 0)
 		return;
 	/* find the longest OCHAR sequence in strip */
 	newlen = 0;
 	scans = g->strip + 1;
 	scand = g->stripdata + 1;
 	do {
 		s = *scans++;
 		d = *scand++;
 		switch (s) {
 @@ -1692,35 +1692,35 @@ findmust(struct parse *p, register struc
 			d = *scand++;
 			if (s == OCHAR)
 				break;
+		}
 		assert(cp < g->must + g->mlen);
 		*cp++ = d;
+	}
 	assert(cp == g->must + g->mlen);
 	*cp++ = '\0';		/* just on general principles */
+}
 /*
  - pluscount - count + nesting
- == static sopno pluscount(register struct parse *p, register struct re_guts *g);
+ == static sopno pluscount(struct parse *p, struct re_guts *g);
  */
 static sopno			/* nesting depth */
-pluscount(struct parse *p, register struct re_guts *g)
+pluscount(struct parse *p, struct re_guts *g)
+{
-	register sop *scan;
+	sop *scan;
-	register sop s;
+	sop s;
-	register sopno plusnest = 0;
+	sopno plusnest = 0;
-	register sopno maxnest = 0;
+	sopno maxnest = 0;
 	if (p->error != 0)
 		return(0);	/* there may not be an OEND */
 	scan = g->strip + 1;
 	do {
 		s = *scan++;
 		switch (s) {
 		case OPLUS_:
 			plusnest++;
 			break;
 		case O_PLUS:
 			if (plusnest > maxnest)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: regerror.c,v 1.2 2013/11/22 15:52:06 christos Exp $ */
+/*	$NetBSD: regerror.c,v 1.3 2014/01/07 21:48:12 christos Exp $ */
 /*-
  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  * Copyright (c) 1992, 1993, 1994
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Henry Spencer of the University of Toronto.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -106,30 +106,30 @@ static struct rerr {
 	{ REG_ASSERT,	"REG_ASSERT",	"\"can't happen\" -- you found a bug" },
 	{ REG_INVARG,	"REG_INVARG",	"invalid argument to regex routine" },
 	{ 0,		"",		"*** unknown regexp error code ***" },
 };
 /*
  - regerror - the interface to error numbers
  = extern size_t regerror(int, const regex_t *, char *, size_t);
  */
 /* ARGSUSED */
 size_t
 regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
+{
-	register struct rerr *r;
+	struct rerr *r;
-	register size_t len;
+	size_t len;
-	register int target = errcode &~ REG_ITOA;
+	int target = errcode &~ REG_ITOA;
-	register const char *s;
+	const char *s;
 	char convbuf[50];
 	if (errcode == REG_ATOI)
 		s = regatoi(preg, convbuf);
 	else {
 		for (r = rerrs; r->code != 0; r++)
 			if (r->code == target)
 				break;
 		if (errcode&REG_ITOA) {
 			if (r->code != 0)
 				(void) strcpy(convbuf, r->name);
 			else
 @@ -151,29 +151,29 @@ regerror(int errcode, const regex_t *pre
+	}
 	return(len);
+}
 /*
  - regatoi - internal routine to implement REG_ATOI
  == static char *regatoi(const regex_t *preg, char *localbuf);
  */
 static char *
 regatoi(const regex_t *preg, char *localbuf)
+{
 #if 0 /* we don't seem to use this and it gives a warning. */
-	register struct rerr *r;
+	struct rerr *r;
-	register size_t siz;
+	size_t siz;
-	register char *p;
+	char *p;
 	for (r = rerrs; r->code != 0; r++)
 		if (strcmp(r->name, preg->re_endp) == 0)
 			break;
 	if (r->code == 0)
 		return("0");
 	sprintf(localbuf, "%d", r->code);
 #else
 	*localbuf = '\0';
 #endif
 	return(localbuf);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: regexec.c,v 1.2 2013/11/22 15:52:06 christos Exp $ */
+/*	$NetBSD: regexec.c,v 1.3 2014/01/07 21:48:12 christos Exp $ */
 /*-
  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  * Copyright (c) 1992, 1993, 1994
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Henry Spencer of the University of Toronto.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -148,27 +148,27 @@ static int nope = 0;		/* for use in asse
  = #define	REG_NOTEOL	00002
  = #define	REG_STARTEND	00004
  = #define	REG_TRACE	00400	// tracing of execution
  = #define	REG_LARGE	01000	// force large representation
  = #define	REG_BACKR	02000	// force use of backref code
+ *
  * We put this here so we can exploit knowledge of the state representation
  * when choosing which matcher to call.  Also, by this point the matchers
  * have been prototyped.
  */
 int				/* 0 success, REG_NOMATCH failure */
 regexec(const regex_t *preg, const RCHAR_T *string, size_t nmatch, regmatch_t *pmatch, int eflags)
+{
-	register struct re_guts *g = preg->re_g;
+	struct re_guts *g = preg->re_g;
 #ifdef REDEBUG
 #	define	GOODFLAGS(f)	(f)
 #else
 #	define	GOODFLAGS(f)	((f)&(REG_NOTBOL|REG_NOTEOL|REG_STARTEND))
 #endif
 	if (preg->re_magic != MAGIC1 || g->magic != MAGIC2)
 		return(REG_BADPAT);
 	assert(!(g->iflags&BAD));
 	if (g->iflags&BAD)		/* backstop for no-debug case */
 		return(REG_BADPAT);
 	eflags = GOODFLAGS(eflags);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: regfree.c,v 1.2 2013/11/22 15:52:06 christos Exp $ */
+/*	$NetBSD: regfree.c,v 1.3 2014/01/07 21:48:12 christos Exp $ */
 /*-
  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  * Copyright (c) 1992, 1993, 1994
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Henry Spencer of the University of Toronto.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -47,27 +47,27 @@ static char sccsid[] = "@(#)regfree.c	8.
 #include <stdlib.h>
 #include <regex.h>
 #include "utils.h"
 #include "regex2.h"
 /*
  - regfree - free everything
  = extern void regfree(regex_t *);
  */
 void
 regfree(regex_t *preg)
+{
-	register struct re_guts *g;
+	struct re_guts *g;
 	if (preg->re_magic != MAGIC1)	/* oops */
 		return;			/* nice to complain, but hard */
 	g = preg->re_g;
 	if (g == NULL || g->magic != MAGIC2)	/* oops again */
 		return;
 	preg->re_magic = 0;		/* mark it invalid */
 	g->magic = 0;			/* mark it invalid */
 	if (g->strip != NULL)
 		free((char *)g->strip);
 	if (g->stripdata != NULL)