Goodbye register keyword. Compiler knows better.

src/backend/regex/engine.c

@@ -150,24 +150,24 @@ extern		"C"
 
 /*
  - matcher - the actual matching engine
- == static int matcher(register struct re_guts *g, char *string, \
+ == static int matcher(struct re_guts *g, char *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;
 char	   *string;
 size_t		nmatch;
 regmatch_t	pmatch[];
 int			eflags;
 {
-	register char *endp;
-	register int i;
+	char *endp;
+	int i;
 	struct match mv;
-	register struct match *m = &mv;
-	register char *dp;
-	register const sopno gf = g->firststate + 1;		/* +1 for OEND */
-	register const sopno gl = g->laststate;
+	struct match *m = &mv;
+	char *dp;
+	const sopno gf = g->firststate + 1;		/* +1 for OEND */
+	const sopno gl = g->laststate;
 	char	   *start;
 	char	   *stop;
 
@@ -333,30 +333,30 @@ int			eflags;
 
 /*
  - dissect - figure out what matched what, no back references
- == static char *dissect(register struct match *m, char *start, \
+ == static char *dissect(struct match *m, char *start, \
  ==		char *stop, sopno startst, sopno stopst);
  */
 static char *					/* == stop (success) always */
 dissect(m, start, stop, startst, stopst)
