@@ -1,4 +1,4 @@
-/*	$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
@@ -130,24 +130,24 @@
 
 /*
  - 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;
-	register size_t i;
+	RCHAR_T *endp;
+	size_t i;
 	struct match mv;
-	register struct match *m = &mv;
-	register RCHAR_T *dp;
-	register const sopno gf = g->firststate+1;	/* +1 for OEND */
-	register const sopno gl = g->laststate;
+	struct match *m = &mv;
+	RCHAR_T *dp;
+	const sopno gf = g->firststate+1;	/* +1 for OEND */
+	const sopno gl = g->laststate;
 	RCHAR_T *start;
 	RCHAR_T *stop;
 
@@ -296,30 +296,30 @@
 
 /*
  - 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;
-	register sopno ss;	/* start sop of current subRE */
-	register sopno es;	/* end sop of current subRE */
-	register RCHAR_T *sp;	/* start of string matched by it */
-	register RCHAR_T *stp;	/* string matched by it cannot pass here */
-	register RCHAR_T *rest;	/* start of rest of string */
-	register RCHAR_T *tail;	/* string unmatched by rest of RE */
-	register sopno ssub;	/* start sop of subsubRE */
-	register sopno esub;	/* end sop of subsubRE */
-	register RCHAR_T *ssp;	/* start of string matched by subsubRE */
-	register RCHAR_T *sep;	/* end of string matched by subsubRE */
-	register RCHAR_T *oldssp;	/* previous ssp */
-	register RCHAR_T *dp;
+	int i;
+	sopno ss;	/* start sop of current subRE */
+	sopno es;	/* end sop of current subRE */
+	RCHAR_T *sp;	/* start of string matched by it */
+	RCHAR_T *stp;	/* string matched by it cannot pass here */
+	RCHAR_T *rest;	/* start of rest of string */
+	RCHAR_T *tail;	/* string unmatched by rest of RE */
+	sopno ssub;	/* start sop of subsubRE */
+	sopno esub;	/* end sop of subsubRE */
+	RCHAR_T *ssp;	/* start of string matched by subsubRE */
+	RCHAR_T *sep;	/* end of string matched by subsubRE */
+	RCHAR_T *oldssp;	/* previous ssp */
+	RCHAR_T *dp;
 
 	AT("diss", start, stop, startst, stopst);
 	sp = start;
@@ -485,31 +485,31 @@
 
 /*
  - 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;
-	register sopno ss;	/* start sop of current subRE */
-	register RCHAR_T *sp;	/* start of string matched by it */
-	register sopno ssub;	/* start sop of subsubRE */
-	register sopno esub;	/* end sop of subsubRE */
-	register RCHAR_T *ssp;	/* start of string matched by subsubRE */
-	register RCHAR_T *dp;
-	register size_t len;
-	register int hard;
-	register sop s;
-	register RCHAR_T d;
-	register regoff_t offsave;
-	register cset *cs;
+	int i;
+	sopno ss;	/* start sop of current subRE */
+	RCHAR_T *sp;	/* start of string matched by it */
+	sopno ssub;	/* start sop of subsubRE */
+	sopno esub;	/* end sop of subsubRE */
+	RCHAR_T *ssp;	/* start of string matched by subsubRE */
+	RCHAR_T *dp;
+	size_t len;
+	int hard;
+	sop s;
+	RCHAR_T d;
+	regoff_t offsave;
+	cset *cs;
 
 	AT("back", start, stop, startst, stopst);
 	sp = start;
@@ -698,26 +698,26 @@
 
 /*
  - 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;
-	register states fresh = m->fresh;
-	register states tmp = m->tmp;
-	register RCHAR_T *p = start;
-	register RCHAR_T c = (start == m->beginp) ? OUT : *(start-1);
-	register RCHAR_T lastc;	/* previous c */
-	register int flag;
-	register int i;
-	register RCHAR_T *coldp;	/* last p after which no match was underway */
+	states st = m->st;
+	states fresh = m->fresh;
+	states tmp = m->tmp;
+	RCHAR_T *p = start;
+	RCHAR_T c = (start == m->beginp) ? OUT : *(start-1);
+	RCHAR_T lastc;	/* previous c */
+	int flag;
+	int i;
+	RCHAR_T *coldp;	/* last p after which no match was underway */
 
 	CLEAR(st);
 	SET1(st, startst);
