Goodbye register keyword. Compiler knows better.

src/backend/access/common/heaptuple.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.35 1998/02/06 20:17:49 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.36 1998/02/11 19:09:21 momjian Exp $
  *
  * NOTES
  *	  The old interface functions have been converted to macros
@@ -44,12 +44,6 @@ long heap_sysoffset[] = {
 		offsetof(HeapTupleData, t_cmax)
 };
 
-/* this is so the sparcstation debugger works */
-
-#if !defined(NO_ASSERT_CHECKING) && defined(sparc) && defined(sunos4)
-#define register
-#endif							/* !NO_ASSERT_CHECKING && sparc && sunos4 */
-
 /* ----------------------------------------------------------------
  *						misc support routines
  * ----------------------------------------------------------------
@@ -476,10 +470,10 @@ nocachegetattr(HeapTuple tup,
 		 * ----------------
 		 */
 		{
-			register int i = 0; /* current offset in bp */
-			register int mask;	/* bit in byte we're looking at */
-			register char n;	/* current byte in bp */
-			register int byte,
+			int i = 0; /* current offset in bp */
+			int mask;	/* bit in byte we're looking at */
+			char n;	/* current byte in bp */
+			int byte,
 						 finalbit;
 
 			byte = attnum >> 3;
@@ -523,7 +517,7 @@ nocachegetattr(HeapTuple tup,
 		}
 		else if (!HeapTupleAllFixed(tup))
 		{
-			register int j = 0;
+			int j = 0;
 
 			/*
 			 *	In for(), we make this <= and not < because we want to
@@ -542,8 +536,8 @@ nocachegetattr(HeapTuple tup,
 	 */
 	if (!slow)
 	{
-		register int j = 1;
-		register long off;
+		int j = 1;
+		long off;
 
 		/*
 		 * need to set cache for some atts
@@ -624,9 +618,9 @@ nocachegetattr(HeapTuple tup,
 	}
 	else
 	{
-		register bool usecache = true;
-		register int off = 0;
-		register int i;
+		bool usecache = true;
+		int off = 0;
+		int i;
 
 		/*
 		 * Now we know that we have to walk the tuple CAREFULLY.
@@ -999,7 +993,7 @@ heap_addheader(uint32 natts,	/* max domain index */
 			   int structlen,	/* its length */
 			   char *structure) /* pointer to the struct */
 {
-	register char *tp;			/* tuple data pointer */
+	char 		*tp;			/* tuple data pointer */
 	HeapTuple	tup;
 	long		len;
 	int			hoff;

src/backend/access/common/indextuple.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.26 1998/02/06 20:17:51 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.27 1998/02/11 19:09:23 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -41,7 +41,7 @@ index_formtuple(TupleDesc tupleDescriptor,
 				Datum value[],
 				char null[])
 {
-	register char *tp;			/* tuple pointer */
+	char *tp;			/* tuple pointer */
 	IndexTuple	tuple;			/* return tuple */
 	Size		size,
 				hoff;
@@ -137,10 +137,10 @@ nocache_index_getattr(IndexTuple tup,
 			 TupleDesc tupleDesc,
 			 bool *isnull)
 {
-	register char *tp;			/* ptr to att in tuple */
-	register char *bp = NULL;	/* ptr to att in tuple */
+	char *tp;			/* ptr to att in tuple */
+	char *bp = NULL;	/* ptr to att in tuple */
 	int			slow;			/* do we have to walk nulls? */
-	register int data_off;		/* tuple data offset */
+	int data_off;		/* tuple data offset */
 	AttributeTupleForm *att = tupleDesc->attrs;
 
 	/* ----------------
@@ -219,10 +219,10 @@ nocache_index_getattr(IndexTuple tup,
 		 * ----------------
 		 */
 		{
-			register int i = 0; /* current offset in bp */
-			register int mask;	/* bit in byte we're looking at */
-			register char n;	/* current byte in bp */
-			register int byte,
+			int i = 0; /* current offset in bp */
+			int mask;	/* bit in byte we're looking at */
+			char n;	/* current byte in bp */
+			int byte,
 						 finalbit;
 
 			byte = attnum >> 3;
@@ -265,7 +265,7 @@ nocache_index_getattr(IndexTuple tup,
 		}
 		else if (!IndexTupleAllFixed(tup))
 		{
-			register int j = 0;
+			int j = 0;
 
 			for (j = 0; j < attnum && !slow; j++)
 				if (att[j]->attlen < 1 && !VARLENA_FIXED_SIZE(att[j]))
@@ -281,8 +281,8 @@ nocache_index_getattr(IndexTuple tup,
 
 	if (!slow)
 	{
-		register int j = 1;
-		register long off;
+		int j = 1;
+		long off;
 
 		/*
 		 * need to set cache for some atts
@@ -346,9 +346,9 @@ nocache_index_getattr(IndexTuple tup,
 	}
 	else
 	{
-		register bool usecache = true;
-		register int off = 0;
-		register int i;
+		bool usecache = true;
+		int off = 0;
+		int i;
 
 		/*
 		 * Now we know that we have to walk the tuple CAREFULLY.

src/backend/access/common/printtup.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.25 1998/02/10 16:02:44 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.26 1998/02/11 19:09:25 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -176,7 +176,7 @@ showatts(char *name, TupleDesc tupleDesc)
 void
 debugtup(HeapTuple tuple, TupleDesc typeinfo)
 {
-	register int i;
+	int i;
 	Datum	    attr;
 	char	   *value;
 	bool		isnull;

src/backend/access/heap/heapam.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.25 1998/01/07 21:01:20 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.26 1998/02/11 19:09:30 momjian Exp $
  *
  *
  * INTERFACE ROUTINES
@@ -791,7 +791,7 @@ heap_getnext(HeapScanDesc scandesc,
 			 int backw,
 			 Buffer *b)
 {
-	register HeapScanDesc sdesc = scandesc;
+	HeapScanDesc sdesc = scandesc;
 	Buffer		localb;
 
 	/* ----------------

src/backend/bootstrap/bootstrap.c

@@ -7,7 +7,7 @@
  * Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.35 1998/02/07 06:10:34 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.36 1998/02/11 19:09:34 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -979,7 +979,7 @@ LexIDStr(int ident_num)
 static int
 CompHash(char *str, int len)
 {
-	register int result;
+	int result;
 
 	result = (NUM * str[0] + NUMSQR * str[len - 1] + NUMCUBE * str[(len - 1) / 2]);
 

src/backend/catalog/aclchk.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.4 1998/01/31 04:38:11 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.5 1998/02/11 19:09:42 momjian Exp $
  *
  * NOTES
  *	  See acl.h.
@@ -74,7 +74,7 @@ char	   *aclcheck_error_strings[] = {
 static
 dumpacl(Acl *acl)
 {
-	register unsigned i;
+	unsigned i;
 	AclItem    *aip;
 
 	elog(DEBUG, "acl size = %d, # acls = %d",
@@ -94,7 +94,7 @@ ChangeAcl(char *relname,
 		  AclItem *mod_aip,
 		  unsigned modechg)
 {
-	register unsigned i;
+	unsigned i;
 	Acl		   *old_acl = (Acl *) NULL,
 			   *new_acl;
 	Relation	relation;
@@ -283,8 +283,8 @@ in_group(AclId uid, AclId gid)
 static int32
 aclcheck(Acl *acl, AclId id, AclIdType idtype, AclMode mode)
 {
-	register unsigned i;
-	register AclItem *aip,
+	unsigned i;
+	AclItem *aip,
 			   *aidat;
 	unsigned	num,
 				found_group;

src/backend/catalog/catalog.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/catalog.c,v 1.13 1998/01/16 23:19:23 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/catalog.c,v 1.14 1998/02/11 19:09:47 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -155,7 +155,7 @@ void
 fillatt(TupleDesc tupleDesc)
 {
 	AttributeTupleForm *attributeP;
-	register TypeTupleForm typp;
+	TypeTupleForm typp;
 	HeapTuple	tuple;
 	int			i;
 	int			natts = tupleDesc->natts;

src/backend/catalog/heap.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.45 1998/02/07 06:10:39 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.46 1998/02/11 19:09:54 momjian Exp $
  *
  * INTERFACE ROUTINES
  *		heap_create()			- Create an uncataloged heap relation
@@ -171,7 +171,7 @@ Relation
 heap_create(char *name,
 			TupleDesc tupDesc)
 {
-	register unsigned i;
+	unsigned i;
 	Oid			relid;
 	Relation	rdesc;
 	int			len;

src/backend/catalog/pg_aggregate.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.11 1998/01/06 19:42:30 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.12 1998/02/11 19:10:03 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -64,7 +64,7 @@ AggregateCreate(char *aggName,
 				char *agginitval1,
 				char *agginitval2)
 {
-	register	i;
+	int			i;
 	Relation	aggdesc;
 	HeapTuple	tup;
 	char		nulls[Natts_pg_aggregate];

src/backend/catalog/pg_operator.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.20 1998/01/15 19:42:30 pgsql Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.21 1998/02/11 19:10:11 momjian Exp $
  *
  * NOTES
  *	  these routines moved here from commands/define.c and somewhat cleaned up.
@@ -224,7 +224,7 @@ OperatorShellMakeWithOpenRelation(Relation pg_operator_desc,
 								  Oid leftObjectId,
 								  Oid rightObjectId)
 {
-	register int i;
+	int i;
 	HeapTuple	tup;
 	Datum		values[Natts_pg_operator];
 	char		nulls[Natts_pg_operator];
@@ -452,7 +452,7 @@ OperatorDef(char *operatorName,
 			char *leftSortName,
 			char *rightSortName)
 {
-	register	i,
+	int			i,
 				j;
 	Relation	pg_operator_desc;
 
@@ -767,7 +767,7 @@ OperatorDef(char *operatorName,
 static void
 OperatorUpd(Oid baseId, Oid commId, Oid negId)
 {
-	register	i;
+	int			i;
 	Relation	pg_operator_desc;
 	HeapScanDesc pg_operator_scan;
 	HeapTuple	tup;

src/backend/catalog/pg_proc.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.13 1998/01/06 19:42:32 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.14 1998/02/11 19:10:16 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -55,7 +55,7 @@ ProcedureCreate(char *procedureName,
 				List *argList,
 				CommandDest dest)
 {
-	register	i;
+	int			i;
 	Relation	rdesc;
 	HeapTuple	tup;
 	bool		defined;

src/backend/catalog/pg_type.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.18 1998/01/15 19:42:30 pgsql Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.19 1998/02/11 19:10:18 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -155,7 +155,7 @@ TypeGet(char *typeName,			/* name of type to be fetched */
 static Oid
 TypeShellMakeWithOpenRelation(Relation pg_type_desc, char *typeName)
 {
-	register int i;
+	int i;
 	HeapTuple	tup;
 	Datum		values[Natts_pg_type];
 	char		nulls[Natts_pg_type];
@@ -297,7 +297,7 @@ TypeCreate(char *typeName,
 		   bool passedByValue,
 		   char alignment)
 {
-	register	i,
+	int			i,
 				j;
 	Relation	pg_type_desc;
 	HeapScanDesc pg_type_scan;

src/backend/commands/remove.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/Attic/remove.c,v 1.21 1998/01/15 19:42:38 pgsql Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/Attic/remove.c,v 1.22 1998/02/11 19:10:20 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -156,7 +156,7 @@ SingleOpOperatorRemove(Oid typeOid)
 	ItemPointerData itemPointerData;
 	Buffer		buffer;
 	static		attnums[3] = {7, 8, 9}; /* left, right, return */
-	register	i;
+	int			i;
 
 	ScanKeyEntryInitialize(&key[0],
 					   0, 0, ObjectIdEqualRegProcedure, (Datum) typeOid);

src/backend/executor/nodeHash.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeHash.c,v 1.17 1998/01/25 05:13:03 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeHash.c,v 1.18 1998/02/11 19:10:28 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -780,9 +780,9 @@ ExecScanHashBucket(HashJoinState *hjstate,
 static int
 hashFunc(char *key, int len)
 {
-	register unsigned int h;
-	register int l;
-	register unsigned char *k;
+	unsigned int h;
+	int l;
+	unsigned char *k;
 
 	/*
 	 * If this is a variable length type, then 'k' points to a "struct

src/backend/lib/qsort.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/lib/Attic/qsort.c,v 1.4 1997/09/08 02:23:03 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/lib/Attic/qsort.c,v 1.5 1998/02/11 19:10:35 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -129,13 +129,13 @@ pg_qsort(void *bot,
 static void
 quick_sort(char *bot, int nmemb, int size, int (*compar) ())
 {
-	register int cnt;
-	register u_char ch;
-	register char *top,
+	int cnt;
+	u_char ch;
+	char *top,
 			   *mid,
 			   *t1,
 			   *t2;
-	register int n1,
+	int n1,
 				n2;
 	char	   *bsv;
 
@@ -277,9 +277,9 @@ swap:	SWAP(bot, replace);
 static void
 insertion_sort(char *bot, int nmemb, int size, int (*compar) ())
 {
-	register int cnt;
-	register u_char ch;
-	register char *s1,
+	int cnt;
+	u_char ch;
+	char *s1,
 			   *s2,
 			   *t1,
 			   *t2,

src/backend/optimizer/util/plancat.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.14 1998/01/15 19:44:41 pgsql Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.15 1998/02/11 19:10:47 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -103,7 +103,7 @@ relation_info(Query *root, Index relid,
 bool
 index_info(Query *root, bool first, int relid, IdxInfoRetval *info)
 {
-	register	i;
+	int			i;
 	HeapTuple	indexTuple,
 				amopTuple;
 	IndexTupleForm index;
@@ -514,7 +514,7 @@ IndexSelectivity(Oid indexrelid,
 				 float *idxPages,
 				 float *idxSelec)
 {
-	register	i,
+	int			i,
 				n;
 	HeapTuple	indexTuple,
 				amopTuple,

src/backend/port/dynloader/aix.c

@@ -75,7 +75,7 @@ static void *findMain(void);
 void	   *
 dlopen(const char *path, int mode)
 {
-	register ModulePtr mp;
+	ModulePtr mp;
 	static void *mainModule;
 
 	/*
@@ -168,7 +168,7 @@ dlopen(const char *path, int mode)
 	 */
 	if (mode & RTLD_GLOBAL)
 	{
-		register ModulePtr mp1;
+		ModulePtr mp1;
 
 		for (mp1 = mp->next; mp1; mp1 = mp1->next)
 			if (loadbind(0, mp1->entry, mp->entry) == -1)
@@ -221,7 +221,7 @@ dlopen(const char *path, int mode)
 static void
 caterr(char *s)
 {
-	register char *p = s;
+	char *p = s;
 
 	while (*p >= '0' && *p <= '9')
 		p++;
@@ -258,9 +258,9 @@ caterr(char *s)
 void	   *
 dlsym(void *handle, const char *symbol)
 {
-	register ModulePtr mp = (ModulePtr) handle;
-	register ExportPtr ep;
-	register int i;
+	ModulePtr mp = (ModulePtr) handle;
+	ExportPtr ep;
+	int i;
 
 	/*
 	 * Could speed up the search, but I assume that one assigns the result
@@ -289,9 +289,9 @@ dlerror(void)
 int
 dlclose(void *handle)
 {
-	register ModulePtr mp = (ModulePtr) handle;
+	ModulePtr mp = (ModulePtr) handle;
 	int			result;
-	register ModulePtr mp1;
+	ModulePtr mp1;
 
 	if (--mp->refCnt > 0)
 		return 0;
@@ -311,8 +311,8 @@ dlclose(void *handle)
 	}
 	if (mp->exports)
 	{
-		register ExportPtr ep;
-		register int i;
+		ExportPtr ep;
+		int i;
 
 		for (ep = mp->exports, i = mp->nExports; i; i--, ep++)
 			if (ep->name)

src/backend/port/getrusage.c

-/* $Id: getrusage.c,v 1.4 1998/02/01 00:02:59 scrappy Exp $ */
+/* $Id: getrusage.c,v 1.5 1998/02/11 19:10:57 momjian Exp $ */
 
 #include <math.h>               /* for pow() prototype */
 
@@ -15,7 +15,7 @@ int
 getrusage(int who, struct rusage * rusage)
 {
 	struct tms	tms;
-	register int tick_rate = CLK_TCK;	/* ticks per second */
+	int tick_rate = CLK_TCK;	/* ticks per second */
 	clock_t		u,
 				s;
 

src/backend/port/inet_aton.c

-/* $Id: inet_aton.c,v 1.12 1998/01/23 19:13:14 scrappy Exp $
+/* $Id: inet_aton.c,v 1.13 1998/02/11 19:11:05 momjian Exp $
  *
  *	This inet_aton() function was taken from the GNU C library and
  *	incorporated into Postgres for those systems which do not have this
@@ -56,12 +56,12 @@
 int
 inet_aton(const char *cp, struct in_addr * addr)
 {
-	register unsigned int val;
-	register int base,
+	unsigned int val;
+	int base,
 				n;
-	register char c;
+	char c;
 	u_int		parts[4];
-	register u_int *pp = parts;
+	u_int *pp = parts;
 
 	for (;;)
 	{

src/backend/port/strcasecmp.c

-/* $Id: strcasecmp.c,v 1.2 1997/12/19 13:34:32 scrappy Exp $ */
+/* $Id: strcasecmp.c,v 1.3 1998/02/11 19:11:10 momjian Exp $ */
 
 /*
  * Copyright (c) 1987 Regents of the University of California.
@@ -63,7 +63,7 @@ static unsigned char charmap[] = {
 int
 strcasecmp(char *s1, char *s2)
 {
-	register unsigned char u1,
+	unsigned char u1,
 				u2;
 
 	for (;;)

src/backend/port/strtol.c

@@ -53,13 +53,13 @@ long
 strtol(nptr, endptr, base)
 const char *nptr;
 char	  **endptr;
-register int base;
+int base;
 {
-	register const char *s = nptr;
-	register unsigned long acc;
-	register int c;
-	register unsigned long cutoff;
-	register int neg = 0,
+	const char *s = nptr;
+	unsigned long acc;
+	int c;
+	unsigned long cutoff;
+	int neg = 0,
 				any,
 				cutlim;
 

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;

src/backend/regex/regcomp.c

@@ -186,10 +186,10 @@ const char *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)
@@ -287,18 +287,18 @@ int			cflags;
 
 /*
  - p_ere - ERE parser top level, concatenation and alternation
- == static void p_ere(register struct parse *p, int stop);
+ == static void p_ere(struct parse *p, int stop);
  */
 static void
 p_ere(p, stop)
-register struct parse *p;
+struct parse *p;
 int			stop;				/* character this ERE should end at */
 {
-	register char c;
-	register sopno prevback = 0;
-	register sopno prevfwd = 0;
-	register sopno conc;
-	register int first = 1;		/* is this the first alternative? */
+	char c;
+	sopno prevback = 0;
+	sopno prevfwd = 0;
+	sopno conc;
+	int first = 1;		/* is this the first alternative? */
 
 	for (;;)
 	{
@@ -336,17 +336,17 @@ int			stop;				/* character this ERE should end at */
 
 /*
  - 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(p)
-register struct parse *p;
+struct parse *p;
 {
-	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 */
@@ -497,11 +497,11 @@ register struct parse *p;
 
 /*
  - 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(p)
-register struct parse *p;
+struct parse *p;
 {
 	REQUIRE(MORE(), REG_EMPTY);
 	while (MORE())
@@ -510,8 +510,8 @@ register struct parse *p;
 
 /*
  - p_bre - BRE parser top level, anchoring and concatenation
- == static void p_bre(register struct parse *p, register int end1, \
- ==		register int end2);
+ == static void p_bre(struct parse *p, int end1, \
+ ==		int end2);
  * Giving end1 as OUT essentially eliminates the end1/end2 check.
  *
  * This implementation is a bit of a kludge, in that a trailing $ is first
@@ -522,13 +522,13 @@ register struct parse *p;
  */
 static void
 p_bre(p, end1, end2)
-register struct parse *p;
-register int end1;				/* first terminating character */
-register int end2;				/* second terminating character */
+struct parse *p;
+int end1;				/* first terminating character */
+int end2;				/* second terminating character */
 {
-	register sopno start = HERE();
-	register int first = 1;		/* first subexpression? */
-	register int wasdollar = 0;
+	sopno start = HERE();
+	int first = 1;		/* first subexpression? */
+	int wasdollar = 0;
 
 	if (EAT('^'))
 	{
@@ -554,19 +554,19 @@ register int end2;				/* second terminating character */
 
 /*
  - 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);
+ == static int p_simp_re(struct parse *p, int starordinary);
  */
 static int						/* was the simple RE an unbackslashed $? */
 p_simp_re(p, starordinary)
-register struct parse *p;
+struct parse *p;
 int			starordinary;		/* is a leading * an ordinary character? */
 {
-	register int c;
-	register int count;
-	register int count2;
-	register sopno pos;
-	register int i;
-	register sopno subno;
+	int c;
+	int count;
+	int count2;
+	sopno pos;
+	int i;
+	sopno subno;
 
 #define  BACKSL  (1<<CHAR_BIT)
 
@@ -689,14 +689,14 @@ int			starordinary;		/* is a leading * an ordinary character? */
 
 /*
  - 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(p)
-register struct parse *p;
+struct parse *p;
 {
-	register int count = 0;
-	register int ndigits = 0;
+	int count = 0;
+	int ndigits = 0;
 
 	while (MORE() && isdigit(PEEK()) && count <= DUPMAX)
 	{
@@ -710,17 +710,17 @@ register struct parse *p;
 
 /*
  - 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(p)
-register struct parse *p;
+struct parse *p;
 {
-	register cset *cs = allocset(p);
-	register int invert = 0;
+	cset *cs = allocset(p);
+	int invert = 0;
 
 	/* Dept of Truly Sickening Special-Case Kludges */
 	if (p->next + 5 < p->end && strncmp(p->next, "[:<:]]", 6) == 0)
@@ -753,8 +753,8 @@ register struct parse *p;
 
 	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))
@@ -768,7 +768,7 @@ register struct parse *p;
 	}
 	if (invert)
 	{
-		register int i;
+		int i;
 
 		for (i = p->g->csetsize - 1; i >= 0; i--)
 			if (CHIN(cs, i))
@@ -794,17 +794,17 @@ register struct parse *p;
 
 /*
  - 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(p, cs)
-register struct parse *p;
-register cset *cs;
+struct parse *p;
+cset *cs;
 {
-	register char c;
-	register char start,
+	char c;
+	char start,
 				finish;
-	register int i;
+	int i;
 
 	/* classify what we've got */
 	switch ((MORE()) ? PEEK() : '\0')
@@ -865,18 +865,18 @@ register cset *cs;
 
 /*
  - 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(p, cs)
-register struct parse *p;
-register cset *cs;
+struct parse *p;
+cset *cs;
 {
-	register char *sp = p->next;
-	register struct cclass *cp;
-	register size_t len;
-	register char *u;
-	register char c;
+	char *sp = p->next;
+	struct cclass *cp;
+	size_t len;
+	char *u;
+	char c;
 
 	while (MORE() && isalpha(PEEK()))
 		NEXT();
@@ -900,16 +900,16 @@ register cset *cs;
 
 /*
  - 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(p, cs)
-register struct parse *p;
-register cset *cs;
+struct parse *p;
+cset *cs;
 {
-	register char c;
+	char c;
 
 	c = p_b_coll_elem(p, '=');
 	CHadd(cs, c);
@@ -917,13 +917,13 @@ register cset *cs;
 
 /*
  - 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(p)
-register struct parse *p;
+struct parse *p;
 {
-	register char value;
+	char value;
 
 	REQUIRE(MORE(), REG_EBRACK);
 	if (!EATTWO('[', '.'))
@@ -937,16 +937,16 @@ register struct parse *p;
 
 /*
  - 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(p, endc)
-register struct parse *p;
+struct parse *p;
 int			endc;				/* name ended by endc,']' */
 {
-	register char *sp = p->next;
-	register struct cname *cp;
-	register int len;
+	char *sp = p->next;
+	struct cname *cp;
+	int len;
 
 	while (MORE() && !SEETWO(endc, ']'))
 		NEXT();
@@ -985,17 +985,17 @@ int			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(p, ch)
-register struct parse *p;
+struct parse *p;
 int			ch;
 {
-	register char *oldnext = p->next;
-	register char *oldend = p->end;
+	char *oldnext = p->next;
+	char *oldend = p->end;
 	char		bracket[3];
 
 	assert(othercase(ch) != ch);/* p_bracket() would recurse */
@@ -1012,14 +1012,14 @@ int			ch;
 
 /*
  - 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(p, ch)
-register struct parse *p;
-register int ch;
+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);
@@ -1033,16 +1033,16 @@ register int ch;
 
 /*
  - 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(p)
-register struct parse *p;
+struct parse *p;
 {
-	register char *oldnext = p->next;
-	register char *oldend = p->end;
+	char *oldnext = p->next;
+	char *oldend = p->end;
 	char		bracket[4];
 
 	p->next = bracket;
@@ -1059,23 +1059,23 @@ register struct parse *p;
 
 /*
  - repeat - generate code for a bounded repetition, recursively if needed
- == static void repeat(register struct parse *p, sopno start, int from, int to);
+ == static void repeat(struct parse *p, sopno start, int from, int to);
  */
 static void
 repeat(p, start, from, to)
-register struct parse *p;
+struct parse *p;
 sopno		start;				/* operand from here to end of strip */
 int			from;				/* repeated from this number */
 int			to;					/* to this number of times (maybe
 								 * INFINITY) */
 {
-	register sopno finish = HERE();
+	sopno finish = HERE();
 
 #define  N		 2
 #define  INF	 3
 #define  REP(f, t)		 ((f)*8 + (t))
 #define  MAP(n)  (((n) <= 1) ? (n) : ((n) == INFINITY) ? INF : N)
-	register sopno copy;
+	sopno copy;
 
 	if (p->error != 0)			/* head off possible runaway recursion */
 		return;
@@ -1134,11 +1134,11 @@ int			to;					/* to this number of times (maybe
 
 /*
  - 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(p, e)
-register struct parse *p;
+struct parse *p;
 int			e;
 {
 	if (p->error == 0)			/* keep earliest error condition */
@@ -1150,18 +1150,18 @@ int			e;
 
 /*
  - allocset - allocate a set of characters for []
- == static cset *allocset(register struct parse *p);
+ == static cset *allocset(struct parse *p);
  */
 static cset *
 allocset(p)
-register struct parse *p;
+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 */
@@ -1208,16 +1208,16 @@ register struct parse *p;
 
 /*
  - 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(p, cs)
-register struct parse *p;
-register cset *cs;
+struct parse *p;
+cset *cs;
 {
-	register int i;
-	register cset *top = &p->g->sets[p->g->ncsets];
-	register size_t css = (size_t) p->g->csetsize;
+	int 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);
@@ -1227,7 +1227,7 @@ register cset *cs;
 
 /*
  - 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
@@ -1237,14 +1237,14 @@ register cset *cs;
  */
 static int						/* set number */
 freezeset(p, cs)
-register struct parse *p;
-register cset *cs;
+struct parse *p;
+cset *cs;
 {
-	register uch h = cs->hash;
-	register int i;
-	register cset *top = &p->g->sets[p->g->ncsets];
-	register cset *cs2;
-	register size_t css = (size_t) p->g->csetsize;
+	uch h = cs->hash;
+	int 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++)
@@ -1269,15 +1269,15 @@ register cset *cs;
 
 /*
  - 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(p, cs)
-register struct parse *p;
-register cset *cs;
+struct parse *p;
+cset *cs;
 {
-	register int i;
-	register size_t css = (size_t) p->g->csetsize;
+	int i;
+	size_t css = (size_t) p->g->csetsize;
 
 	for (i = 0; i < css; i++)
 		if (CHIN(cs, i))
@@ -1288,16 +1288,16 @@ register cset *cs;
 
 /*
  - 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(p, cs)
-register struct parse *p;
-register cset *cs;
+struct parse *p;
+cset *cs;
 {
-	register int i;
-	register size_t css = (size_t) p->g->csetsize;
-	register int n = 0;
+	int i;
+	size_t css = (size_t) p->g->csetsize;
+	int n = 0;
 
 	for (i = 0; i < css; i++)
 		if (CHIN(cs, i))
@@ -1307,16 +1307,16 @@ register cset *cs;
 
 /*
  - 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(p, cs, cp)
-register struct parse *p;
-register cset *cs;
-register char *cp;
+struct parse *p;
+cset *cs;
+char *cp;
 {
-	register size_t oldend = cs->smultis;
+	size_t oldend = cs->smultis;
 
 	cs->smultis += strlen(cp) + 1;
 	if (cs->multis == NULL)
@@ -1335,16 +1335,16 @@ register char *cp;
 
 /*
  - 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(cs, cp)
-register cset *cs;
-register char *cp;
+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);
 		memmove(fp, fp + len + 1,
@@ -1364,13 +1364,13 @@ register char *cp;
 
 /*
  - 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(cs, cp)
-register cset *cs;
-register char *cp;
+cset *cs;
+char *cp;
 {
 		return(mcfind(cs, cp) != NULL);
 }
@@ -1378,15 +1378,15 @@ register char *cp;
 
 /*
  - 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(cs, cp)
-register cset *cs;
-register char *cp;
+cset *cs;
+char *cp;
 {
-		register char *p;
+		char *p;
 
 		if (cs->multis == NULL)
 				return(NULL);
@@ -1398,47 +1398,47 @@ register char *cp;
 */
 /*
  - 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(p, cs)
-register struct parse *p;
-register cset *cs;
+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(p, cs)
-register struct parse *p;
-register cset *cs;
+struct parse *p;
+cset *cs;
 {
 	assert(cs->multis == NULL); /* xxx */
 }
 
 /*
  - 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(g, c)
-register struct re_guts *g;
+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)
@@ -1448,19 +1448,19 @@ int			c;
 
 /*
  - 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(g, c1, c2)
-register struct re_guts *g;
+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])
@@ -1470,17 +1470,17 @@ int			c2;
 
 /*
  - 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(p, g)
 struct parse *p;
-register struct re_guts *g;
+struct re_guts *g;
 {
-	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)
@@ -1499,16 +1499,16 @@ register struct re_guts *g;
 
 /*
  - dupl - emit a duplicate of a bunch of sops
- == static sopno dupl(register struct parse *p, sopno start, sopno finish);
+ == static sopno dupl(struct parse *p, sopno start, sopno finish);
  */
 static sopno					/* start of duplicate */
 dupl(p, start, finish)
-register struct parse *p;
+struct parse *p;
 sopno		start;				/* from here */
 sopno		finish;				/* 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)
@@ -1523,7 +1523,7 @@ sopno		finish;				/* to this less one */
 
 /*
  - 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
@@ -1531,7 +1531,7 @@ sopno		finish;				/* to this less one */
  */
 static void
 doemit(p, op, opnd)
-register struct parse *p;
+struct parse *p;
 sop			op;
 size_t		opnd;
 {
@@ -1553,18 +1553,18 @@ size_t		opnd;
 
 /*
  - 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(p, op, opnd, pos)
-register struct parse *p;
+struct parse *p;
 sop			op;
 size_t		opnd;
 sopno		pos;
 {
-	register sopno sn;
-	register sop s;
-	register int i;
+	sopno sn;
+	sop s;
+	int i;
 
 	/* avoid making error situations worse */
 	if (p->error != 0)
@@ -1596,12 +1596,12 @@ sopno		pos;
 
 /*
  - 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(p, pos, value)
-register struct parse *p;
-register sopno pos;
+struct parse *p;
+sopno pos;
 sop			value;
 {
 	/* avoid making error situations worse */
@@ -1614,14 +1614,14 @@ sop			value;
 
 /*
  - enlarge - enlarge the strip
- == static void enlarge(register struct parse *p, sopno size);
+ == static void enlarge(struct parse *p, sopno size);
  */
 static void
 enlarge(p, size)
-register struct parse *p;
-register sopno size;
+struct parse *p;
+sopno size;
 {
-	register sop *sp;
+	sop *sp;
 
 	if (p->ssize >= size)
 		return;
@@ -1638,12 +1638,12 @@ register sopno size;
 
 /*
  - 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(p, g)
-register struct parse *p;
-register struct re_guts *g;
+struct parse *p;
+struct re_guts *g;
 {
 	g->nstates = p->slen;
 	g->strip = (sop *) realloc((char *) p->strip, p->slen * sizeof(sop));
@@ -1656,7 +1656,7 @@ register struct re_guts *g;
 
 /*
  - 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
@@ -1667,15 +1667,15 @@ register struct re_guts *g;
 static void
 findmust(p, g)
 struct parse *p;
-register struct re_guts *g;
+struct re_guts *g;
 {
-	register sop *scan;
+	sop *scan;
 	sop		   *start = 0;
-	register sop *newstart = 0;
-	register sopno newlen;
-	register sop s;
-	register char *cp;
-	register sopno i;
+	sop *newstart = 0;
+	sopno newlen;
+	sop s;
+	char *cp;
+	sopno i;
 
 	/* avoid making error situations worse */
 	if (p->error != 0)
@@ -1750,17 +1750,17 @@ register struct re_guts *g;
 
 /*
  - 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(p, g)
 struct parse *p;
-register struct re_guts *g;
+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 */

src/backend/regex/regerror.c

@@ -160,10 +160,10 @@ const regex_t *preg;
 char	   *errbuf;
 size_t		errbuf_size;
 {
-	register struct rerr *r;
-	register size_t len;
-	register int target = errcode & ~REG_ITOA;
-	register char *s;
+	struct rerr *r;
+	size_t len;
+	int target = errcode & ~REG_ITOA;
+	char *s;
 	char		convbuf[50];
 
 	if (errcode == REG_ATOI)
@@ -211,7 +211,7 @@ regatoi(preg, localbuf)
 const regex_t *preg;
 char	   *localbuf;
 {
-	register struct rerr *r;
+	struct rerr *r;
 
 	for (r = rerrs; r->code != 0; r++)
 		if (strcmp(r->name, preg->re_endp) == 0)

src/backend/regex/regexec.c

@@ -162,7 +162,7 @@ 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)

src/backend/regex/regfree.c

@@ -58,7 +58,7 @@ void
 pg95_regfree(preg)
 regex_t    *preg;
 {
-	register struct re_guts *g;
+	struct re_guts *g;
 
 	if (preg->re_magic != MAGIC1)		/* oops */
 		return;					/* nice to complain, but hard */

src/backend/storage/buffer/bufmgr.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.33 1998/02/02 13:16:31 scrappy Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.34 1998/02/11 19:11:42 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1197,7 +1197,7 @@ ResetBufferUsage()
 void
 ResetBufferPool()
 {
-	register int i;
+	int i;
 
 	for (i = 1; i <= NBuffers; i++)
 	{
@@ -1225,7 +1225,7 @@ ResetBufferPool()
 int
 BufferPoolCheckLeak()
 {
-	register int i;
+	int i;
 	int			error = 0;
 
 	for (i = 1; i <= NBuffers; i++)
@@ -1444,7 +1444,7 @@ BufferGetBlock(Buffer buffer)
 void
 ReleaseRelationBuffers(Relation rdesc)
 {
-	register int i;
+	int i;
 	int			holding = 0;
 	BufferDesc *buf;
 
@@ -1501,7 +1501,7 @@ ReleaseRelationBuffers(Relation rdesc)
 void
 DropBuffers(Oid dbid)
 {
-	register int i;
+	int i;
 	BufferDesc *buf;
 
 	SpinAcquire(BufMgrLock);
@@ -1587,7 +1587,7 @@ blockNum=%d, flags=0x%x, refcount=%d %d)\n",
 void
 BufferPoolBlowaway()
 {
-	register int i;
+	int i;
 
 	BufferSync();
 	for (i = 1; i <= NBuffers; i++)
@@ -1618,7 +1618,7 @@ BufferPoolBlowaway()
 int
 BlowawayRelationBuffers(Relation rdesc, BlockNumber block)
 {
-	register int	i;
+	int	i;
 	BufferDesc	   *buf;
 
 	if (rdesc->rd_islocal)

src/backend/storage/page/bufpage.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/page/bufpage.c,v 1.13 1998/01/07 21:05:40 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/page/bufpage.c,v 1.14 1998/02/11 19:11:59 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -98,7 +98,7 @@ PageAddItem(Page page,
 			OffsetNumber offsetNumber,
 			ItemIdFlags flags)
 {
-	register	i;
+	int			i;
 	Size		alignedSize;
 	Offset		lower;
 	Offset		upper;

src/backend/utils/adt/acl.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.23 1998/01/05 16:39:39 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.24 1998/02/11 19:12:03 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -242,7 +242,7 @@ aclitemin(char *s)
 char	   *
 aclitemout(AclItem *aip)
 {
-	register char *p;
+	char *p;
 	char	   *out;
 	HeapTuple	htp;
 	unsigned	i;

src/backend/utils/adt/chunk.c

@@ -6,7 +6,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/chunk.c,v 1.14 1998/01/13 04:04:47 scrappy Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/chunk.c,v 1.15 1998/02/11 19:12:08 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -191,7 +191,7 @@ _FindBestChunk(int size,
 		 * compute the number of page fetches for a given chunk size (d[])
 		 * and access pattern (A[][])
 		 */
-		register int i,
+		int i,
 					j,
 					nc;
 
@@ -224,7 +224,7 @@ _FindBestChunk(int size,
 static int
 get_next(int d[], int k, int C, int dmax[])
 {
-	register int i,
+	int i,
 				j,
 				temp;
 

src/backend/utils/adt/date.c

@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.22 1998/01/07 18:46:37 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.23 1998/02/11 19:12:19 momjian Exp $
  *
  * NOTES
  *	 This code is actually (almost) unused.
@@ -206,7 +206,7 @@ reltime2tm(int32 time, struct tm * tm)
 #if FALSE
 char	   *timestring;
 long		quantity;
-register int i;
+int i;
 int			unitnr;
 
 timestring = (char *) palloc(Max(strlen(INVALID_RELTIME_STR),
@@ -966,8 +966,8 @@ isreltime(char *str)
 }								/* isreltime() */
 
 #if FALSE
-register char *p;
-register char c;
+char *p;
+char c;
 int			i;
 char		unit[UNITMAXLEN];
 char		direction[DIRMAXLEN];
@@ -1156,9 +1156,9 @@ istinterval(char *i_string,
 			AbsoluteTime *i_start,
 			AbsoluteTime *i_end)
 {
-	register char *p,
+	char *p,
 			   *p1;
-	register char c;
+	char c;
 
 	p = i_string;
 	/* skip leading blanks up to '[' */

src/backend/utils/adt/dt.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/dt.c,v 1.50 1998/01/07 18:46:45 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/dt.c,v 1.51 1998/02/11 19:12:33 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -4015,9 +4015,9 @@ DecodeUnits(int field, char *lowtoken, int *val)
 static datetkn *
 datebsearch(char *key, datetkn *base, unsigned int nel)
 {
-	register datetkn *last = base + nel - 1,
+	datetkn *last = base + nel - 1,
 			   *position;
-	register int result;
+	int result;
 
 	while (last >= base)
 	{

src/backend/utils/adt/int.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.13 1998/01/07 18:46:49 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.14 1998/02/11 19:12:37 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -80,7 +80,7 @@ int2out(int16 sh)
 int16 *
 int28in(char *shs)
 {
-	register int16 (*result)[];
+	int16 (*result)[];
 	int			nums;
 
 	if (shs == NULL)
@@ -109,9 +109,9 @@ int28in(char *shs)
 char *
 int28out(int16 (*shs)[])
 {
-	register int num;
-	register int16 *sp;
-	register char *rp;
+	int num;
+	int16 *sp;
+	char *rp;
 	char	   *result;
 
 	if (shs == NULL)
@@ -145,7 +145,7 @@ int32 *
 int44in(char *input_string)
 {
 	int32	   *foo = (int32 *) palloc(4 * sizeof(int32));
-	register int i = 0;
+	int i = 0;
 
 	i = sscanf(input_string,
 			   "%d, %d, %d, %d",

src/backend/utils/adt/like.c

@@ -150,7 +150,7 @@ textnlike(struct varlena * s, struct varlena * p)
 }
 
 
-/*	$Revision: 1.10 $
+/*	$Revision: 1.11 $
 **	"like.c" A first attempt at a LIKE operator for Postgres95.
 **
 **	Originally written by Rich $alz, mirror!rs, Wed Nov 26 19:03:17 EST 1986.
@@ -185,9 +185,9 @@ textnlike(struct varlena * s, struct varlena * p)
 **	Match text and p, return LIKE_TRUE, LIKE_FALSE, or LIKE_ABORT.
 */
 static int
-DoMatch(register char *text, register char *p)
+DoMatch(char *text, char *p)
 {
-	register int matched;
+	int matched;
 
 	for (; *p; text ++, p++)
 	{

src/backend/utils/adt/numutils.c

@@ -10,7 +10,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/numutils.c,v 1.21 1998/01/05 16:40:09 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/numutils.c,v 1.22 1998/02/11 19:12:39 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -184,9 +184,9 @@ ftoa(double value, char *ascii, int width, int prec1, char format)
 #else
 	auto int	expon;
 	auto int	sign;
-	register int avail = 0;
-	register char *a = NULL;
-	register char *p = NULL;
+	int avail = 0;
+	char *a = NULL;
+	char *p = NULL;
 	char		mode;
 	int			lowercase;
 	int			prec;
@@ -370,13 +370,13 @@ frac_out:
 int
 atof1(char *str, double *val)
 {
-	register char *p;
+	char *p;
 	double		v;
 	double		fact;
 	int			minus;
-	register char c;
+	char c;
 	int			expon;
-	register int gotmant;
+	int gotmant;
 
 	v = 0.0;
 	p = str;

src/backend/utils/adt/oid.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/oid.c,v 1.13 1998/01/07 18:46:50 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/oid.c,v 1.14 1998/02/11 19:12:41 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -31,7 +31,7 @@
 Oid	*
 oid8in(char *oidString)
 {
-	register Oid (*result)[];
+	Oid (*result)[];
 	int			nums;
 
 	if (oidString == NULL)
@@ -60,9 +60,9 @@ oid8in(char *oidString)
 char *
 oid8out(Oid (*oidArray)[])
 {
-	register int num;
-	register Oid *sp;
-	register char *rp;
+	int num;
+	Oid *sp;
+	char *rp;
 	char	   *result;
 
 	if (oidArray == NULL)

src/backend/utils/adt/regproc.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.13 1998/01/31 04:38:46 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.14 1998/02/11 19:12:43 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -160,8 +160,8 @@ oid8types(Oid (*oidArray)[])
 	HeapTuple	typetup;
 	text	   *result;
 	ScanKeyData key;
-	register int num;
-	register Oid *sp;
+	int num;
+	Oid *sp;
 
 	if (oidArray == NULL)
 	{

src/backend/utils/adt/selfuncs.c

@@ -12,7 +12,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.16 1998/02/05 21:19:21 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.17 1998/02/11 19:12:45 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -334,8 +334,8 @@ gethilokey(Oid relid,
 		   char **high,
 		   char **low)
 {
-	register Relation rdesc;
-	register HeapScanDesc sdesc;
+	Relation rdesc;
+	HeapScanDesc sdesc;
 	static ScanKeyData key[3] = {
 		{0, Anum_pg_statistic_starelid, F_OIDEQ, {0, 0, F_OIDEQ}},
 		{0, Anum_pg_statistic_staattnum, F_INT2EQ, {0, 0, F_INT2EQ}},

src/backend/utils/cache/catcache.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.21 1998/01/15 19:45:28 pgsql Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.22 1998/02/11 19:12:47 momjian Exp $
  *
  * Notes:
  *		XXX This needs to use exception.h to handle recovery when
@@ -287,7 +287,7 @@ CatalogCacheSetId(CatCache *cacheInOutP, int id)
  * ----------------
  */
 static long
-comphash(long l, register char *v)
+comphash(long l, char *v)
 {
 	long		i;
 	NameData	n;
@@ -654,7 +654,7 @@ InitSysCache(char *relname,
 			 HeapTuple (*iScanfuncP) ())
 {
 	CatCache   *cp;
-	register int i;
+	int i;
 	MemoryContext oldcxt;
 
 	char	   *indname;

src/backend/utils/cache/syscache.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/cache/syscache.c,v 1.13 1998/01/31 04:38:54 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/cache/syscache.c,v 1.14 1998/02/11 19:12:49 momjian Exp $
  *
  * NOTES
  *	  These routines allow the parser/planner/executor to perform
@@ -398,7 +398,7 @@ SearchSysCacheTuple(int cacheId,		/* cache selection code */
 					Datum key3,
 					Datum key4)
 {
-	register HeapTuple tp;
+	HeapTuple tp;
 
 	if (cacheId < 0 || cacheId >= SysCacheSize)
 	{

src/backend/utils/error/elog.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.25 1998/01/25 05:14:35 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.26 1998/02/11 19:12:50 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -45,8 +45,8 @@ elog(int lev, const char *fmt,...)
 	va_list		ap;
 	char		buf[ELOG_MAXLEN],
 				line[ELOG_MAXLEN];
-	register char *bp;
-	register const char *cp;
+	char *bp;
+	const char *cp;
 	extern int	errno,
 				sys_nerr;
 

src/backend/utils/error/exc.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/error/Attic/exc.c,v 1.18 1997/09/08 21:49:00 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/error/Attic/exc.c,v 1.19 1998/02/11 19:12:52 momjian Exp $
  *
  * NOTE
  *	  XXX this code needs improvement--check for state violations and
@@ -179,7 +179,7 @@ ExcRaise(Exception *excP,
 		 ExcData data,
 		 ExcMessage message)
 {
-	register ExcFrame *efp;
+	ExcFrame *efp;
 
 	efp = ExcCurFrameP;
 	if (efp == NULL)

src/backend/utils/fmgr/fmgr.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.13 1998/01/31 05:31:03 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.14 1998/02/11 19:12:55 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -261,7 +261,7 @@ char	   *
 fmgr(Oid procedureId,...)
 {
 	va_list		pvar;
-	register	i;
+	int			i;
 	int			pronargs;
 	FmgrValues	values;
 	FmgrInfo	finfo;
@@ -299,7 +299,7 @@ char	   *
 fmgr_ptr(FmgrInfo *finfo, ...)
 {
 	va_list		pvar;
-	register	i;
+	int			i;
 	int			n_arguments;
 	FmgrInfo	local_finfo;
 	FmgrValues	values;

src/backend/utils/hash/dynahash.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/hash/dynahash.c,v 1.11 1997/09/18 20:22:30 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/hash/dynahash.c,v 1.12 1998/02/11 19:13:02 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -157,7 +157,7 @@ static long hash_accesses,
 HTAB	   *
 hash_create(int nelem, HASHCTL *info, int flags)
 {
-	register HHDR *hctl;
+	HHDR *hctl;
 	HTAB	   *hashp;
 
 
@@ -302,9 +302,9 @@ hdefault(HTAB *hashp)
 static int
 init_htab(HTAB *hashp, int nelem)
 {
-	register SEG_OFFSET *segp;
-	register int nbuckets;
-	register int nsegs;
+	SEG_OFFSET *segp;
+	int nbuckets;
+	int nsegs;
 	int			l2;
 	HHDR	   *hctl;
 
@@ -387,7 +387,7 @@ hash_destroy(HTAB *hashp)
 
 	if (hashp != NULL)
 	{
-		register SEG_OFFSET segNum;
+		SEG_OFFSET segNum;
 		SEGMENT		segp;
 		int			nsegs = hashp->hctl->nsegs;
 		int			j;
@@ -480,7 +480,7 @@ hash_search(HTAB *hashp,
 	long		segment_num;
 	long		segment_ndx;
 	SEGMENT		segp;
-	register ELEMENT *curr;
+	ELEMENT *curr;
 	HHDR	   *hctl;
 	BUCKET_INDEX currIndex;
 	BUCKET_INDEX *prevIndexPtr;
@@ -735,7 +735,7 @@ expand_table(HTAB *hashp)
 	ELEMENT    *chain;
 	BUCKET_INDEX *old,
 			   *newbi;
-	register BUCKET_INDEX chainIndex,
+	BUCKET_INDEX chainIndex,
 				nextIndex;
 
 #ifdef HASH_STATISTICS
@@ -811,7 +811,7 @@ expand_table(HTAB *hashp)
 static int
 dir_realloc(HTAB *hashp)
 {
-	register char *p;
+	char *p;
 	char	  **p_ptr;
 	long		old_dirsize;
 	long		new_dirsize;

src/backend/utils/hash/hashfn.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/hash/hashfn.c,v 1.5 1997/09/08 02:31:45 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/hash/hashfn.c,v 1.6 1998/02/11 19:13:06 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -25,7 +25,7 @@ long
 string_hash(char *key, int keysize)
 {
 	int			h;
-	register unsigned char *k = (unsigned char *) key;
+	unsigned char *k = (unsigned char *) key;
 
 	h = 0;
 
@@ -43,7 +43,7 @@ string_hash(char *key, int keysize)
 long
 tag_hash(int *key, int keysize)
 {
-	register long h = 0;
+	long h = 0;
 
 	/*
 	 * Convert tag to integer;	Use four byte chunks in a "jump table" to
@@ -130,10 +130,10 @@ tag_hash(int *key, int keysize)
 long
 disk_hash(char *key)
 {
-	register int n = 0;
-	register char *str = key;
-	register int len = strlen(key);
-	register int loop;
+	int n = 0;
+	char *str = key;
+	int len = strlen(key);
+	int loop;
 
 #define HASHC	n = *str++ + 65599 * n
 

src/backend/utils/mmgr/oset.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/mmgr/Attic/oset.c,v 1.6 1997/09/08 21:49:29 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/mmgr/Attic/oset.c,v 1.7 1998/02/11 19:13:17 momjian Exp $
  *
  * NOTE
  *	  XXX This is a preliminary implementation which lacks fail-fast
@@ -64,7 +64,7 @@ OrderedSetContains(OrderedSet set, OrderedElem elem)
 Pointer
 OrderedSetGetHead(OrderedSet set)
 {
-	register OrderedElem elem;
+	OrderedElem elem;
 
 	elem = set->head;
 	if (elem->next)
@@ -81,7 +81,7 @@ OrderedSetGetHead(OrderedSet set)
 Pointer
 OrderedSetGetTail(OrderedSet set)
 {
-	register OrderedElem elem;
+	OrderedElem elem;
 
 	elem = set->tail;
 	if (elem->prev)

src/backend/utils/sort/lselect.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/lselect.c,v 1.11 1998/01/31 04:39:12 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/lselect.c,v 1.12 1998/02/11 19:13:37 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -37,7 +37,7 @@
 struct leftist *
 lmerge(struct leftist * pt, struct leftist * qt, LeftistContext context)
 {
-	register struct leftist *root,
+	struct leftist *root,
 			   *majorLeftist,
 			   *minorLeftist;
 	int			dist;
@@ -76,7 +76,7 @@ lmerge(struct leftist * pt, struct leftist * qt, LeftistContext context)
 static struct leftist *
 linsert(struct leftist * root, struct leftist * new1, LeftistContext context)
 {
-	register struct leftist *left,
+	struct leftist *left,
 			   *right;
 
 	if (!tuplecmp(root->lt_tuple, new1->lt_tuple, context))
@@ -129,7 +129,7 @@ gettuple(struct leftist ** treep,
 		 short *devnum,			/* device from which tuple came */
 		 LeftistContext context)
 {
-	register struct leftist *tp;
+	struct leftist *tp;
 	HeapTuple	tup;
 
 	tp = *treep;
@@ -159,8 +159,8 @@ puttuple(struct leftist ** treep,
 		 short devnum,
 		 LeftistContext context)
 {
-	register struct leftist *new1;
-	register struct leftist *tp;
+	struct leftist *new1;
+	struct leftist *tp;
 
 	new1 = (struct leftist *) palloc((unsigned) sizeof(struct leftist));
 	new1->lt_dist = 1;
@@ -186,7 +186,7 @@ puttuple(struct leftist ** treep,
 int
 tuplecmp(HeapTuple ltup, HeapTuple rtup, LeftistContext context)
 {
-	register Datum lattr,
+	Datum lattr,
 				rattr;
 	int			nkey = 0;
 	int			result = 0;

src/backend/utils/sort/psort.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/psort.c,v 1.36 1998/02/01 22:20:47 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/psort.c,v 1.37 1998/02/11 19:13:47 momjian Exp $
  *
  * NOTES
  *		Sorts the first relation into the second relation.
@@ -175,8 +175,8 @@ psort_begin(Sort * node, int nkeys, ScanKey key)
 static void
 inittapes(Sort * node)
 {
-	register int i;
-	register struct tape *tp;
+	int i;
+	struct tape *tp;
 
 	Assert(node != (Sort *) NULL);
 	Assert(PS(node) != (Psortstate *) NULL);
@@ -276,8 +276,8 @@ inittapes(Sort * node)
 static void
 initialrun(Sort * node)
 {
-	/* register struct tuple   *tup; */
-	register struct tape *tp;
+	/* struct tuple   *tup; */
+	struct tape *tp;
 	int			baseruns;		/* D:(a) */
 	int			extrapasses;	/* EOF */
 
@@ -433,7 +433,7 @@ createfirstrun(Sort *node)
 	
 	if ( LACKMEM (node) )	/* in-memory sort is impossible */
 	{
-    	register int t;
+    	int t;
 		
 		Assert (!foundeor);
 		inittapes(node);
@@ -466,8 +466,8 @@ createfirstrun(Sort *node)
 static bool
 createrun(Sort * node, FILE * file)
 {
-	register HeapTuple	lasttuple;
-	register HeapTuple	tup;
+	HeapTuple	lasttuple;
+	HeapTuple	tup;
 	TupleTableSlot	   *cr_slot;
 	HeapTuple		   *memtuples;
 	int					t_last = -1;
@@ -554,7 +554,7 @@ createrun(Sort * node, FILE * file)
 	/* put tuples for the next run into leftist tree */
 	if ( t_last >= 1 )
 	{
-		register int t;
+		int t;
 		
 		PsortTupDesc = PS(node)->treeContext.tupDesc;
 		PsortKeys = PS(node)->treeContext.scanKeys;
@@ -600,7 +600,7 @@ tuplecopy(HeapTuple tup)
 static FILE *
 mergeruns(Sort * node)
 {
-	register struct tape *tp;
+	struct tape *tp;
 
 	Assert(node != (Sort *) NULL);
 	Assert(PS(node) != (Psortstate *) NULL);
@@ -627,9 +627,9 @@ mergeruns(Sort * node)
 static void
 merge(Sort * node, struct tape * dest)
 {
-	register HeapTuple tup;
-	register struct tape *lasttp;		/* (TAPE[P]) */
-	register struct tape *tp;
+	HeapTuple tup;
+	struct tape *lasttp;		/* (TAPE[P]) */
+	struct tape *tp;
 	struct leftist *tuples;
 	FILE		   *destfile;
 	int				times;			/* runs left to merge */
@@ -734,8 +734,8 @@ merge(Sort * node, struct tape * dest)
 static void
 dumptuples(FILE * file, Sort * node)
 {
-	register struct leftist *tp;
-	register struct leftist *newp;
+	struct leftist *tp;
+	struct leftist *newp;
 	struct leftist **treep = &PS(node)->Tuples;
 	LeftistContext context = &PS(node)->treeContext;
 	HeapTuple	tup;
@@ -769,7 +769,7 @@ dumptuples(FILE * file, Sort * node)
 HeapTuple
 psort_grabtuple(Sort * node, bool * should_free)
 {
-	register HeapTuple	tup;
+	HeapTuple	tup;
 
 	Assert(node != (Sort *) NULL);
 	Assert(PS(node) != (Psortstate *) NULL);
@@ -920,7 +920,7 @@ psort_restorepos(Sort * node)
 void
 psort_end(Sort * node)
 {
-	register struct tape *tp;
+	struct tape *tp;
 
 	if (!node->cleaned)
 	{
@@ -978,7 +978,7 @@ static struct tapelst *Tapes = NULL;
 static FILE *
 gettape()
 {
-	register struct tapelst *tp;
+	struct tapelst *tp;
 	FILE	   *file;
 	static int	tapeinit = 0;
 	char	   *mktemp();
@@ -1020,8 +1020,8 @@ gettape()
 static void
 resettape(FILE * file)
 {
-	register struct tapelst *tp;
-	register int fd;
+	struct tapelst *tp;
+	int fd;
 
 	Assert(PointerIsValid(file));
 
@@ -1052,9 +1052,9 @@ resettape(FILE * file)
 static void
 destroytape(FILE * file)
 {
-	register struct tapelst *tp,
+	struct tapelst *tp,
 			   *tq;
-	register int fd;
+	int fd;
 
 	if ((tp = Tapes) == NULL)
 		elog(FATAL, "destroytape: tape not found");
@@ -1089,7 +1089,7 @@ destroytape(FILE * file)
 static int
 _psort_cmp (HeapTuple *ltup, HeapTuple *rtup)
 {
-    register Datum	lattr, rattr;
+    Datum	lattr, rattr;
     int		nkey;
     int		result = 0;
     bool	isnull1, isnull2;

src/interfaces/libpgtcl/pgtclCmds.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/interfaces/libpgtcl/Attic/pgtclCmds.c,v 1.19 1997/11/21 19:12:41 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/interfaces/libpgtcl/Attic/pgtclCmds.c,v 1.20 1998/02/11 19:13:54 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -41,7 +41,7 @@
 static inline char *
 translate_escape(char *p, int isArray)
 {
-	register char c,
+	char c,
 			   *q,
 			   *s;
 
@@ -155,7 +155,7 @@ tcl_value(char *value)
 {
 	int			literal,
 				last;
-	register char *p;
+	char *p;
 
 	if (!value)
 	{

src/test/regress/regress.c

 /*
- * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.21 1998/01/07 18:47:07 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.22 1998/02/11 19:14:04 momjian Exp $
  */
 
 #include <float.h>				/* faked on sunos */
@@ -279,7 +279,7 @@ char	   *
 reverse_c16(string)
 char	   *string;
 {
-	register	i;
+	int			i;
 	int			len;
 	char	   *new_string;