-register struct match *m;
+struct match *m;
 char	   *start;
 char	   *stop;
 sopno		startst;
 sopno		stopst;
 {
-	register int i;
-	register sopno ss;			/* start sop of current subRE */
-	register sopno es;			/* end sop of current subRE */
-	register char *sp;			/* start of string matched by it */
-	register char *stp;			/* string matched by it cannot pass here */
-	register char *rest;		/* start of rest of string */
-	register char *tail;		/* string unmatched by rest of RE */
-	register sopno ssub;		/* start sop of subsubRE */
-	register sopno esub;		/* end sop of subsubRE */
-	register char *ssp;			/* start of string matched by subsubRE */
-	register char *sep;			/* end of string matched by subsubRE */
-	register char *oldssp;		/* previous ssp */
-	register char *dp;
+	int i;
+	sopno ss;			/* start sop of current subRE */
+	sopno es;			/* end sop of current subRE */
+	char *sp;			/* start of string matched by it */
+	char *stp;			/* string matched by it cannot pass here */
+	char *rest;		/* start of rest of string */
+	char *tail;		/* string unmatched by rest of RE */
+	sopno ssub;		/* start sop of subsubRE */
+	sopno esub;		/* end sop of subsubRE */
+	char *ssp;			/* start of string matched by subsubRE */
+	char *sep;			/* end of string matched by subsubRE */
+	char *oldssp;		/* previous ssp */
+	char *dp;
 
 	AT("diss", start, stop, startst, stopst);
 	sp = start;
@@ -533,30 +533,30 @@ sopno		stopst;
 
 /*
  - backref - figure out what matched what, figuring in back references
- == static char *backref(register struct match *m, char *start, \
+ == static char *backref(struct match *m, char *start, \
  ==		char *stop, sopno startst, sopno stopst, sopno lev);
  */
 static char *					/* == stop (success) or NULL (failure) */
 backref(m, start, stop, startst, stopst, lev)
-register struct match *m;
+struct match *m;
 char	   *start;
 char	   *stop;
 sopno		startst;
 sopno		stopst;
 sopno		lev;				/* PLUS nesting level */
 {
-	register int i;
-	register sopno ss;			/* start sop of current subRE */
-	register char *sp;			/* start of string matched by it */
-	register sopno ssub;		/* start sop of subsubRE */
-	register sopno esub;		/* end sop of subsubRE */
-	register char *ssp;			/* start of string matched by subsubRE */
-	register char *dp;
-	register size_t len;
-	register int hard;
-	register sop s;
-	register regoff_t offsave;
-	register cset *cs;
+	int i;
+	sopno ss;			/* start sop of current subRE */
+	char *sp;			/* start of string matched by it */
+	sopno ssub;		/* start sop of subsubRE */
+	sopno esub;		/* end sop of subsubRE */
+	char *ssp;			/* start of string matched by subsubRE */
+	char *dp;
+	size_t len;
+	int hard;
+	sop s;
+	regoff_t offsave;
+	cset *cs;
 
 	AT("back", start, stop, startst, stopst);
 	sp = start;
@@ -747,26 +747,26 @@ sopno		lev;				/* PLUS nesting level */
 
 /*
  - fast - step through the string at top speed
- == static char *fast(register struct match *m, char *start, \
+ == static char *fast(struct match *m, char *start, \
  ==		char *stop, sopno startst, sopno stopst);
  */
 static char *					/* where tentative match ended, or NULL */
 fast(m, start, stop, startst, stopst)
-register struct match *m;
+struct match *m;
 char	   *start;
 char	   *stop;
 sopno		startst;
 sopno		stopst;
 {
-	register states st = m->st;
-	register states fresh = m->fresh;
-	register states tmp = m->tmp;
-	register char *p = start;
-	register int c = (start == m->beginp) ? OUT : *(start - 1);
-	register int lastc;			/* previous c */
-	register int flagch;
-	register int i;
-	register char *coldp;		/* last p after which no match was
+	states st = m->st;
+	states fresh = m->fresh;
+	states tmp = m->tmp;
+	char *p = start;
+	int c = (start == m->beginp) ? OUT : *(start - 1);
+	int lastc;			/* previous c */
+	int flagch;
+	int i;
+	char *coldp;		/* last p after which no match was
 								 * underway */
 
 	CLEAR(st);
@@ -846,26 +846,26 @@ sopno		stopst;
 
 /*
  - slow - step through the string more deliberately
- == static char *slow(register struct match *m, char *start, \
+ == static char *slow(struct match *m, char *start, \
  ==		char *stop, sopno startst, sopno stopst);
  */
 static char *					/* where it ended */
 slow(m, start, stop, startst, stopst)
-register struct match *m;
+struct match *m;
 char	   *start;
 char	   *stop;
 sopno		startst;
 sopno		stopst;
 {
-	register states st = m->st;
-	register states empty = m->empty;
-	register states tmp = m->tmp;
-	register char *p = start;
-	register int c = (start == m->beginp) ? OUT : *(start - 1);
-	register int lastc;			/* previous c */
-	register int flagch;
-	register int i;
-	register char *matchp;		/* last p at which a match ended */
+	states st = m->st;
+	states empty = m->empty;
+	states tmp = m->tmp;
+	char *p = start;
+	int c = (start == m->beginp) ? OUT : *(start - 1);
+	int lastc;			/* previous c */
+	int flagch;
+	int i;
+	char *matchp;		/* last p at which a match ended */
 
 	AT("slow", start, stop, startst, stopst);
 	CLEAR(st);
@@ -940,8 +940,8 @@ sopno		stopst;
 
 /*
  - step - map set of states reachable before char to set reachable after
- == static states step(register struct re_guts *g, sopno start, sopno stop, \
- ==		register states bef, int ch, register states aft);
+ == static states step(struct re_guts *g, sopno start, sopno stop, \
+ ==		states bef, int ch, states aft);
  == #define		BOL		(OUT+1)
  == #define		EOL		(BOL+1)
  == #define		BOLEOL	(BOL+2)
@@ -954,19 +954,19 @@ sopno		stopst;
  */
 static states
 step(g, start, stop, bef, 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			ch;					/* character or NONCHAR code */
-register states aft;			/* states already known reachable after */
+states aft;			/* states already known reachable after */
 {
-	register cset *cs;
-	register sop s;
-	register sopno pc;
-	register onestate here;		/* note, macros know this name */
-	register sopno look;
-	register int i;
+	cset *cs;
+	sop s;
+	sopno pc;
+	onestate here;		/* note, macros know this name */
+	sopno look;
+	int i;
 
 	for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here))
 	{
@@ -1087,9 +1087,9 @@ states		st;
 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;