@@ -789,26 +789,26 @@
 
 /*
  - 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;
-	register states empty = m->empty;
-	register states tmp = m->tmp;
-	register RCHAR_T *p = start;
-	register RCHAR_T c = (start == m->beginp) ? OUT : *(start-1);
-	register RCHAR_T lastc;	/* previous c */
-	register int flag;
-	register int i;
-	register RCHAR_T *matchp;	/* last p at which a match ended */
+	states st = m->st;
+	states empty = m->empty;
+	states tmp = m->tmp;
+	RCHAR_T *p = start;
+	RCHAR_T c = (start == m->beginp) ? OUT : *(start-1);
+	RCHAR_T lastc;	/* previous c */
+	int flag;
+	int i;
+	RCHAR_T *matchp;	/* last p at which a match ended */
 
 	AT("slow", start, stop, startst, stopst);
 	CLEAR(st);
@@ -876,8 +876,8 @@
 
 /*
  - step - map set of states reachable before char to set reachable after
- == static states step(register struct re_guts *g, sopno start, sopno stop, \
- ==	register states bef, int flag, RCHAR_T ch, register states aft);
+ == static states step(struct re_guts *g, sopno start, sopno stop, \
+ ==	states bef, int flag, RCHAR_T ch, states aft);
  == #define	BOL	(1)
  == #define	EOL	(BOL+1)
  == #define	BOLEOL	(BOL+2)
@@ -887,21 +887,21 @@
  */
 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;
-	register sop s;
-	register RCHAR_T d;
-	register sopno pc;
-	register onestate here;		/* note, macros know this name */
-	register sopno look;
-	register int i;
+	cset *cs;
+	sop s;
+	RCHAR_T d;
+	sopno pc;
+	onestate here;		/* note, macros know this name */
+	sopno look;
+	int i;
 
 	for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) {
 		s = g->strip[pc];
@@ -1021,9 +1021,9 @@
 int ch;
 FILE *d;
 {
-	register struct re_guts *g = m->g;
-	register int i;
-	register int first = 1;
+	struct re_guts *g = m->g;
+	int i;
+	int first = 1;
 
 	if (!(m->eflags&REG_TRACE))
 		return;

@@ -1,4 +1,4 @@
-/*	$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
@@ -192,10 +192,10 @@
 regcomp(regex_t *preg, const RCHAR_T *pattern, int cflags)
 {
 	struct parse pa;
-	register struct re_guts *g;
-	register struct parse *p = &pa;
-	register int i;
-	register size_t len;
+	struct re_guts *g;
+	struct parse *p = &pa;
+	int i;
+	size_t len;
 #ifdef REDEBUG
 #	define	GOODFLAGS(f)	(f)
 #else
@@ -295,18 +295,18 @@
 
 /*
  - 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;
-	register sopno prevback = 0;
-	register sopno prevfwd = 0;
-	register sopno conc;
-	register int first = 1;		/* is this the first alternative? */
+	char c;
+	sopno prevback = 0;
+	sopno prevfwd = 0;
+	sopno conc;
+	int first = 1;		/* is this the first alternative? */
 
 	if (reclimit++ > RECLIMIT || p->error == REG_ESPACE) {
 		p->error = REG_ESPACE;
@@ -346,16 +346,16 @@
 
 /*
  - 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;
-	register sopno pos;
-	register int count;
-	register int count2;
-	register sopno subno;
+	char c;
+	sopno pos;
+	int count;
+	int count2;
+	sopno subno;
 	int wascaret = 0;
 
 	assert(MORE());		/* caller should have ensured this */
@@ -494,10 +494,10 @@
 
 /*
  - 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())
@@ -506,8 +506,8 @@
 
 /*
  - p_bre - BRE parser top level, anchoring and concatenation
- == static void p_bre(register struct parse *p, register int end1, \
- ==	register int end2, size_t reclimit);
+ == static void p_bre(struct parse *p, int end1, \
+ ==	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
@@ -517,14 +517,14 @@
  * 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;
-	register int first = 1;			/* first subexpression? */
-	register int wasdollar = 0;
+	sopno start;
+	int first = 1;			/* first subexpression? */
+	int wasdollar = 0;
 
 	if (reclimit++ > RECLIMIT || p->error == REG_ESPACE) {
 		p->error = REG_ESPACE;
@@ -554,19 +554,19 @@
 
 /*
  - 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;
-	register int count;
-	register int count2;
-	register sopno pos;
-	register int i;
-	register sopno subno;
+	int c;
+	int count;
+	int count2;
+	sopno pos;
+	int i;
+	sopno subno;
 	int backsl;
 
 	pos = HERE();		/* repetion op, if any, covers from here */
@@ -679,13 +679,13 @@
 
 /*
  - 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;
-	register int ndigits = 0;
+	int count = 0;
+	int ndigits = 0;
 
 	while (MORE() && ISDIGIT((UCHAR_T)PEEK()) && count <= DUPMAX) {
 		count = count*10 + (GETNEXT() - '0');
@@ -698,16 +698,16 @@
 
 /*
  - 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;
-	register int invert = 0;
+	cset *cs;
+	int invert = 0;
 	static RCHAR_T bow[] = { '[', ':', '<', ':', ']', ']' };
 	static RCHAR_T eow[] = { '[', ':', '>', ':', ']', ']' };
 
@@ -743,8 +743,8 @@
 		return;
 
 	if (p->g->cflags&REG_ICASE) {
-		register int i;
-		register int ci;
+		int i;
+		int ci;
 
 		for (i = p->g->csetsize - 1; i >= 0; i--)
 			if (CHIN(cs, i) && isalpha(i)) {
@@ -756,7 +756,7 @@
 			mccase(p, cs);
 	}
 	if (invert) {
-		register int i;
+		int i;
 
 		for (i = p->g->csetsize - 1; i >= 0; i--)
 			if (CHIN(cs, i))
@@ -780,14 +780,14 @@
 
 /*
  - 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;
-	register char start, finish;
-	register int i;
+	char c;
+	char start, finish;
+	int i;
 
 	/* classify what we've got */
 	switch ((MORE()) ? PEEK() : '\0') {
@@ -844,16 +844,16 @@
 
 /*
  - 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;
-	register struct cclass *cp;
-	register size_t len;
-	register const char *u;
-	register char c;
+	RCHAR_T *sp = p->next;
+	struct cclass *cp;
+	size_t len;
+	const char *u;
+	char c;
 
 	while (MORE() && isalpha(PEEK()))
 		NEXT();
@@ -876,14 +876,14 @@
 
 /*
  - 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);
@@ -891,12 +891,12 @@
 
 /*
  - 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('[', '.'))
@@ -910,16 +910,16 @@
 
 /*
  - 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;
-	register struct cname *cp;
-	register size_t len;
+	RCHAR_T *sp = p->next;
+	struct cname *cp;
+	size_t len;
 
 	while (MORE() && !SEETWO(endc, ']'))
 		NEXT();
@@ -955,15 +955,15 @@
 
 /*
  - 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;
-	register RCHAR_T *oldend = p->end;
+	RCHAR_T *oldnext = p->next;
+	RCHAR_T *oldend = p->end;
 	RCHAR_T bracket[3];
 
 	assert(othercase(ch) != ch);	/* p_bracket() would recurse */
@@ -980,13 +980,13 @@
 
 /*
  - 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)
@@ -1002,15 +1002,15 @@
 
 /*
  - 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;
-	register RCHAR_T *oldend = p->end;
+	RCHAR_T *oldnext = p->next;
+	RCHAR_T *oldend = p->end;
 	RCHAR_T bracket[4];
 
 	p->next = bracket;
@@ -1027,21 +1027,21 @@
 
 /*
  - 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;
@@ -1103,10 +1103,10 @@
 
 /*
  - 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;
@@ -1117,17 +1117,17 @@
 
 /*
  - 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++;
-	register size_t nc;
-	register size_t nbytes;
-	register cset *cs;
-	register size_t css = (size_t)p->g->csetsize;
-	register int i;
+	int no = p->g->ncsets++;
+	size_t nc;
+	size_t nbytes;
+	cset *cs;
+	size_t css = (size_t)p->g->csetsize;
+	int i;
 
 	if (no >= p->ncsalloc) {	/* need another column of space */
 		p->ncsalloc += CHAR_BIT;
@@ -1174,14 +1174,14 @@
 
 /*
  - 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;
-	register cset *top = &p->g->sets[p->g->ncsets];
-	register size_t css = (size_t)p->g->csetsize;
+	size_t i;
+	cset *top = &p->g->sets[p->g->ncsets];
+	size_t css = (size_t)p->g->csetsize;
 
 	for (i = 0; i < css; i++)
 		CHsub(cs, i);
@@ -1191,7 +1191,7 @@
 
 /*
  - 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
@@ -1200,13 +1200,13 @@
  * 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;
-	register size_t i;
-	register cset *top = &p->g->sets[p->g->ncsets];
-	register cset *cs2;
-	register size_t css = (size_t)p->g->csetsize;
+	uch h = cs->hash;
+	size_t i;
+	cset *top = &p->g->sets[p->g->ncsets];
+	cset *cs2;
+	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++)
@@ -1229,13 +1229,13 @@
 
 /*
  - 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;
-	register size_t css = (size_t)p->g->csetsize;
+	size_t i;
+	size_t css = (size_t)p->g->csetsize;
 
 	for (i = 0; i < css; i++)
 		if (CHIN(cs, i))
@@ -1246,14 +1246,14 @@
 
 /*
  - 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;
-	register size_t css = (size_t)p->g->csetsize;
-	register int n = 0;
+	size_t i;
+	size_t css = (size_t)p->g->csetsize;
+	int n = 0;
 
 	for (i = 0; i < css; i++)
 		if (CHIN(cs, i))
@@ -1263,13 +1263,13 @@
 
 /*
  - mcadd - add a collating element to a cset
- == static void mcadd(register struct parse *p, register cset *cs, \
- ==	register char *cp);
+ == static void mcadd(struct parse *p, cset *cs, \
+ ==	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)
@@ -1288,13 +1288,13 @@
 #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);
-	register size_t len = strlen(fp);
+	char *fp = mcfind(cs, cp);
+	size_t len = strlen(fp);
 
 	assert(fp != NULL);
 	(void) memmove(fp, fp + len + 1,
@@ -1313,22 +1313,22 @@
 
 /*
  - 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);
@@ -1341,26 +1341,26 @@
 
 /*
  - 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 */
 }
@@ -1368,15 +1368,15 @@
 #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;
-	register int i;
-	register int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
-	register unsigned uc = (unsigned char)c;
+	uch *col;
+	int i;
+	int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
+	unsigned uc = (unsigned char)c;
 
 	for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
 		if (col[uc] != 0)
@@ -1386,16 +1386,16 @@
 
 /*
  - 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;
-	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;
+	uch *col;
+	int i;
+	int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT;
+	unsigned uc1 = (unsigned char)c1;
+	unsigned uc2 = (unsigned char)c2;
 
 	for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
 		if (col[uc1] != col[uc2])
@@ -1406,16 +1406,16 @@
 
 /*
  - 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;
-	register int c;
-	register int c2;
-	register cat_t cat;
+	cat_t *cats = g->categories;
+	int c;
+	int c2;
+	cat_t cat;
 
 	/* avoid making error situations worse */
 	if (p->error != 0)
@@ -1434,16 +1434,16 @@
 
 /*
  - 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();
-	register sopno len = finish - start;
+	sopno ret = HERE();
+	sopno len = finish - start;
 
 	assert(finish >= start);
 	if (len == 0)
@@ -1461,14 +1461,14 @@
 
 /*
  - 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)
@@ -1490,15 +1490,15 @@
 
 /*
  - 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;
-	register sop s;
-	register RCHAR_T d;
-	register int i;
+	sopno sn;
+	sop s;
+	RCHAR_T d;
+	int i;
 
 	/* avoid making error situations worse */
 	if (p->error != 0)
@@ -1531,10 +1531,10 @@
 
 /*
  - 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)
@@ -1546,13 +1546,13 @@
 
 /*
  - 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;
-	register RCHAR_T *dp;
+	sop *sp;
+	RCHAR_T *dp;
 	sopno osize;
 
 	if (p->ssize >= size)
@@ -1579,10 +1579,10 @@
 
 /*
  - 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,
@@ -1601,7 +1601,7 @@
 
 /*
  - 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
@@ -1610,19 +1610,19 @@
  * 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;
-	register RCHAR_T *scand;
+	sop *scans;
+	RCHAR_T *scand;
 	sop *starts = 0;
 	RCHAR_T *startd = NULL;
-	register sop *newstarts = 0;
-	register RCHAR_T *newstartd = NULL;
-	register sopno newlen;
-	register sop s;
-	register RCHAR_T d;
-	register RCHAR_T *cp;
-	register sopno i;
+	sop *newstarts = 0;
+	RCHAR_T *newstartd = NULL;
+	sopno newlen;
+	sop s;
+	RCHAR_T d;
+	RCHAR_T *cp;
+	sopno i;
 
 	/* avoid making error situations worse */
 	if (p->error != 0)
@@ -1702,15 +1702,15 @@
 
 /*
  - 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;
-	register sop s;
-	register sopno plusnest = 0;
-	register sopno maxnest = 0;
+	sop *scan;
+	sop s;
+	sopno plusnest = 0;
+	sopno maxnest = 0;
 
 	if (p->error != 0)
 		return(0);	/* there may not be an OEND */

@@ -1,4 +1,4 @@
-/*	$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
@@ -116,10 +116,10 @@
 size_t
 regerror(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 const char *s;
+	struct rerr *r;
+	size_t len;
+	int target = errcode &~ REG_ITOA;
+	const char *s;
 	char convbuf[50];
 
 	if (errcode == REG_ATOI)
@@ -161,9 +161,9 @@
 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;
-	register size_t siz;
-	register char *p;
+	struct rerr *r;
+	size_t siz;
+	char *p;
 
 	for (r = rerrs; r->code != 0; r++)
 		if (strcmp(r->name, preg->re_endp) == 0)

@@ -1,4 +1,4 @@
-/*	$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
@@ -158,7 +158,7 @@
 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

@@ -1,4 +1,4 @@
-/*	$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
@@ -57,7 +57,7 @@
 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 */