dtksh: remove register keyword

cde/programs/dtksh/ksh93/src/lib/lib0ast/hostinfo.sh

@@ -123,9 +123,9 @@ do	case $info in
 		cat > $tmp.c <<!
 main()
 {
-	register unsigned long	i;
-	register unsigned long	j;
-	register unsigned long	k = 0;
+	unsigned long	i;
+	unsigned long	j;
+	unsigned long	k = 0;
 	for (i = 0; i < 5000; i++)
 		for (j = 0; j < 50000; j++)
 			k += j;

cde/programs/dtksh/ksh93/src/lib/libast/comp/atexit.c

@@ -125,7 +125,7 @@ extern __MANGLE__ void		_exit __PROTO__((int));
 
 int
 atexit __PARAM__((void (*func)(void)), (func)) __OTORP__(void (*func)();){
-	register struct list*	p;
+	struct list*	p;
 
 	if (!(p = newof(0, struct list, 1, 0))) return(-1);
 	p->func = func;
@@ -136,7 +136,7 @@ atexit __PARAM__((void (*func)(void)), (func)) __OTORP__(void (*func)();){
 
 void
 _ast_atexit __PARAM__((void), ()){
-	register struct list*	p;
+	struct list*	p;
 
 	while (p = funclist)
 	{

cde/programs/dtksh/ksh93/src/lib/libast/comp/getgroups.c

@@ -116,7 +116,7 @@ ast_getgroups __PARAM__((int len, gid_t* set), (len, set)) __OTORP__(int len; gi
 #undef	NGROUPS_MAX
 #define NGROUPS_MAX	1
 #endif
-	register int	i;
+	int	i;
 	int		big[NGROUPS_MAX];
 #else
 #undef	NGROUPS_MAX

cde/programs/dtksh/ksh93/src/lib/libast/comp/memccpy.c

@@ -105,10 +105,10 @@ NoN(memccpy)
  */
 
 __V_*
-memccpy __PARAM__((__V_* as1, const __V_* as2, register int c, size_t n), (as1, as2, c, n)) __OTORP__(__V_* as1; const __V_* as2; register int c; size_t n;){
-	register char*		s1 = (char*)as1;
-	register const char*	s2 = (char*)as2;
-	register const char*	ep = s2 + n;
+memccpy __PARAM__((__V_* as1, const __V_* as2, int c, size_t n), (as1, as2, c, n)) __OTORP__(__V_* as1; const __V_* as2; int c; size_t n;){
+	char*		s1 = (char*)as1;
+	const char*	s2 = (char*)as2;
+	const char*	ep = s2 + n;
 
 	while (s2 < ep)
 		if ((*s1++ = *s2++) == c)

cde/programs/dtksh/ksh93/src/lib/libast/comp/memchr.c

@@ -104,9 +104,9 @@ NoN(memchr)
  */
 
 __V_*
-memchr __PARAM__((const __V_* asp, register int c, size_t n), (asp, c, n)) __OTORP__(const __V_* asp; register int c; size_t n;){
-	register const char*	sp = (char*)asp;
-	register const char*	ep = sp + n;
+memchr __PARAM__((const __V_* asp, int c, size_t n), (asp, c, n)) __OTORP__(const __V_* asp; int c; size_t n;){
+	const char*	sp = (char*)asp;
+	const char*	ep = sp + n;
 
 	while (sp < ep)
 		if (*sp++ == c)

cde/programs/dtksh/ksh93/src/lib/libast/comp/memcmp.c

@@ -100,9 +100,9 @@ NoN(memcmp)
 
 int
 memcmp __PARAM__((const __V_* ab1, const __V_* ab2, size_t n), (ab1, ab2, n)) __OTORP__(const __V_* ab1; const __V_* ab2; size_t n;){
-	register const unsigned char*	b1 = (const unsigned char*)ab1;
-	register const unsigned char*	b2 = (const unsigned char*)ab2;
-	register const unsigned char*	e = b1 + n;
+	const unsigned char*	b1 = (const unsigned char*)ab1;
+	const unsigned char*	b2 = (const unsigned char*)ab2;
+	const unsigned char*	e = b1 + n;
 
 	while (b1 < e)
 		if (*b1++ != *b2++)

cde/programs/dtksh/ksh93/src/lib/libast/comp/memcpy.c

@@ -113,9 +113,9 @@ memcpy __PARAM__((__V_* s1, __V_* s2, size_t n), (s1, s2, n)) __OTORP__(__V_* s1
 #else
 
 __V_*
-memcpy __PARAM__((__V_* as1, const __V_* as2, register size_t n), (as1, as2, n)) __OTORP__(__V_* as1; const __V_* as2; register size_t n;){
-	register char*		s1 = (char*)as1;
-	register const char*	s2 = (const char*)as2;
+memcpy __PARAM__((__V_* as1, const __V_* as2, size_t n), (as1, as2, n)) __OTORP__(__V_* as1; const __V_* as2; size_t n;){
+	char*		s1 = (char*)as1;
+	const char*	s2 = (const char*)as2;
 
 	while (n-- > 0)
 		*s1++ = *s2++;

cde/programs/dtksh/ksh93/src/lib/libast/comp/memmove.c

@@ -99,9 +99,9 @@ NoN(memmove)
 #else
 
 __V_*
-memmove __PARAM__((__V_* to, const __V_* from, register size_t n), (to, from, n)) __OTORP__(__V_* to; const __V_* from; register size_t n;){
-	register char*	out = (char*)to;
-	register char*	in = (char*)from;
+memmove __PARAM__((__V_* to, const __V_* from, size_t n), (to, from, n)) __OTORP__(__V_* to; const __V_* from; size_t n;){
+	char*	out = (char*)to;
+	char*	in = (char*)from;
 
 	if (n <= 0)	/* works if size_t is signed or not */
 		;

cde/programs/dtksh/ksh93/src/lib/libast/comp/memset.c

@@ -99,8 +99,8 @@ NoN(memset)
 #else
 
 __V_*
-memset __PARAM__((__V_* asp, register int c, register size_t n), (asp, c, n)) __OTORP__(__V_* asp; register int c; register size_t n;){
-	register char*	sp = (char*)asp;
+memset __PARAM__((__V_* asp, int c, size_t n), (asp, c, n)) __OTORP__(__V_* asp; int c; size_t n;){
+	char*	sp = (char*)asp;
 
 	while (n-- > 0)
 		*sp++ = c;

cde/programs/dtksh/ksh93/src/lib/libast/comp/mkdir.c

@@ -104,7 +104,7 @@ NoN(mkdir)
 
 int
 mkdir __PARAM__((const char* path, mode_t mode), (path, mode)) __OTORP__(const char* path; mode_t mode;){
-	register int	n;
+	int	n;
 	char*		av[3];
 
 	static char*	cmd[] = { "/bin/mkdir", "/usr/5bin/mkdir", 0 };

cde/programs/dtksh/ksh93/src/lib/libast/comp/rmdir.c

@@ -103,7 +103,7 @@ NoN(rmdir)
 
 int
 rmdir __PARAM__((const char* path), (path)) __OTORP__(const char* path;){
-	register int	n;
+	int	n;
 	struct stat	st;
 	char*		av[3];
 

cde/programs/dtksh/ksh93/src/lib/libast/comp/setlocale.c

@@ -104,10 +104,10 @@ typedef struct
 } Locale_t;
 
 char*
-_ast_setlocale __PARAM__((register int category, const char* locale), (category, locale)) __OTORP__(register int category; const char* locale;){
+_ast_setlocale __PARAM__((int category, const char* locale), (category, locale)) __OTORP__(int category; const char* locale;){
 #if _hdr_locale && _lib_setlocale
-	register Locale_t*	lc;
-	register char*		p;
+	Locale_t*	lc;
+	char*		p;
 
 	static Locale_t		def[] =
 	{

cde/programs/dtksh/ksh93/src/lib/libast/comp/spawnveg.c

@@ -176,9 +176,9 @@ spawnveg __PARAM__((const char* cmd, char* const argv[], char* const envv[], pid
 		execve(cmd, argv, envv);
 		if (errno == ENOEXEC)
 		{
-			register char**	o;
-			register char**	p;
-			register char**	v;
+			char**	o;
+			char**	p;
+			char**	v;
 
 			for (p = o = (char**)argv; *p; p++);
 			if (v = newof(0, char*, p - o + 2, 0))

cde/programs/dtksh/ksh93/src/lib/libast/comp/statvfs.c

@@ -126,7 +126,7 @@ NoN(statvfs)
 #endif
 
 static void
-us2v __PARAM__((register struct statfs* ufs, register struct stat* st, register struct statvfs* vfs), (ufs, st, vfs)) __OTORP__(register struct statfs* ufs; register struct stat* st; register struct statvfs* vfs;){
+us2v __PARAM__((struct statfs* ufs, struct stat* st, struct statvfs* vfs), (ufs, st, vfs)) __OTORP__(struct statfs* ufs; struct stat* st; struct statvfs* vfs;){
 	memset(vfs, 0, sizeof(*vfs));
 	vfs->f_bsize = vfs->f_frsize = ufs->f_bsize;
 	vfs->f_blocks = ufs->f_blocks;
@@ -171,7 +171,7 @@ statvfs __PARAM__((const char* path, struct statvfs* vfs), (path, vfs)) __OTORP_
 #else
 
 static void
-s2v __PARAM__((register struct stat* st, register struct statvfs* vfs), (st, vfs)) __OTORP__(register struct stat* st; register struct statvfs* vfs;){
+s2v __PARAM__((struct stat* st, struct statvfs* vfs), (st, vfs)) __OTORP__(struct stat* st; struct statvfs* vfs;){
 	memset(vfs, 0, sizeof(*vfs));
 	vfs->f_bsize = vfs->f_frsize =
 #if _mem_st_blksize_stat

cde/programs/dtksh/ksh93/src/lib/libast/comp/strchr.c

@@ -114,7 +114,7 @@ strchr __PARAM__((const char* s, int c), (s, c)) __OTORP__(const char* s; int c;
 #else
 
 char*
-strchr __PARAM__((register const char* s, register int c), (s, c)) __OTORP__(register const char* s; register int c;){
+strchr __PARAM__((const char* s, int c), (s, c)) __OTORP__(const char* s; int c;){
 	do if (*s == c) return((char*)s); while(*s++);
 	return(0);
 }

cde/programs/dtksh/ksh93/src/lib/libast/comp/strrchr.c

@@ -114,8 +114,8 @@ strrchr __PARAM__((const char* s, int c), (s, c)) __OTORP__(const char* s; int c
 #else
 
 char*
-strrchr __PARAM__((register const char* s, register int c), (s, c)) __OTORP__(register const char* s; register int c;){
-	register const char*	r;
+strrchr __PARAM__((const char* s, int c), (s, c)) __OTORP__(const char* s; int c;){
+	const char*	r;
 
 	r = 0;
 	do if (*s == c) r = s; while(*s++);

cde/programs/dtksh/ksh93/src/lib/libast/comp/strtod.c

@@ -103,7 +103,7 @@ NoN(strtod)
 extern __MANGLE__ double	atof __PROTO__((const char*));
 
 double
-strtod __PARAM__((register const char* s, char** e), (s, e)) __OTORP__(register const char* s; char** e;){
+strtod __PARAM__((const char* s, char** e), (s, e)) __OTORP__(const char* s; char** e;){
 	double	n;
 
 	n = atof(s);

cde/programs/dtksh/ksh93/src/lib/libast/comp/strtol.c

@@ -106,9 +106,9 @@ NoN(strtol)
 #define MBASE	('z' - 'a' + 1 + 10)
 
 long
-strtol __PARAM__((register const char* str, char** ptr, register int base), (str, ptr, base)) __OTORP__(register const char* str; char** ptr; register int base;){
-	register long val;
-	register int c;
+strtol __PARAM__((const char* str, char** ptr, int base), (str, ptr, base)) __OTORP__(const char* str; char** ptr; int base;){
+	long val;
+	int c;
 	int xx, neg = 0;
 
 	if (ptr)

cde/programs/dtksh/ksh93/src/lib/libast/comp/tmpnam.c

@@ -112,8 +112,8 @@ static char	buf[L_tmpnam];
 static char	seed[] = { 'a', 'a', 'a', 0 };
 
 char*
-tmpnam __PARAM__((register char* p), (p)) __OTORP__(register char* p;){
-	register char*	q;
+tmpnam __PARAM__((char* p), (p)) __OTORP__(char* p;){
+	char*	q;
 
 	if (!p) p = buf;
 	strcopy(strcopy(strcopy(p, P_tmpdir), seed), "XXXXXX");

cde/programs/dtksh/ksh93/src/lib/libast/comp/waitpid.c

@@ -157,9 +157,9 @@ struct zombie
 
 pid_t
 waitpid __PARAM__((pid_t pid, int* status, int flags), (pid, status, flags)) __OTORP__(pid_t pid; int* status; int flags;){
-	register struct zombie*	zp;
-	register struct zombie*	pp;
-	register int		p;
+	struct zombie*	zp;
+	struct zombie*	pp;
+	int		p;
 	int			s;
 #if !_lib_wait2 && !_lib_wait3
 #if !defined(SIGCLD)

cde/programs/dtksh/ksh93/src/lib/libast/dir/getdents.c

@@ -144,8 +144,8 @@ getdents __PARAM__((int fd, __V_* buf, size_t siz), (fd, buf, siz)) __OTORP__(in
 #else
 #if _lib_dirread
 	{
-		register char*		sp;	/* system */
-		register struct dirent*	up;	/* user */
+		char*		sp;	/* system */
+		struct dirent*	up;	/* user */
 		char*			u;
 		int			n;
 		int			m;
@@ -187,10 +187,10 @@ getdents __PARAM__((int fd, __V_* buf, size_t siz), (fd, buf, siz)) __OTORP__(in
 
 #define MAXREC	roundof(sizeof(*up)-sizeof(up->d_name)+sizeof(sp->d_name)+1,8)
 
-		register struct direct*	sp;	/* system */
-		register struct dirent*	up;	/* user */
-		register char*		s;
-		register char*		u;
+		struct direct*	sp;	/* system */
+		struct dirent*	up;	/* user */
+		char*		s;
+		char*		u;
 		int			n;
 		int			m;
 		char			tmp[sizeof(sp->d_name) + 1];

cde/programs/dtksh/ksh93/src/lib/libast/dir/opendir.c

@@ -103,9 +103,9 @@ static const char id_dir[] = "\n@(#)directory (AT&T Bell Laboratories) 04/01/93\
 static DIR*	freedirp;		/* always keep one dirp */
 
 DIR*
-opendir __PARAM__((register const char* path), (path)) __OTORP__(register const char* path;){
-	register DIR*	dirp = 0;
-	register int	fd;
+opendir __PARAM__((const char* path), (path)) __OTORP__(const char* path;){
+	DIR*	dirp = 0;
+	int	fd;
 	struct stat	st;
 
 	if ((fd = open(path, 0)) < 0) return(0);
@@ -138,7 +138,7 @@ opendir __PARAM__((register const char* path), (path)) __OTORP__(register const
 }
 
 void
-closedir __PARAM__((register DIR* dirp), (dirp)) __OTORP__(register DIR* dirp;){
+closedir __PARAM__((DIR* dirp), (dirp)) __OTORP__(DIR* dirp;){
 	if (dirp)
 	{
 		close(dirp->dd_fd);

cde/programs/dtksh/ksh93/src/lib/libast/dir/readdir.c

@@ -99,8 +99,8 @@ NoN(readdir)
 #else
 
 struct dirent*
-readdir __PARAM__((register DIR* dirp), (dirp)) __OTORP__(register DIR* dirp;){
-	register struct dirent*	dp;
+readdir __PARAM__((DIR* dirp), (dirp)) __OTORP__(DIR* dirp;){
+	struct dirent*	dp;
 
 	for (;;)
 	{

cde/programs/dtksh/ksh93/src/lib/libast/dir/seekdir.c

@@ -99,7 +99,7 @@ NoN(seekdir)
 #else
 
 void
-seekdir __PARAM__((register DIR* dirp, long loc), (dirp, loc)) __OTORP__(register DIR* dirp; long loc;){
+seekdir __PARAM__((DIR* dirp, long loc), (dirp, loc)) __OTORP__(DIR* dirp; long loc;){
 	off_t	base;		/* file location of block */
 	off_t	offset; 	/* offset within block */
 

cde/programs/dtksh/ksh93/src/lib/libast/disc/sfkeyprintf.c

@@ -134,12 +134,12 @@ typedef union
 #define initfield(f,s)	((f)->first = (f)->delimiter = *((f)->next = (s)))
 
 static char*
-getfield __PARAM__((register Field_t* f, int restore), (f, restore)) __OTORP__(register Field_t* f; int restore;){
-	register char*	s;
-	register int	n;
-	register int	c;
-	register int	lp;
-	register int	rp;
+getfield __PARAM__((Field_t* f, int restore), (f, restore)) __OTORP__(Field_t* f; int restore;){
+	char*	s;
+	int	n;
+	int	c;
+	int	lp;
+	int	rp;
 	char*		b;
 
 	if (!f->delimiter)
@@ -414,7 +414,7 @@ int aha = *f.next;
 
 int
 sfkeyprintf __PARAM__((Sfio_t* sp, __V_* handle, const char* format, Sf_key_lookup_t lookup, Sf_key_convert_t convert), (sp, handle, format, lookup, convert)) __OTORP__(Sfio_t* sp; __V_* handle; const char* format; Sf_key_lookup_t lookup; Sf_key_convert_t convert;){
-	register int	i;
+	int	i;
 
 	for (i = 0; i < elementsof(state.tmp); i++)
 		if (!state.tmp[i] && !(state.tmp[i] = sfstropen()))

cde/programs/dtksh/ksh93/src/lib/libast/feature/align.c

@@ -118,9 +118,9 @@ extern __MANGLE__ int		printf __PROTO__((const char*, ...));
 
 main()
 {
-	register int	i;
-	register int	j;
-	register int	k;
+	int	i;
+	int	j;
+	int	k;
 
 	int		align0;
 	int		align1;

cde/programs/dtksh/ksh93/src/lib/libast/feature/botch.c

@@ -111,7 +111,7 @@ main()
 #if _lib_getgroups
 	if (sizeof(gid_t) < sizeof(int))
 	{
-		register int	n;
+		int	n;
 		gid_t		groups[32 * sizeof(int) / sizeof(gid_t)];
 
 		for (n = 0; n < sizeof(int) / sizeof(gid_t); n++)

cde/programs/dtksh/ksh93/src/lib/libast/feature/int.c

@@ -132,9 +132,9 @@ static int	size[] = { 1, 2, 4, 8 };
 
 main()
 {
-	register int	t;
-	register int	s;
-	register int	m = 1;
+	int	t;
+	int	s;
+	int	m = 1;
 
 	for (s = 0; s < elementsof(size); s++)
 	{

cde/programs/dtksh/ksh93/src/lib/libast/feature/limits.c

@@ -154,8 +154,8 @@ static char*		cmd[] = { "/bin/echo", 0 };
 
 main()
 {
-	register int	i;
-	register int	n;
+	int	i;
+	int	n;
 
 	char		c;
 	unsigned char	uc;

cde/programs/dtksh/ksh93/src/lib/libast/feature/signal.c

@@ -258,9 +258,9 @@ extern __MANGLE__ int		printf __PROTO__((const char*, ...));
 
 main()
 {
-	register int	i;
-	register int	j;
-	register int	k;
+	int	i;
+	int	j;
+	int	k;
 
 	k = 0;
 	for (i = 0; map[i].name; i++)

cde/programs/dtksh/ksh93/src/lib/libast/features/align.c

@@ -110,9 +110,9 @@ extern __MANGLE__ int		printf __PROTO__((const char*, ...));
 
 main()
 {
-	register int	i;
-	register int	j;
-	register int	k;
+	int	i;
+	int	j;
+	int	k;
 
 	int		align0;
 	int		align1;

cde/programs/dtksh/ksh93/src/lib/libast/features/botch.c

@@ -103,7 +103,7 @@ main()
 #if _lib_getgroups
 	if (sizeof(gid_t) < sizeof(int))
 	{
-		register int	n;
+		int	n;
 		gid_t		groups[32 * sizeof(int) / sizeof(gid_t)];
 
 		for (n = 0; n < sizeof(int) / sizeof(gid_t); n++)

cde/programs/dtksh/ksh93/src/lib/libast/features/int.c

@@ -124,9 +124,9 @@ static int	size[] = { 1, 2, 4, 8 };
 
 main()
 {
-	register int	t;
-	register int	s;
-	register int	m = 1;
+	int	t;
+	int	s;
+	int	m = 1;
 
 	for (s = 0; s < elementsof(size); s++)
 	{

cde/programs/dtksh/ksh93/src/lib/libast/features/limits.c

@@ -121,8 +121,8 @@ extern __MANGLE__ int		printf __PROTO__((const char*, ...));
 
 main()
 {
-	register int	i;
-	register int	n;
+	int	i;
+	int	n;
 
 	char		c;
 	unsigned char	uc;

cde/programs/dtksh/ksh93/src/lib/libast/features/signal.c

@@ -280,9 +280,9 @@ extern __MANGLE__ int		printf __PROTO__((const char*, ...));
 
 main()
 {
-	register int	i;
-	register int	j;
-	register int	k;
+	int	i;
+	int	j;
+	int	k;
 	int		n;
 
 	k = 0;

cde/programs/dtksh/ksh93/src/lib/libast/hash/hashalloc.c

@@ -110,9 +110,9 @@ Hash_info_t		hash_info = { 0 };
 Hash_table_t*
 hashalloc __PARAM__((Hash_table_t* ref, ...), (va_alist)) __OTORP__(va_dcl)
 { __OTORP__(Hash_table_t* ref; )
-	register Hash_table_t*	tab;
-	register Hash_table_t*	ret = 0;
-	register int		internal;
+	Hash_table_t*	tab;
+	Hash_table_t*	ret = 0;
+	int		internal;
 	int			n;
 	va_list			ap;
 	va_list			va[4];

cde/programs/dtksh/ksh93/src/lib/libast/hash/hashdump.c

@@ -97,7 +97,7 @@
  */
 
 static void
-dumpflags __PARAM__((register int flags), (flags)) __OTORP__(register int flags;){
+dumpflags __PARAM__((int flags), (flags)) __OTORP__(int flags;){
 	if (flags & HASH_ALLOCATE) sfprintf(sfstderr, "allocate ");
 	if (flags & HASH_BUCKET) sfprintf(sfstderr, "bucket ");
 	if (flags & HASH_FIXED) sfprintf(sfstderr, "fixed ");
@@ -113,9 +113,9 @@ dumpflags __PARAM__((register int flags), (flags)) __OTORP__(register int flags;
  */
 
 static void
-dumpbucket __PARAM__((register Hash_table_t* tab, int flags), (tab, flags)) __OTORP__(register Hash_table_t* tab; int flags;){
-	register Hash_bucket_t**	sp;
-	register Hash_bucket_t*		b;
+dumpbucket __PARAM__((Hash_table_t* tab, int flags), (tab, flags)) __OTORP__(Hash_table_t* tab; int flags;){
+	Hash_bucket_t**	sp;
+	Hash_bucket_t*		b;
 	Hash_bucket_t**			sx;
 	int				n;
 	unsigned char*			s;
@@ -163,7 +163,7 @@ dumpbucket __PARAM__((register Hash_table_t* tab, int flags), (tab, flags)) __OT
  */
 
 static void
-dumptable __PARAM__((register Hash_table_t* tab, register int flags), (tab, flags)) __OTORP__(register Hash_table_t* tab; register int flags;){
+dumptable __PARAM__((Hash_table_t* tab, int flags), (tab, flags)) __OTORP__(Hash_table_t* tab; int flags;){
 	Hash_table_t*	scope;
 	int		level;
 
@@ -192,8 +192,8 @@ dumptable __PARAM__((register Hash_table_t* tab, register int flags), (tab, flag
  */
 
 static void
-dumproot __PARAM__((register Hash_root_t* root, register int flags), (root, flags)) __OTORP__(register Hash_root_t* root; register int flags;){
-	register Hash_table_t*	tab;
+dumproot __PARAM__((Hash_root_t* root, int flags), (root, flags)) __OTORP__(Hash_root_t* root; int flags;){
+	Hash_table_t*	tab;
 
 	sfprintf(sfstderr, "    root\n");
 	sfprintf(sfstderr, "        address:     0x%08lx\n", (unsigned long)root);
@@ -221,8 +221,8 @@ dumproot __PARAM__((register Hash_root_t* root, register int flags), (root, flag
  */
 
 void
-hashdump __PARAM__((register Hash_table_t* tab, int flags), (tab, flags)) __OTORP__(register Hash_table_t* tab; int flags;){
-	register Hash_root_t*	root;
+hashdump __PARAM__((Hash_table_t* tab, int flags), (tab, flags)) __OTORP__(Hash_table_t* tab; int flags;){
+	Hash_root_t*	root;
 
 	sfprintf(sfstderr, "\nhash table information:\n\n");
 	if (tab) dumproot(tab->root, flags);

cde/programs/dtksh/ksh93/src/lib/libast/hash/hashfree.c

@@ -100,10 +100,10 @@
  */
 
 Hash_table_t*
-hashfree __PARAM__((register Hash_table_t* tab), (tab)) __OTORP__(register Hash_table_t* tab;){
-	register Hash_bucket_t**	sp;
-	register Hash_bucket_t*		b;
-	register Hash_bucket_t*		p;
+hashfree __PARAM__((Hash_table_t* tab), (tab)) __OTORP__(Hash_table_t* tab;){
+	Hash_bucket_t**	sp;
+	Hash_bucket_t*		b;
+	Hash_bucket_t*		p;
 	Hash_bucket_t**			sx;
 	Hash_root_t*			rp;
 	Hash_table_t*			tp;

cde/programs/dtksh/ksh93/src/lib/libast/hash/hashlib.h

@@ -162,11 +162,11 @@ typedef struct				/* root local pointers		*/
 #define HASH(r,n,h)	if (r->local->hash) h = r->namesize ? (*r->local->hash)(n, r->namesize) : (*r->local->hash)(n);\
 			else\
 			{\
-				register const char*	_hash_s1 = n;\
+				const char*	_hash_s1 = n;\
 				h = 0;\
 				if (r->namesize)\
 				{\
-					register const char*	_hash_s2 = _hash_s1 + r->namesize;\
+					const char*	_hash_s2 = _hash_s1 + r->namesize;\
 					while (_hash_s1 < _hash_s2) HASHPART(h, *_hash_s1++);\
 				}\
 				else while (*_hash_s1) HASHPART(h, *_hash_s1++);\

cde/programs/dtksh/ksh93/src/lib/libast/hash/hashlook.c

@@ -97,19 +97,19 @@
  */
 
 char*
-hashlook __PARAM__((register Hash_table_t* tab, const char* name, long flags, const char* value), (tab, name, flags, value)) __OTORP__(register Hash_table_t* tab; const char* name; long flags; const char* value;){
-	register Hash_bucket_t*	b;
-	register unsigned int	n;
-	register Hash_last_t*	last;
+hashlook __PARAM__((Hash_table_t* tab, const char* name, long flags, const char* value), (tab, name, flags, value)) __OTORP__(Hash_table_t* tab; const char* name; long flags; const char* value;){
+	Hash_bucket_t*	b;
+	unsigned int	n;
+	Hash_last_t*	last;
 	Hash_table_t*		top;
 	Hash_bucket_t*		prev;
 	unsigned int		i;
 
 	if ((flags & (HASH_LOOKUP|HASH_INTERNAL)) == (HASH_LOOKUP|HASH_INTERNAL))
 	{
-		register char*		s1;
-		register const char*	s2;
-		register int		c;
+		char*		s1;
+		const char*	s2;
+		int		c;
 
 		if (flags & HASH_HASHED) n = *((unsigned int*)value);
 		else
@@ -166,12 +166,12 @@ hashlook __PARAM__((register Hash_table_t* tab, const char* name, long flags, co
 				{
 					if (!tab->root->local->compare)
 					{
-						register char*		s1 = hashname(b);
-						register const char*	s2 = name;
+						char*		s1 = hashname(b);
+						const char*	s2 = name;
 
 						if (tab->root->namesize)
 						{
-							register char*	s3 = s1 + tab->root->namesize;
+							char*	s3 = s1 + tab->root->namesize;
 
 							while (*s1++ == *s2++)
 								if (s1 >= s3) goto found;

cde/programs/dtksh/ksh93/src/lib/libast/hash/hashscan.c

@@ -107,8 +107,8 @@
  */
 
 Hash_position_t*
-hashscan __PARAM__((register Hash_table_t* tab, register int flags), (tab, flags)) __OTORP__(register Hash_table_t* tab; register int flags;){
-	register Hash_position_t*	pos;
+hashscan __PARAM__((Hash_table_t* tab, int flags), (tab, flags)) __OTORP__(Hash_table_t* tab; int flags;){
+	Hash_position_t*	pos;
 
 	static Hash_bucket_t		empty;
 
@@ -122,12 +122,12 @@ hashscan __PARAM__((register Hash_table_t* tab, register int flags), (tab, flags
 		pos->flags = HASH_SCOPE;
 		do
 		{
-			register Hash_bucket_t*	b;
+			Hash_bucket_t*	b;
 
 			if (tab->flags & HASH_SCANNING)
 			{
-				register Hash_bucket_t**	sp = tab->table;
-				register Hash_bucket_t**	sx = tab->table + tab->size;
+				Hash_bucket_t**	sp = tab->table;
+				Hash_bucket_t**	sx = tab->table + tab->size;
 
 				while (sp < sx)
 					for (b = *sp++; b; b = b->next)
@@ -147,8 +147,8 @@ hashscan __PARAM__((register Hash_table_t* tab, register int flags), (tab, flags
  */
 
 Hash_bucket_t*
-hashnext __PARAM__((register Hash_position_t* pos), (pos)) __OTORP__(register Hash_position_t* pos;){
-	register Hash_bucket_t*	b;
+hashnext __PARAM__((Hash_position_t* pos), (pos)) __OTORP__(Hash_position_t* pos;){
+	Hash_bucket_t*	b;
 
 	if (!pos) return(hash_info.last = pos->tab->root->last.bucket = 0);
 	b = pos->bucket;
@@ -173,7 +173,7 @@ hashnext __PARAM__((register Hash_position_t* pos), (pos)) __OTORP__(register Ha
 		if (!(b->hash & HASH_DELETED) && (!(pos->tab->flags & HASH_VALUE) || b->value) && (!pos->flags || !(b->hash & (HASH_HIDDEN|HASH_HIDES)))) break;
 		if (b->hash & HASH_HIDES)
 		{
-			register Hash_bucket_t*	h = (Hash_bucket_t*)b->name;
+			Hash_bucket_t*	h = (Hash_bucket_t*)b->name;
 
 			if (!(h->hash & HASH_HIDDEN))
 			{
@@ -191,7 +191,7 @@ hashnext __PARAM__((register Hash_position_t* pos), (pos)) __OTORP__(register Ha
  */
 
 void
-hashdone __PARAM__((register Hash_position_t* pos), (pos)) __OTORP__(register Hash_position_t* pos;){
+hashdone __PARAM__((Hash_position_t* pos), (pos)) __OTORP__(Hash_position_t* pos;){
 	if (pos)
 	{
 		if (pos->tab->flags & HASH_SCANNING)

cde/programs/dtksh/ksh93/src/lib/libast/hash/hashsize.c

@@ -98,11 +98,11 @@
  */
 
 void
-hashsize __PARAM__((register Hash_table_t* tab, int size), (tab, size)) __OTORP__(register Hash_table_t* tab; int size;){
-	register Hash_bucket_t**	old_s;
-	register Hash_bucket_t**	new_s;
-	register Hash_bucket_t*		old_b;
-	register Hash_bucket_t*		new_b;
+hashsize __PARAM__((Hash_table_t* tab, int size), (tab, size)) __OTORP__(Hash_table_t* tab; int size;){
+	Hash_bucket_t**	old_s;
+	Hash_bucket_t**	new_s;
+	Hash_bucket_t*		old_b;
+	Hash_bucket_t*		new_b;
 	Hash_bucket_t**			old_sx;
 	unsigned int			index;
 	HASHregion			region;

cde/programs/dtksh/ksh93/src/lib/libast/hash/hashwalk.c

@@ -98,8 +98,8 @@
 
 int
 hashwalk __PARAM__((Hash_table_t* tab, int flags, register(*walker)(const char*, char*, __V_*), __V_* handle), (tab, flags, walker, handle)) __OTORP__(Hash_table_t* tab; int flags; register(*walker)(); __V_* handle;){
-	register Hash_bucket_t*	b;
-	register int		v;
+	Hash_bucket_t*	b;
+	int		v;
 	Hash_position_t*	pos;
 
 	if (!(pos = hashscan(tab, flags))) return(-1);

cde/programs/dtksh/ksh93/src/lib/libast/hash/memhash.c

@@ -98,9 +98,9 @@
 
 unsigned int
 memhash __PARAM__((const __V_* as, int n), (as, n)) __OTORP__(const __V_* as; int n;){
-	register const unsigned char*	s = (const unsigned char*)as;
-	register const unsigned char*	e = s + n;
-	register unsigned int		c = 0;
+	const unsigned char*	s = (const unsigned char*)as;
+	const unsigned char*	e = s + n;
+	unsigned int		c = 0;
 
 	while (s < e) HASHPART(c, *s++);
 	return(c);

cde/programs/dtksh/ksh93/src/lib/libast/hash/memsum.c

@@ -102,9 +102,9 @@
  */
 
 unsigned long
-memsum __PARAM__((const __V_* ap, int n, register unsigned long c), (ap, n, c)) __OTORP__(const __V_* ap; int n; register unsigned long c;){
-	register const unsigned char*	p = (const unsigned char*)ap;
-	register const unsigned char*	e = p + n;
+memsum __PARAM__((const __V_* ap, int n, unsigned long c), (ap, n, c)) __OTORP__(const __V_* ap; int n; unsigned long c;){
+	const unsigned char*	p = (const unsigned char*)ap;
+	const unsigned char*	e = p + n;
 
 	while (p < e) HASHPART(c, *p++);
 #if LONG_MAX > 2147483647

cde/programs/dtksh/ksh93/src/lib/libast/hash/strhash.c

@@ -98,9 +98,9 @@
 
 unsigned int
 strhash __PARAM__((const char* as), (as)) __OTORP__(const char* as;){
-	register const unsigned char*	s = (const unsigned char*)as;
-	register unsigned int		i = 0;
-	register unsigned int		c;
+	const unsigned char*	s = (const unsigned char*)as;
+	unsigned int		i = 0;
+	unsigned int		c;
 
 	while (c = *s++) HASHPART(i, c);
 	return(i);

cde/programs/dtksh/ksh93/src/lib/libast/hash/strsum.c

@@ -102,9 +102,9 @@
  */
 
 unsigned long
-strsum __PARAM__((const char* as, register unsigned long c), (as, c)) __OTORP__(const char* as; register unsigned long c;){
-	register const unsigned char*	s = (const unsigned char*)as;
-	register int			n;
+strsum __PARAM__((const char* as, unsigned long c), (as, c)) __OTORP__(const char* as; unsigned long c;){
+	const unsigned char*	s = (const unsigned char*)as;
+	int			n;
 
 	while (n = *s++) HASHPART(c, n);
 #if LONG_MAX > 2147483647

cde/programs/dtksh/ksh93/src/lib/libast/misc/calloc.c

@@ -103,10 +103,10 @@
 #undef	calloc
 
 __V_*
-calloc __PARAM__((register size_t count, register size_t size), (count, size)) __OTORP__(register size_t count; register size_t size;)
+calloc __PARAM__((size_t count, size_t size), (count, size)) __OTORP__(size_t count; size_t size;)
 #line 15
 {
-	register __V_*	ptr;
+	__V_*	ptr;
 
 	if (ptr = malloc(size *= count))
 		memzero(ptr, size);

cde/programs/dtksh/ksh93/src/lib/libast/misc/cmdclose.c

@@ -104,10 +104,10 @@
 #include <wait.h>
 
 int
-cmdclose __PARAM__((register int fd), (fd)) __OTORP__(register int fd;)
+cmdclose __PARAM__((int fd), (fd)) __OTORP__(int fd;)
 #line 17
 {
-	register struct cmdinfo*	cmd;
+	struct cmdinfo*	cmd;
 	int				status = -1;
 
 	for (cmd = cmds; cmd; cmd = cmd->next)

cde/programs/dtksh/ksh93/src/lib/libast/misc/cmdkill.c

@@ -102,10 +102,10 @@
 #include "cmdlib.h"
 
 int
-cmdkill __PARAM__((register int fd, int sig), (fd, sig)) __OTORP__(register int fd; int sig;)
+cmdkill __PARAM__((int fd, int sig), (fd, sig)) __OTORP__(int fd; int sig;)
 #line 13
 {
-	register struct cmdinfo*	cmd;
+	struct cmdinfo*	cmd;
 
 	for (cmd = cmds; cmd; cmd = cmd->next)
 		if (cmd->fd == fd)

cde/programs/dtksh/ksh93/src/lib/libast/misc/cmdopen.c

@@ -150,7 +150,7 @@ static const Namval_t		options[] =
  */
 
 static int
-setopt __PARAM__((register __V_* a, register const __V_* p, register int n, const char* v), (a, p, n, v)) __OTORP__(register __V_* a; register const __V_* p; register int n; const char* v;)
+setopt __PARAM__((__V_* a, const __V_* p, int n, const char* v), (a, p, n, v)) __OTORP__(__V_* a; const __V_* p; int n; const char* v;)
 #line 66
 {
 	NoP(v);
@@ -208,9 +208,9 @@ int
 cmdopen __PARAM__((const char* cmd, char** argv, char** envv, int* redv, const char* mode), (cmd, argv, envv, redv, mode)) __OTORP__(const char* cmd; char** argv; char** envv; int* redv; const char* mode;)
 #line 119
 {
-	register struct cmdinfo*	proc;
-	register int			cmdfd = -1;
-	register char**			p;
+	struct cmdinfo*	proc;
+	int			cmdfd = -1;
+	char**			p;
 	char**				v;
 	int*				r;
 	int				flags = 0;

cde/programs/dtksh/ksh93/src/lib/libast/misc/error.c

@@ -136,7 +136,7 @@ static const Namval_t		options[] =
  */
 
 static int
-setopt __PARAM__((__V_* a, const __V_* p, register int n, register const char* v), (a, p, n, v)) __OTORP__(__V_* a; const __V_* p; register int n; register const char* v;){
+setopt __PARAM__((__V_* a, const __V_* p, int n, const char* v), (a, p, n, v)) __OTORP__(__V_* a; const __V_* p; int n; const char* v;){
 	NoP(a);
 	if (p) switch (((Namval_t*)p)->value)
 	{
@@ -192,8 +192,8 @@ setopt __PARAM__((__V_* a, const __V_* p, register int n, register const char* v
  */
 
 static void
-print __PARAM__((register Sfio_t* sp, register char* name, char* delim), (sp, name, delim)) __OTORP__(register Sfio_t* sp; register char* name; char* delim;){
-	register int	c;
+print __PARAM__((Sfio_t* sp, char* name, char* delim), (sp, name, delim)) __OTORP__(Sfio_t* sp; char* name; char* delim;){
+	int	c;
 
 	while (c = *name++)
 	{
@@ -217,7 +217,7 @@ print __PARAM__((register Sfio_t* sp, register char* name, char* delim), (sp, na
  */
 
 static void
-context __PARAM__((register Sfio_t* sp, register Error_context_t* cp), (sp, cp)) __OTORP__(register Sfio_t* sp; register Error_context_t* cp;){
+context __PARAM__((Sfio_t* sp, Error_context_t* cp), (sp, cp)) __OTORP__(Sfio_t* sp; Error_context_t* cp;){
 	if (cp->context) context(sp, cp->context);
 	if (!(cp->flags & ERROR_SILENT))
 	{
@@ -243,7 +243,7 @@ error __PARAM__((int level, ...), (va_alist)) __OTORP__(va_dcl)
 
 void
 errorv __PARAM__((const char* lib, int level, va_list ap), (lib, level, ap)) __OTORP__(const char* lib; int level; va_list ap;){
-	register int	n;
+	int	n;
 	int		fd;
 	int		flags;
 	char*		s;

cde/programs/dtksh/ksh93/src/lib/libast/misc/fastfind.c

@@ -115,11 +115,11 @@ typedef struct
 
 __V_*
 findopen __PARAM__((const char* pattern), (pattern)) __OTORP__(const char* pattern;){
-	register Find_t*	fp;
-	register char*		p;
-	register char*		s;
-	register char*		b;
-	register int		i; 
+	Find_t*	fp;
+	char*		p;
+	char*		s;
+	char*		b;
+	int		i;
 	int			brace = 0;
 	int			paren = 0;
 
@@ -216,7 +216,7 @@ findopen __PARAM__((const char* pattern), (pattern)) __OTORP__(const char* patte
 
 void
 findclose __PARAM__((__V_* handle), (handle)) __OTORP__(__V_* handle;){
-	register Find_t*	fp = (Find_t*)handle;
+	Find_t*	fp = (Find_t*)handle;
 
 	sfclose(fp->fp);
 	free(fp);
@@ -229,12 +229,12 @@ findclose __PARAM__((__V_* handle), (handle)) __OTORP__(__V_* handle;){
 
 char*
 findnext __PARAM__((__V_* handle), (handle)) __OTORP__(__V_* handle;){
-	register Find_t*	fp = (Find_t*)handle;
-	register char*		p;
-	register char*		q;
-	register char*		s;
-	register char*		b;
-	register int		c;
+	Find_t*	fp = (Find_t*)handle;
+	char*		p;
+	char*		q;
+	char*		s;
+	char*		b;
+	int		c;
 	int			n;
 
 	for (c = fp->peek; c != EOF;)

cde/programs/dtksh/ksh93/src/lib/libast/misc/fs3d.c

@@ -94,9 +94,9 @@
 #include <fs3d.h>
 
 int
-fs3d __PARAM__((register int op), (op)) __OTORP__(register int op;){
-	register int	cur;
-	register char*	v;
+fs3d __PARAM__((int op), (op)) __OTORP__(int op;){
+	int	cur;
+	char*	v;
 	char		val[sizeof(FS3D_off) + 8];
 
 	static int	fsview;

cde/programs/dtksh/ksh93/src/lib/libast/misc/ftwalk.c

@@ -122,9 +122,9 @@
 static Ftw_t	*Free;
 #define freeFtw(f)	((f)->link = Free, Free = (f))
 
-static Ftw_t *newFtw __PARAM__((register char* name, register int namelen), (name, namelen)) __OTORP__(register char* name; register int namelen;){
-	register Ftw_t	*f;
-	register int	amount;
+static Ftw_t *newFtw __PARAM__((char* name, int namelen), (name, namelen)) __OTORP__(char* name; int namelen;){
+	Ftw_t	*f;
+	int	amount;
 
 	if(Free && namelen < MINNAME)
 		f = Free, Free = f->link;
@@ -144,9 +144,9 @@ static Ftw_t *newFtw __PARAM__((register char* name, register int namelen), (nam
 	return f;
 }
 
-static int freeAll __PARAM__((register Ftw_t* f, register int rv), (f, rv)) __OTORP__(register Ftw_t* f; register int rv;){
-	register Ftw_t	*next;
-	register int	freeing;
+static int freeAll __PARAM__((Ftw_t* f, int rv), (f, rv)) __OTORP__(Ftw_t* f; int rv;){
+	Ftw_t	*next;
+	int	freeing;
 
 	for(freeing = 0; freeing < 2; ++freeing)
 	{
@@ -165,8 +165,8 @@ static int freeAll __PARAM__((register Ftw_t* f, register int rv), (f, rv)) __OT
 /*
 	To compare directories by device/inode.
 */
-static int statcmp __PARAM__((register Ftw_t* f1, register Ftw_t* f2), (f1, f2)) __OTORP__(register Ftw_t* f1; register Ftw_t* f2;){
-	register int	d;
+static int statcmp __PARAM__((Ftw_t* f1, Ftw_t* f2), (f1, f2)) __OTORP__(Ftw_t* f1; Ftw_t* f2;){
+	int	d;
 	if((d = f1->statb.st_ino - f2->statb.st_ino) != 0)
 		return d;
 	if((d = f1->statb.st_dev - f2->statb.st_dev) != 0)
@@ -182,9 +182,9 @@ static int statcmp __PARAM__((register Ftw_t* f1, register Ftw_t* f2), (f1, f2))
 #define RROTATE(r)	(t = r->left, r->left = t->right, t->right = r, r = t)
 #define LROTATE(r)	(t = r->right, r->right = t->left, t->left = r, r = t)
 
-static Ftw_t *search __PARAM__((register Ftw_t* e, register Ftw_t* root, int(*comparf)(Ftw_t*, Ftw_t*), int insert), (e, root, comparf, insert)) __OTORP__(register Ftw_t* e; register Ftw_t* root; int(*comparf)(); int insert;){
-	register int		cmp;
-	register Ftw_t		*t, *left, *right, *lroot, *rroot;
+static Ftw_t *search __PARAM__((Ftw_t* e, Ftw_t* root, int(*comparf)(Ftw_t*, Ftw_t*), int insert), (e, root, comparf, insert)) __OTORP__(Ftw_t* e; Ftw_t* root; int(*comparf)(); int insert;){
+	int		cmp;
+	Ftw_t		*t, *left, *right, *lroot, *rroot;
 
 	left = right = lroot = rroot = 0;
 	while(root)
@@ -247,8 +247,8 @@ static Ftw_t *search __PARAM__((register Ftw_t* e, register Ftw_t* root, int(*co
 /*
 **	Delete the root element from the tree
 */
-static Ftw_t *deleteroot __PARAM__((register Ftw_t* root), (root)) __OTORP__(register Ftw_t* root;){
-	register Ftw_t *t, *left, *right;
+static Ftw_t *deleteroot __PARAM__((Ftw_t* root), (root)) __OTORP__(Ftw_t* root;){
+	Ftw_t *t, *left, *right;
 
 	left = root->left;
 	right = root->right;
@@ -267,7 +267,7 @@ static Ftw_t *deleteroot __PARAM__((register Ftw_t* root), (root)) __OTORP__(reg
 /*
 	Convert a binary search tree into a sorted todo (link) list
 */
-static void getlist __PARAM__((register Ftw_t** top, register Ftw_t** bot, register Ftw_t* root), (top, bot, root)) __OTORP__(register Ftw_t** top; register Ftw_t** bot; register Ftw_t* root;){
+static void getlist __PARAM__((Ftw_t** top, Ftw_t** bot, Ftw_t* root), (top, bot, root)) __OTORP__(Ftw_t** top; Ftw_t** bot; Ftw_t* root;){
 	if(root->left)
 		getlist(top,bot,root->left);
 	if (*top) (*bot)->link = root, *bot = root;
@@ -279,8 +279,8 @@ static void getlist __PARAM__((register Ftw_t** top, register Ftw_t** bot, regis
 /*
 	Set directory when curdir is lost in space
 */
-static int setdir __PARAM__((register char* home, register char* path), (home, path)) __OTORP__(register char* home; register char* path;){
-	register int	cdrv;
+static int setdir __PARAM__((char* home, char* path), (home, path)) __OTORP__(char* home; char* path;){
+	int	cdrv;
 
 	if(path[0] == '/')
 		cdrv = pathcd(path,NiL);
@@ -298,8 +298,8 @@ static int setdir __PARAM__((register char* home, register char* path), (home, p
 /*
 	Set to parent dir
 */
-static int setpdir __PARAM__((register char* home, register char* path, register char* base), (home, path, base)) __OTORP__(register char* home; register char* path; register char* base;){
-	register int	cdrv, c;
+static int setpdir __PARAM__((char* home, char* path, char* base), (home, path, base)) __OTORP__(char* home; char* path; char* base;){
+	int	cdrv, c;
 
 	if(base > path)
 	{
@@ -315,9 +315,9 @@ static int setpdir __PARAM__((register char* home, register char* path, register
 /*
 	Pop a set of directories
 */
-static int popdirs __PARAM__((register int n_dir, register Ftw_t* ftw), (n_dir, ftw)) __OTORP__(register int n_dir; register Ftw_t* ftw;){
+static int popdirs __PARAM__((int n_dir, Ftw_t* ftw), (n_dir, ftw)) __OTORP__(int n_dir; Ftw_t* ftw;){
 	struct stat	sb;
-	register char	*s, *endbuf;
+	char	*s, *endbuf;
 	char		buf[PATH_MAX];
 
 	if(!ftw || ftw->level < 0)
@@ -340,11 +340,11 @@ static int popdirs __PARAM__((register int n_dir, register Ftw_t* ftw), (n_dir,
 /*
 	Get top list of elt to process
 */
-static Ftw_t *toplist __PARAM__((register char** paths, int(*statf)(const char*, struct stat*),int(*comparf)(Ftw_t*, Ftw_t*), int metaphysical), (paths, statf, comparf, metaphysical)) __OTORP__(register char** paths; int(*statf)();int(*comparf)(); int metaphysical;){
-	register char		*path;
-	register Ftw_t		*f, *root;
+static Ftw_t *toplist __PARAM__((char** paths, int(*statf)(const char*, struct stat*),int(*comparf)(Ftw_t*, Ftw_t*), int metaphysical), (paths, statf, comparf, metaphysical)) __OTORP__(char** paths; int(*statf)();int(*comparf)(); int metaphysical;){
+	char		*path;
+	Ftw_t		*f, *root;
 	Ftw_t			*top, *bot;
-	register struct stat	*sb;
+	struct stat	*sb;
 	struct stat		st;
 
 	top = bot = root = 0;
@@ -389,9 +389,9 @@ static Ftw_t *toplist __PARAM__((register char** paths, int(*statf)(const char*,
 	Note that free() is not used because we may need to chdir(home)
 	if there isn't enough space to continue
 */
-static int resize __PARAM__((register char** home, register char** endbuf, register char** path, register char** base, int n_buf, int incre), (home, endbuf, path, base, n_buf, incre)) __OTORP__(register char** home; register char** endbuf; register char** path; register char** base; int n_buf; int incre;){
-	register char	*old, *newp;
-	register int		n_old;
+static int resize __PARAM__((char** home, char** endbuf, char** path, char** base, int n_buf, int incre), (home, endbuf, path, base, n_buf, incre)) __OTORP__(char** home; char** endbuf; char** path; char** base; int n_buf; int incre;){
+	char	*old, *newp;
+	int		n_old;
 
 	/* add space for "/." used in testing FTW_DNX */
 	n_old = n_buf;
@@ -418,7 +418,7 @@ static int resize __PARAM__((register char** home, register char** endbuf, regis
 */
 ftwalk __PARAM__((const char *cpath, int (*userf)(Ftw_t*), int flags, int (*comparf)(Ftw_t*, Ftw_t*)), (cpath, userf, flags, comparf)) __OTORP__(const char *cpath; int (*userf)(); int flags; int (*comparf)();){
 	char		*path = (char*)cpath;
-	register int	cdrv;		/* chdir value */
+	int	cdrv;		/* chdir value */
 	int		fnrv;		/* return value from user function */
 	Ftw_t		topf,		/* the parent of top elt */
 			*todo, *top, *bot;
@@ -478,14 +478,14 @@ ftwalk __PARAM__((const char *cpath, int (*userf)(Ftw_t*), int flags, int (*comp
 	dirfp = 0;
 	while(todo)
 	{
-		register int		i, nd;
-		register Ftw_t		*ftw, *f;
-		register struct stat	*sb;
-		register char		*name, *endbase;
+		int		i, nd;
+		Ftw_t		*ftw, *f;
+		struct stat	*sb;
+		char		*name, *endbase;
 		Ftw_t			*link, *root, *curdir, *diroot, *dotdot;
 		struct dirent		*dir;
 		char			*base;
-		register int		level, n_base, nostat, cpname;
+		int		level, n_base, nostat, cpname;
 
 		/* process the top object on the stack */
 		ftw = todo;

cde/programs/dtksh/ksh93/src/lib/libast/misc/ftwflags.c

@@ -95,7 +95,7 @@
 
 int
 ftwflags __PARAM__((void), ()){
-	register char*	s;
+	char*	s;
 	
 	s = astconf("PATH_RESOLVE", NiL, NiL);
 	if (streq(s, "physical"))

cde/programs/dtksh/ksh93/src/lib/libast/misc/getcwd.c

@@ -111,8 +111,8 @@ struct dirlist				/* long path chdir(2) component	*/
  */
 
 static int
-popdir __PARAM__((register struct dirlist* d, register char* end), (d, end)) __OTORP__(register struct dirlist* d; register char* end;){
-	register struct dirlist*	dp;
+popdir __PARAM__((struct dirlist* d, char* end), (d, end)) __OTORP__(struct dirlist* d; char* end;){
+	struct dirlist*	dp;
 	int				v;
 
 	v = 0;
@@ -135,8 +135,8 @@ popdir __PARAM__((register struct dirlist* d, register char* end), (d, end)) __O
  */
 
 static struct dirlist*
-pushdir __PARAM__((register struct dirlist* d, char* dots, char* path, char* end), (d, dots, path, end)) __OTORP__(register struct dirlist* d; char* dots; char* path; char* end;){
-	register struct dirlist*	p;
+pushdir __PARAM__((struct dirlist* d, char* dots, char* path, char* end), (d, dots, path, end)) __OTORP__(struct dirlist* d; char* dots; char* path; char* end;){
+	struct dirlist*	p;
 
 	if (!(p = newof(0, struct dirlist, 1, 0)) || chdir(dots))
 	{
@@ -162,9 +162,9 @@ pushdir __PARAM__((register struct dirlist* d, char* dots, char* path, char* end
 
 char*
 getcwd __PARAM__((char* buf, size_t len), (buf, len)) __OTORP__(char* buf; size_t len;){
-	register char*	d;
-	register char*	p;
-	register char*	s;
+	char*	d;
+	char*	p;
+	char*	s;
 	DIR*		dirp = 0;
 	int		n;
 	int		x;

cde/programs/dtksh/ksh93/src/lib/libast/misc/getpath.c

@@ -104,7 +104,7 @@ char*
 getpath __PARAM__((void), ())
 #line 13
 {
-	register char*	s;
+	char*	s;
 
 	if (!(s = getenv("PATH")) || !*s) s = ":/bin:/usr/bin:/usr/ucb";
 	return(s);

cde/programs/dtksh/ksh93/src/lib/libast/misc/getshell.c

@@ -118,9 +118,9 @@ char*
 getshell __PARAM__((void), ())
 #line 28
 {
-	register char*	s;
-	register char*	sh;
-	register int	i;
+	char*	s;
+	char*	sh;
+	int	i;
 
 	if ((sh = getenv("SHELL")) && *sh == '/' && strmatch(sh, "*/(sh|*[!cC]sh)"))
 	{

cde/programs/dtksh/ksh93/src/lib/libast/misc/getsymlink.c

@@ -127,10 +127,10 @@ getsymlink __PARAM__((const char* name, char* buf, int siz), (name, buf, siz)) _
 #ifdef UNIV_MAX
 	if (isspace(*buf))
 	{
-		register char*	s;
-		register char*	t;
-		register char*	u;
-		register char*	v;
+		char*	s;
+		char*	t;
+		char*	u;
+		char*	v;
 		int		match = 0;
 		char		tmp[PATH_MAX];
 

cde/programs/dtksh/ksh93/src/lib/libast/misc/getuniv.c

@@ -112,16 +112,16 @@ getuniv __PARAM__((void), ())
 	return(getuniverse(buf) < 0 ? 0 : buf);
 #else
 #ifndef UNIV_MAX
-	register char*	u;
-	register char*	p;
+	char*	u;
+	char*	p;
 
 	if (!(u = getenv(univ_env)) || !*u)
 	{
 		u = _UNIV_DEFAULT;
 		if (p = getenv("PATH"))
 		{
-			register int	r = 1;
-			register char*	d = p;
+			int	r = 1;
+			char*	d = p;
 			int		offset = staktell();
 
 			for (;;)
@@ -180,7 +180,7 @@ getuniv __PARAM__((void), ())
 	return(buf);
 #else
 #if defined(ATT_UNIV) || defined(U_GET)
-	register int	n;
+	int	n;
 
 #if defined(ATT_UNIV)
 	if ((n = setuniverse(ATT_UNIV)) < 0) return(0);

cde/programs/dtksh/ksh93/src/lib/libast/misc/hsort.c

@@ -102,10 +102,10 @@ void
 hsort __PARAM__((char** argv, int n, int(*fn)(const char*, const char*)), (argv, n, fn)) __OTORP__(char** argv; int n; int(*fn)();)
 #line 15
 {
-	register int 	i;
-	register int 	j;
-	register int 	m;
-	register char**	ap;
+	int 	i;
+	int 	j;
+	int 	m;
+	char**	ap;
 	char*		s;
 	int 		k;
 

cde/programs/dtksh/ksh93/src/lib/libast/misc/magic.c

@@ -151,9 +151,9 @@ _vmopen __PARAM__((void), ()){
 }
 
 static void
-vmclose __PARAM__((register Vmalloc_t* vp), (vp)) __OTORP__(register Vmalloc_t* vp;){
-	register Vmchunk_t*	cp;
-	register Vmchunk_t*	np;
+vmclose __PARAM__((Vmalloc_t* vp), (vp)) __OTORP__(Vmalloc_t* vp;){
+	Vmchunk_t*	cp;
+	Vmchunk_t*	np;
 
 	if (vp)
 	{
@@ -168,7 +168,7 @@ vmclose __PARAM__((register Vmalloc_t* vp), (vp)) __OTORP__(register Vmalloc_t*
 }
 
 static __V_*
-vmalloc __PARAM__((register Vmalloc_t* vp, size_t size), (vp, size)) __OTORP__(register Vmalloc_t* vp; size_t size;){
+vmalloc __PARAM__((Vmalloc_t* vp, size_t size), (vp, size)) __OTORP__(Vmalloc_t* vp; size_t size;){
 	char*	p;
 	size_t	n;
 
@@ -385,8 +385,8 @@ static Dict_t		info[] =
  */
 
 static char*
-getdata __PARAM__((register Magic_t* mp, register long off, register int siz), (mp, off, siz)) __OTORP__(register Magic_t* mp; register long off; register int siz;){
-	register long	n;
+getdata __PARAM__((Magic_t* mp, long off, int siz), (mp, off, siz)) __OTORP__(Magic_t* mp; long off; int siz;){
+	long	n;
 
 	if (off + siz <= mp->fbsz) return(mp->fbuf + off);
 	if (off < mp->xoff || off + siz > mp->xoff + mp->xbsz)
@@ -413,10 +413,10 @@ getdata __PARAM__((register Magic_t* mp, register long off, register int siz), (
 
 static long
 indirect __PARAM__((const char* cs, char** e, __V_* handle), (cs, e, handle)) __OTORP__(const char* cs; char** e; __V_* handle;){
-	register char*		s = (char*)cs;
-	register Magic_t*	mp = (Magic_t*)handle;
-	register long		n = 0;
-	register char*		p;
+	char*		s = (char*)cs;
+	Magic_t*	mp = (Magic_t*)handle;
+	long		n = 0;
+	char*		p;
 
 	if (!s) liberror(lib, 2, "%s in indirect expression", *e);
 	else
@@ -461,11 +461,11 @@ indirect __PARAM__((const char* cs, char** e, __V_* handle), (cs, e, handle)) __
  */
 
 static char*
-ckmagic __PARAM__((register Magic_t* mp, const char* file, char* buf, struct stat* st, unsigned long off), (mp, file, buf, st, off)) __OTORP__(register Magic_t* mp; const char* file; char* buf; struct stat* st; unsigned long off;){
-	register Entry_t*	ep;
-	register char*		p;
-	register char*		b;
-	register int		level = 0;
+ckmagic __PARAM__((Magic_t* mp, const char* file, char* buf, struct stat* st, unsigned long off), (mp, file, buf, st, off)) __OTORP__(Magic_t* mp; const char* file; char* buf; struct stat* st; unsigned long off;){
+	Entry_t*	ep;
+	char*		p;
+	char*		b;
+	int		level = 0;
 	int			call = -1;
 	int			c;
 	char*			t;
@@ -769,11 +769,11 @@ ckmagic __PARAM__((register Magic_t* mp, const char* file, char* buf, struct sta
  */
 
 static int
-ckenglish __PARAM__((register Magic_t* mp, int pun, int badpun), (mp, pun, badpun)) __OTORP__(register Magic_t* mp; int pun; int badpun;){
-	register char*	s;
-	register int	vowl = 0;
-	register int	freq = 0;
-	register int	rare = 0;
+ckenglish __PARAM__((Magic_t* mp, int pun, int badpun), (mp, pun, badpun)) __OTORP__(Magic_t* mp; int pun; int badpun;){
+	char*	s;
+	int	vowl = 0;
+	int	freq = 0;
+	int	rare = 0;
 
 	if (5 * badpun > pun)
 		return(0);
@@ -799,12 +799,12 @@ ckenglish __PARAM__((register Magic_t* mp, int pun, int badpun), (mp, pun, badpu
 #define F_eascii	(1<<2)
 
 static char*
-cklang __PARAM__((register Magic_t* mp, const char* file, char* buf, struct stat* st), (mp, file, buf, st)) __OTORP__(register Magic_t* mp; const char* file; char* buf; struct stat* st;){
-	register int		c;
-	register unsigned char*	b;
-	register unsigned char*	e;
-	register int		q;
-	register char*		s;
+cklang __PARAM__((Magic_t* mp, const char* file, char* buf, struct stat* st), (mp, file, buf, st)) __OTORP__(Magic_t* mp; const char* file; char* buf; struct stat* st;){
+	int		c;
+	unsigned char*	b;
+	unsigned char*	e;
+	int		q;
+	char*		s;
 	char*			t;
 	char*			base;
 	char*			suff;
@@ -1099,7 +1099,7 @@ cklang __PARAM__((register Magic_t* mp, const char* file, char* buf, struct stat
  */
 
 static char*
-type __PARAM__((register Magic_t* mp, const char* file, struct stat* st, char* buf, int size), (mp, file, st, buf, size)) __OTORP__(register Magic_t* mp; const char* file; struct stat* st; char* buf; int size;){
+type __PARAM__((Magic_t* mp, const char* file, struct stat* st, char* buf, int size), (mp, file, st, buf, size)) __OTORP__(Magic_t* mp; const char* file; struct stat* st; char* buf; int size;){
 	char*	s;
 
 	if (!S_ISREG(st->st_mode))
@@ -1160,10 +1160,10 @@ type __PARAM__((register Magic_t* mp, const char* file, struct stat* st, char* b
  */
 
 int
-magicload __PARAM__((register Magic_t* mp, const char* file, unsigned long flags), (mp, file, flags)) __OTORP__(register Magic_t* mp; const char* file; unsigned long flags;){
-	register Entry_t*	ep;
-	register Sfio_t*	fp;
-	register char*		p;
+magicload __PARAM__((Magic_t* mp, const char* file, unsigned long flags), (mp, file, flags)) __OTORP__(Magic_t* mp; const char* file; unsigned long flags;){
+	Entry_t*	ep;
+	Sfio_t*	fp;
+	char*		p;
 	int			n;
 	int			lge;
 	int			lev;
@@ -1195,7 +1195,7 @@ magicload __PARAM__((register Magic_t* mp, const char* file, unsigned long flags
 	first = ep = vmnewof(mp->region, 0, Entry_t, 1, 0);
 	while (p = sfgetr(fp, '\n', 1))
 	{
-		register char*	p2;
+		char*	p2;
 		char*		next;
 
 		error_info.line++;
@@ -1685,9 +1685,9 @@ magicload __PARAM__((register Magic_t* mp, const char* file, unsigned long flags
 
 Magic_t*
 magicopen __PARAM__((unsigned long flags), (flags)) __OTORP__(unsigned long flags;){
-	register Magic_t*	mp;
-	register int		n;
-	register Vmalloc_t*	vp;
+	Magic_t*	mp;
+	int		n;
+	Vmalloc_t*	vp;
 
 	if (!(vp = vmopen(Vmdcheap, Vmbest, 0)))
 		return(0);
@@ -1715,7 +1715,7 @@ magicopen __PARAM__((unsigned long flags), (flags)) __OTORP__(unsigned long flag
  */
 
 void
-magicclose __PARAM__((register Magic_t* mp), (mp)) __OTORP__(register Magic_t* mp;){
+magicclose __PARAM__((Magic_t* mp), (mp)) __OTORP__(Magic_t* mp;){
 #if USE_VMALLOC
 	if (mp) vmclose(mp->region);
 #else
@@ -1735,7 +1735,7 @@ magicclose __PARAM__((register Magic_t* mp), (mp)) __OTORP__(register Magic_t* m
  */
 
 char*
-magictype __PARAM__((register Magic_t* mp, const char* file, struct stat* st), (mp, file, st)) __OTORP__(register Magic_t* mp; const char* file; struct stat* st;){
+magictype __PARAM__((Magic_t* mp, const char* file, struct stat* st), (mp, file, st)) __OTORP__(Magic_t* mp; const char* file; struct stat* st;){
 	char*		s;
 	struct stat	statb;
 
@@ -1761,9 +1761,9 @@ magictype __PARAM__((register Magic_t* mp, const char* file, struct stat* st), (
  */
 
 int
-magiclist __PARAM__((register Magic_t* mp, register Sfio_t* sp), (mp, sp)) __OTORP__(register Magic_t* mp; register Sfio_t* sp;){
-	register Entry_t*	ep = mp->magic;
-	register Entry_t*	rp = 0;
+magiclist __PARAM__((Magic_t* mp, Sfio_t* sp), (mp, sp)) __OTORP__(Magic_t* mp; Sfio_t* sp;){
+	Entry_t*	ep = mp->magic;
+	Entry_t*	rp = 0;
 
 	sfprintf(sp, "cont\toffset\ttype\top\tmask\tvalue\tdesc\n");
 	while (ep)

cde/programs/dtksh/ksh93/src/lib/libast/misc/malloc.c

@@ -375,10 +375,10 @@ int	Mt_certify;		/* automatically certify the arena */
 int	Mt_trace = -1;		/* print trace of mallocs and frees */
 
 /* Convert an int to a string */
-static itoa __PARAM__((register size_t i, register char* buf), (i, buf)) __OTORP__(register size_t i; register char* buf;)
+static itoa __PARAM__((size_t i, char* buf), (i, buf)) __OTORP__(size_t i; char* buf;)
 #line 281
 {
-	register int	k, c;
+	int	k, c;
 
 	k = 0;
 	do
@@ -396,10 +396,10 @@ static itoa __PARAM__((register size_t i, register char* buf), (i, buf)) __OTORP
 }
 
 /* Convert an int to a hex string */
-static xtoa __PARAM__((register size_t i, register char* buf), (i, buf)) __OTORP__(register size_t i; register char* buf;)
+static xtoa __PARAM__((size_t i, char* buf), (i, buf)) __OTORP__(size_t i; char* buf;)
 #line 301
 {
-	register int	k;
+	int	k;
 
 	static char dig[] = "0123456789ABCDEF";
 
@@ -412,7 +412,7 @@ static xtoa __PARAM__((register size_t i, register char* buf), (i, buf)) __OTORP
 }
 
 /* internal function for warning on corruption */
-static int mt_corrupt __PARAM__((register VOID* addr, register size_t usize, register VOID* stamp), (addr, usize, stamp)) __OTORP__(register VOID* addr; register size_t usize; register VOID* stamp;)
+static int mt_corrupt __PARAM__((VOID* addr, size_t usize, VOID* stamp), (addr, usize, stamp)) __OTORP__(VOID* addr; size_t usize; VOID* stamp;)
 #line 316
 {
 	char	buf[64], *mesg;
@@ -436,7 +436,7 @@ static int mt_corrupt __PARAM__((register VOID* addr, register size_t usize, reg
 }
 
 /* Print trace information */
-static mt_trace __PARAM__((register VOID* addr, register int type), (addr, type)) __OTORP__(register VOID* addr; register int type;)
+static mt_trace __PARAM__((VOID* addr, int type), (addr, type)) __OTORP__(VOID* addr; int type;)
 #line 339
 {
 	char	*mesg, buf[64];
@@ -458,7 +458,7 @@ static mt_trace __PARAM__((register VOID* addr, register int type), (addr, type)
 }
 
 /* Print a warning */
-static mt_didfree __PARAM__((register VOID* addr, register int type), (addr, type)) __OTORP__(register VOID* addr; register int type;)
+static mt_didfree __PARAM__((VOID* addr, int type), (addr, type)) __OTORP__(VOID* addr; int type;)
 #line 360
 {
 	char	*mesg, buf[64];
@@ -472,10 +472,10 @@ static mt_didfree __PARAM__((register VOID* addr, register int type), (addr, typ
 }
 
 /* Set trace info for a block */
-static mt_setinfo __PARAM__((register TREE* bp, register size_t usize, int type), (bp, usize, type)) __OTORP__(register TREE* bp; register size_t usize; int type;)
+static mt_setinfo __PARAM__((TREE* bp, size_t usize, int type), (bp, usize, type)) __OTORP__(TREE* bp; size_t usize; int type;)
 #line 373
 {
-	register uchar	*magic, *emagic;
+	uchar	*magic, *emagic;
 
 	USIZE(bp) = usize;
 	USTAMP(bp) = NIL(VOID*);
@@ -487,7 +487,7 @@ static mt_setinfo __PARAM__((register TREE* bp, register size_t usize, int type)
 }
 
 /* Set a stamp */
-mt_stamp __PARAM__((register VOID* addr, register VOID* stamp), (addr, stamp)) __OTORP__(register VOID* addr; register VOID* stamp;)
+mt_stamp __PARAM__((VOID* addr, VOID* stamp), (addr, stamp)) __OTORP__(VOID* addr; VOID* stamp;)
 #line 387
 {
 	USTAMP(BLOCK(addr)) = stamp;
@@ -497,8 +497,8 @@ mt_stamp __PARAM__((register VOID* addr, register VOID* stamp), (addr, stamp)) _
 mt_certify __PARAM__((void), ())
 #line 393
 {
-	register TREE	*bp, *endb;
-	register uchar	*magic, *endm;
+	TREE	*bp, *endb;
+	uchar	*magic, *endm;
 
 	if(!Mt_corrupt)
 		Mt_corrupt = mt_corrupt;
@@ -522,8 +522,8 @@ mt_certify __PARAM__((void), ())
 mt_stat __PARAM__((int fd), (fd)) __OTORP__(int fd;)
 #line 417
 {
-	register TREE	*bp, *endb;
-	register size_t	nbusy, sfree, sbusy, mbusy;
+	TREE	*bp, *endb;
+	size_t	nbusy, sfree, sbusy, mbusy;
 	char		buf[64], *mesg;
 
 	nbusy = sfree = sbusy = mbusy = 0;
@@ -566,11 +566,11 @@ mt_stat __PARAM__((int fd), (fd)) __OTORP__(int fd;)
 /*
 **	Get more core. Gaps in memory are noted as busy blocks.
 */
-static TREE *morecore __PARAM__((register size_t size), (size)) __OTORP__(register size_t size;)
+static TREE *morecore __PARAM__((size_t size), (size)) __OTORP__(size_t size;)
 #line 463
 {
-	register TREE	*tp, *bp;
-	register VOID	*addr;
+	TREE	*tp, *bp;
+	VOID	*addr;
 
 	/* space for queue of delayed free blocks */
 	if(!Qfree)
@@ -607,7 +607,7 @@ static TREE *morecore __PARAM__((register size_t size), (size)) __OTORP__(regist
 #ifndef SEGMENT
 		if((((size_t)addr)%ALIGN) != 0)
 		{	/* make sure alignment is correct */
-			register size_t n = ALIGN - ((size_t)addr)%ALIGN;
+			size_t n = ALIGN - ((size_t)addr)%ALIGN;
 			if((VOID*)GETCORE(n) == ERRCORE)
 			{
 				Bottom = bp;
@@ -663,11 +663,11 @@ static TREE *morecore __PARAM__((register size_t size), (size)) __OTORP__(regist
 **	the tree and return its address.
 **	This uses the top-down splay strategy.
 */
-static TREE *t_search __PARAM__((register int size), (size)) __OTORP__(register int size;)
+static TREE *t_search __PARAM__((int size), (size)) __OTORP__(int size;)
 #line 559
 {
-	register int		cmp;
-	register TREE	*t, *del, *left, *right, *lroot, *rroot;
+	int		cmp;
+	TREE	*t, *del, *left, *right, *lroot, *rroot;
 
 	/* find the right one to delete */
 	del = Root;
@@ -786,14 +786,14 @@ static TREE *t_search __PARAM__((register int size), (size)) __OTORP__(register
 /*
 **	malloc().
 */
-__V_* malloc __PARAM__((register size_t size), (size)) __OTORP__(register size_t size;)
+__V_* malloc __PARAM__((size_t size), (size)) __OTORP__(size_t size;)
 #line 681
 {
-	register TREE	*tp, *np, *fp;
-	register int		n, i;
+	TREE	*tp, *np, *fp;
+	int		n, i;
 #ifdef MTRACE
 	/* save true size and make size large enough to hold our data */
-	register size_t	mtsize = size;
+	size_t	mtsize = size;
 	size = size <= (MINSIZE-MTSPACE) ? MINSIZE : size + MTSPACE;
 	if(Mt_certify)
 		mt_certify();
@@ -896,14 +896,14 @@ __V_* malloc __PARAM__((register size_t size), (size)) __OTORP__(register size_t
 /*
 **	realloc().
 */
-__V_* realloc __PARAM__((__V_* old, register size_t size), (old, size)) __OTORP__(__V_* old; register size_t size;)
+__V_* realloc __PARAM__((__V_* old, size_t size), (old, size)) __OTORP__(__V_* old; size_t size;)
 #line 790
 {
-	register TREE	*tp, *np;
-	register int	n, ts;
-	register VOID	*newp;
+	TREE	*tp, *np;
+	int	n, ts;
+	VOID	*newp;
 #ifdef MTRACE
-	register size_t	mtsize = size;
+	size_t	mtsize = size;
 	if(old)
 	{
 		size = size < (MINSIZE-MTSPACE) ? MINSIZE : size + MTSPACE;
@@ -989,10 +989,10 @@ __V_* realloc __PARAM__((__V_* old, register size_t size), (old, size)) __OTORP_
 void free __PARAM__((__V_* aold), (aold)) __OTORP__(__V_* aold;)
 #line 879
 {
-	register VOID*	old = (VOID*)aold;
-	register int	size;
-	register TREE	*tp, *np, *sp;
-	register VOID	*dequeue;
+	VOID*	old = (VOID*)aold;
+	int	size;
+	TREE	*tp, *np, *sp;
+	VOID	*dequeue;
 #ifdef MTRACE
 	if(Lfree != old)
 	{

cde/programs/dtksh/ksh93/src/lib/libast/misc/optget.c

@@ -165,9 +165,9 @@ optget __PARAM__((char** argv, const char* oopts), (argv, oopts)) __OTORP__(char
  */
 
 static int
-error __PARAM__((register char* p), (p)) __OTORP__(register char* p;){
-	register char*	s;
-	register char*	t;
+error __PARAM__((char* p), (p)) __OTORP__(char* p;){
+	char*	s;
+	char*	t;
 	int		n;
 
 	if (!opt_info.msg && !(opt_info.msg = newof(0, char, OPT_MSG, 0))) opt_info.arg = "[* out of space *]";
@@ -215,7 +215,7 @@ error __PARAM__((register char* p), (p)) __OTORP__(register char* p;){
 
 static void
 optadd __PARAM__((const char* opts), (opts)) __OTORP__(const char* opts;){
-	register int	n;
+	int	n;
 
 	if ((!opt_info.nopt || opt_info.opts[opt_info.nopt - 1] != (char*)opts) && opt_info.nopt < elementsof(opt_info.opts) - 1)
 	{
@@ -260,9 +260,9 @@ optadd __PARAM__((const char* opts), (opts)) __OTORP__(const char* opts;){
  */
 
 int
-optget __PARAM__((register char** argv, const char* oopts), (argv, oopts)) __OTORP__(register char** argv; const char* oopts;){
-	register int	c;
-	register char*	s;
+optget __PARAM__((char** argv, const char* oopts), (argv, oopts)) __OTORP__(char** argv; const char* oopts;){
+	int	c;
+	char*	s;
 	char*		e;
 	char*		opts;
 	int		n;
@@ -435,9 +435,9 @@ optget __PARAM__((register char** argv, const char* oopts), (argv, oopts)) __OTO
 char*
 optusage __PARAM__((const char* oopts), (oopts)) __OTORP__(const char* oopts;){
 	char*			opts = (char*)oopts;
-	register Sfio_t*	sp;
-	register int		c;
-	register char*		p;
+	Sfio_t*	sp;
+	int		c;
+	char*		p;
 	char*			t;
 	char*			x;
 	char**			o;

cde/programs/dtksh/ksh93/src/lib/libast/misc/optjoin.c

@@ -99,8 +99,8 @@ int
 optjoin __PARAM__((char** argv, ...), (va_alist)) __OTORP__(va_dcl)
 { __OTORP__(char** argv; )
 	va_list			ap;
-	register OPTFUN		fun;
-	register OPTFUN		rep;
+	OPTFUN		fun;
+	OPTFUN		rep;
 	OPTFUN			err;
 	int			more;
 	int			user;

cde/programs/dtksh/ksh93/src/lib/libast/misc/pathaccess.c

@@ -102,7 +102,7 @@
 #include <ls.h>
 
 char*
-pathaccess __PARAM__((register char* path, register const char* dirs, const char* a, const char* b, register int mode), (path, dirs, a, b, mode)) __OTORP__(register char* path; register const char* dirs; const char* a; const char* b; register int mode;)
+pathaccess __PARAM__((char* path, const char* dirs, const char* a, const char* b, int mode), (path, dirs, a, b, mode)) __OTORP__(char* path; const char* dirs; const char* a; const char* b; int mode;)
 #line 18
 {
 	int		sep = ':';

cde/programs/dtksh/ksh93/src/lib/libast/misc/pathcanon.c

@@ -111,11 +111,11 @@ char*
 pathcanon __PARAM__((char* path, int flags), (path, flags)) __OTORP__(char* path; int flags;)
 #line 33
 {
-	register char*	p;
-	register char*	r;
-	register char*	s;
-	register char*	t;
-	register int	dots;
+	char*	p;
+	char*	r;
+	char*	s;
+	char*	t;
+	int	dots;
 	int		loop;
 	int		oerrno;
 #if defined(FS_3D)

cde/programs/dtksh/ksh93/src/lib/libast/misc/pathcat.c

@@ -101,10 +101,10 @@
 #include <ast.h>
 
 char*
-pathcat __PARAM__((char* path, register const char* dirs, int sep, const char* a, register const char* b), (path, dirs, sep, a, b)) __OTORP__(char* path; register const char* dirs; int sep; const char* a; register const char* b;)
+pathcat __PARAM__((char* path, const char* dirs, int sep, const char* a, const char* b), (path, dirs, sep, a, b)) __OTORP__(char* path; const char* dirs; int sep; const char* a; const char* b;)
 #line 13
 {
-	register char*	s;
+	char*	s;
 
 	s = path;
 	while (*dirs && *dirs != sep) *s++ = *dirs++;

cde/programs/dtksh/ksh93/src/lib/libast/misc/pathkey.c

@@ -110,9 +110,9 @@ char*
 pathkey __PARAM__((char* key, char* attr, const char* lang, const char* apath), (key, attr, lang, apath)) __OTORP__(char* key; char* attr; const char* lang; const char* apath;)
 #line 24
 {
-	register char*		path = (char*)apath;
-	register char*		s;
-	register char*		k;
+	char*		path = (char*)apath;
+	char*		s;
+	char*		k;
 	char*			t;
 	char*			flags;
 	char**			p;

cde/programs/dtksh/ksh93/src/lib/libast/misc/pathpath.c

@@ -104,10 +104,10 @@
 extern __MANGLE__ char**	environ;
 
 char*
-pathpath __PARAM__((register char* path, const char* p, const char* a, int mode), (path, p, a, mode)) __OTORP__(register char* path; const char* p; const char* a; int mode;)
+pathpath __PARAM__((char* path, const char* p, const char* a, int mode), (path, p, a, mode)) __OTORP__(char* path; const char* p; const char* a; int mode;)
 #line 20
 {
-	register char*	s;
+	char*	s;
 	char*		x;
 
 	static char*	cmd;

cde/programs/dtksh/ksh93/src/lib/libast/misc/pathprobe.c

@@ -112,9 +112,9 @@ pathprobe __PARAM__((char* path, char* attr, const char* lang, const char* tool,
 #line 32
 {
 	char*		proc = (char*)aproc;
-	register char*	p;
-	register char*	k;
-	register char**	ap;
+	char*	p;
+	char*	k;
+	char**	ap;
 	int		n;
 	char*		e;
 	char*		probe;

cde/programs/dtksh/ksh93/src/lib/libast/misc/pathrepl.c

@@ -101,11 +101,11 @@
 #include <ast.h>
 
 char*
-pathrepl __PARAM__((register char* path, const char* match, register const char* replace), (path, match, replace)) __OTORP__(register char* path; const char* match; register const char* replace;)
+pathrepl __PARAM__((char* path, const char* match, const char* replace), (path, match, replace)) __OTORP__(char* path; const char* match; const char* replace;)
 #line 14
 {
-	register const char*	m = match;
-	register const char*	r;
+	const char*	m = match;
+	const char*	r;
 	char*			t;
 
 	if (!match) match = "";
@@ -122,7 +122,7 @@ pathrepl __PARAM__((register char* path, const char* match, register const char*
 			while (*m && *m++ == *path) path++;
 			if (!*m && *path == '/')
 			{
-				register char*	p;
+				char*	p;
 
 				p = t;
 				r = replace;
@@ -130,7 +130,7 @@ pathrepl __PARAM__((register char* path, const char* match, register const char*
 				if (p < path) while (*p++ = *path++);
 				else if (*r && p >= path)
 				{
-					register char*	u;
+					char*	u;
 
 					t = path + strlen(path);
 					u = t + strlen(r);

cde/programs/dtksh/ksh93/src/lib/libast/misc/pathtemp.c

@@ -115,10 +115,10 @@ char*
 pathtemp __PARAM__((char* buf, const char* adir, const char* apfx), (buf, adir, apfx)) __OTORP__(char* buf; const char* adir; const char* apfx;)
 #line 39
 {
-	register char*	dir = (char*)adir;
+	char*	dir = (char*)adir;
 	char*		pfx = (char*)apfx;
-	register char*	p;
-	register char*	s;
+	char*	p;
+	char*	s;
 	int		pid;
 
 	static char*	tmpdir;

cde/programs/dtksh/ksh93/src/lib/libast/misc/procclose.c

@@ -95,7 +95,7 @@
 #include <wait.h>
 
 int
-procclose __PARAM__((register Proc_t* p), (p)) __OTORP__(register Proc_t* p;){
+procclose __PARAM__((Proc_t* p), (p)) __OTORP__(Proc_t* p;){
 	int	status = -1;
 
 	if (p)

cde/programs/dtksh/ksh93/src/lib/libast/misc/procfree.c

@@ -93,7 +93,7 @@
 #include "proclib.h"
 
 int
-procfree __PARAM__((register Proc_t* p), (p)) __OTORP__(register Proc_t* p;){
+procfree __PARAM__((Proc_t* p), (p)) __OTORP__(Proc_t* p;){
 	if (!p) return(-1);
 	if (p == &proc_default) p->pid = -1;
 	else free(p);

cde/programs/dtksh/ksh93/src/lib/libast/misc/procopen.c

@@ -151,7 +151,7 @@ static const Namval_t		options[] =
  */
 
 static int
-setopt __PARAM__((register __V_* a, register const __V_* p, register int n, const char* v), (a, p, n, v)) __OTORP__(register __V_* a; register const __V_* p; register int n; const char* v;){
+setopt __PARAM__((__V_* a, const __V_* p, int n, const char* v), (a, p, n, v)) __OTORP__(__V_* a; const __V_* p; int n; const char* v;){
 	NoP(v);
 	if (p)
 	{
@@ -253,7 +253,7 @@ modify __PARAM__((Proc_t* proc, int forked, int op, long arg1, long arg2), (proc
 #endif
 #if USE_SPAWN
 	{
-		register Modify_t*	m;
+		Modify_t*	m;
 
 		if (!(m = newof(NiL, Modify_t, 1, 0))) return(-1);
 		m->next = mods;
@@ -327,8 +327,8 @@ modify __PARAM__((Proc_t* proc, int forked, int op, long arg1, long arg2), (proc
 
 static void
 restore __PARAM__((Proc_t* proc), (proc)) __OTORP__(Proc_t* proc;){
-	register Modify_t*	m;
-	register Modify_t*	p;
+	Modify_t*	m;
+	Modify_t*	p;
 	int			oerrno;
 
 	NoP(proc);
@@ -399,9 +399,9 @@ restore __PARAM__((Proc_t* proc), (proc)) __OTORP__(Proc_t* proc;){
 
 Proc_t*
 procopen __PARAM__((const char* cmd, char** argv, char** envv, long* modv, long flags), (cmd, argv, envv, modv, flags)) __OTORP__(const char* cmd; char** argv; char** envv; long* modv; long flags;){
-	register Proc_t*	proc = 0;
-	register int		procfd;
-	register char**		p;
+	Proc_t*	proc = 0;
+	int		procfd;
+	char**		p;
 	char**			v;
 	int			i;
 	int			forked = 0;

cde/programs/dtksh/ksh93/src/lib/libast/misc/putenv.c

@@ -115,10 +115,10 @@ putenv __PARAM__((const char* akey), (akey)) __OTORP__(const char* akey;)
 	static char**	last;		/* last free slot (0)		*/
 
 	char*		key = (char*)akey;
-	register char**	v = environ;
-	register char**	p = envv;
-	register char*	s;
-	register char*	t;
+	char**	v = environ;
+	char**	p = envv;
+	char*	s;
+	char*	t;
 	int		n;
 
 	if (p && !v)

cde/programs/dtksh/ksh93/src/lib/libast/misc/putsymlink.c

@@ -109,10 +109,10 @@ int
 putsymlink __PARAM__((const char* buf, const char* name), (buf, name)) __OTORP__(const char* buf; const char* name;)
 #line 16
 {
-	register char*	t = (char*)buf;
+	char*	t = (char*)buf;
 #ifdef UNIV_MAX
-	register char*	s = (char*)buf;
-	register char*	v;
+	char*	s = (char*)buf;
+	char*	v;
 	int		n;
 	char		tmp[PATH_MAX];
 

cde/programs/dtksh/ksh93/src/lib/libast/misc/query.c

@@ -111,8 +111,8 @@ query __PARAM__((int quit, const char* format, ...), (va_alist)) __OTORP__(va_dc
 #line 26
 
 	va_list		ap;
-	register int	n;
-	register int	c;
+	int	n;
+	int	c;
 
 	static Sfio_t*	rfp;
 	static Sfio_t*	wfp;

cde/programs/dtksh/ksh93/src/lib/libast/misc/setcwd.c

@@ -138,11 +138,11 @@ vchdir __PARAM__((const char* path), (path)) __OTORP__(const char* path;)
  */
 
 int
-setcwd __PARAM__((register char* path, char* home), (path, home)) __OTORP__(register char* path; char* home;)
+setcwd __PARAM__((char* path, char* home), (path, home)) __OTORP__(char* path; char* home;)
 #line 48
 {
-	register char*	s;
-	register int	n;
+	char*	s;
+	int	n;
 	int		r;
 
 	r = 0;

cde/programs/dtksh/ksh93/src/lib/libast/misc/setenv.c

@@ -114,10 +114,10 @@ setenv __PARAM__((const char* akey), (akey)) __OTORP__(const char* akey;)
 	static char**	last;		/* last free slot (0)		*/
 
 	char*		key = (char*)akey;
-	register char**	v = environ;
-	register char**	p = envv;
-	register char*	s;
-	register char*	t;
+	char**	v = environ;
+	char**	p = envv;
+	char*	s;
+	char*	t;
 	int		n;
 
 	if (p && !v)

cde/programs/dtksh/ksh93/src/lib/libast/misc/setenviron.c

@@ -103,10 +103,10 @@ setenviron __PARAM__((const char* akey), (akey)) __OTORP__(const char* akey;){
 	static char	ok[] = "";	/* delete/optimization ok return*/
 
 	char*		key = (char*)akey;
-	register char**	v = environ;
-	register char**	p = envv;
-	register char*	s;
-	register char*	t;
+	char**	v = environ;
+	char**	p = envv;
+	char*	s;
+	char*	t;
 	int		n;
 
 	if (p && !v)

cde/programs/dtksh/ksh93/src/lib/libast/misc/setuniv.c

@@ -117,7 +117,7 @@ setuniv __PARAM__((const char* buf), (buf)) __OTORP__(const char* buf;)
 	return(-1);
 #else
 #if defined(ATT_UNIV) || defined(U_GET)
-	register int	n;
+	int	n;
 
 	for (n = 0; n < UNIV_MAX; n++)
 		if (streq(buf, univ_name[n]))

cde/programs/dtksh/ksh93/src/lib/libast/misc/sigcrit.c

@@ -136,7 +136,7 @@ interrupt __PARAM__((int sig), (sig)) __OTORP__(int sig;){
 
 int
 sigcritical __PARAM__((int op), (op)) __OTORP__(int op;){
-	register int		i;
+	int		i;
 	static int		level;
 #if _lib_sigprocmask
 	static sigset_t		mask;

cde/programs/dtksh/ksh93/src/lib/libast/misc/stack.c

@@ -100,9 +100,9 @@ static const char id_stack[] = "\n@(#)stack (AT&T Bell Laboratories) 05/01/84\0\
  */
 
 STACK
-stackalloc __PARAM__((register int size, __V_* error), (size, error)) __OTORP__(register int size; __V_* error;){
-	register STACK			stack;
-	register struct stackblock	*b;
+stackalloc __PARAM__((int size, __V_* error), (size, error)) __OTORP__(int size; __V_* error;){
+	STACK			stack;
+	struct stackblock	*b;
 
 	if (size <= 0) size = 100;
 	if (!(stack = newof(0, struct stacktable, 1, 0))) return(0);
@@ -132,9 +132,9 @@ stackalloc __PARAM__((register int size, __V_* error), (size, error)) __OTORP__(
  */
 
 void
-stackfree __PARAM__((register STACK stack), (stack)) __OTORP__(register STACK stack;){
-	register struct stackblock*	b;
-	register struct stackblock*	p;
+stackfree __PARAM__((STACK stack), (stack)) __OTORP__(STACK stack;){
+	struct stackblock*	b;
+	struct stackblock*	p;
 
 	b = stack->blocks;
 	while (p = b)
@@ -151,7 +151,7 @@ stackfree __PARAM__((register STACK stack), (stack)) __OTORP__(register STACK st
  */
 
 void
-stackclear __PARAM__((register STACK stack), (stack)) __OTORP__(register STACK stack;){
+stackclear __PARAM__((STACK stack), (stack)) __OTORP__(STACK stack;){
 	stack->position.block = stack->blocks;
 	stack->position.index = -1;
 }
@@ -161,7 +161,7 @@ stackclear __PARAM__((register STACK stack), (stack)) __OTORP__(register STACK s
  */
 
 __V_*
-stackget __PARAM__((register STACK stack), (stack)) __OTORP__(register STACK stack;){
+stackget __PARAM__((STACK stack), (stack)) __OTORP__(STACK stack;){
 	if (stack->position.index < 0) return(stack->error);
 	else return(stack->position.block->stack[stack->position.index]);
 }
@@ -171,8 +171,8 @@ stackget __PARAM__((register STACK stack), (stack)) __OTORP__(register STACK sta
  */
 
 int
-stackpush __PARAM__((register STACK stack, __V_* value), (stack, value)) __OTORP__(register STACK stack; __V_* value;){
-	register struct stackblock	*b;
+stackpush __PARAM__((STACK stack, __V_* value), (stack, value)) __OTORP__(STACK stack; __V_* value;){
+	struct stackblock	*b;
 
 	if (++stack->position.index >= stack->size)
 	{
@@ -200,7 +200,7 @@ stackpush __PARAM__((register STACK stack, __V_* value), (stack, value)) __OTORP
  */
 
 int
-stackpop __PARAM__((register STACK stack), (stack)) __OTORP__(register STACK stack;){
+stackpop __PARAM__((STACK stack), (stack)) __OTORP__(STACK stack;){
 	/*
 	 * return:
 	 *
@@ -225,7 +225,7 @@ stackpop __PARAM__((register STACK stack), (stack)) __OTORP__(register STACK sta
  */
 
 void
-stacktell __PARAM__((register STACK stack, int set, STACKPOS* position), (stack, set, position)) __OTORP__(register STACK stack; int set; STACKPOS* position;){
+stacktell __PARAM__((STACK stack, int set, STACKPOS* position), (stack, set, position)) __OTORP__(STACK stack; int set; STACKPOS* position;){
 	if (set) stack->position = *position;
 	else *position = stack->position;
 }

cde/programs/dtksh/ksh93/src/lib/libast/misc/stak.c

@@ -189,7 +189,7 @@ static char *overflow __PARAM__((int n), (n)) __OTORP__(int n;)
 static void stakinit __PARAM__((int size), (size)) __OTORP__(int size;)
 #line 109
 {
-	register Sfile_t *sp;
+	Sfile_t *sp;
 	init = size;
 	sp = stakcreate(0);
 	init = 1;
@@ -230,12 +230,12 @@ static int stakexcept __PARAM__((Sfile_t* sp, int type, Sfdisc_t* dp), (sp, type
 Sfile_t *stakcreate __PARAM__((int flags), (flags)) __OTORP__(int flags;)
 #line 148
 {
-	register int bsize;
-	register Sfile_t *stream;
-	register struct stak *sp;
-	register struct frame *fp;
-	register Sfdisc_t *dp;
-	register char *cp;
+	int bsize;
+	Sfile_t *stream;
+	struct stak *sp;
+	struct frame *fp;
+	Sfdisc_t *dp;
+	char *cp;
 	if(!(stream=newof((char*)0,Sfile_t, 1, sizeof(*dp)+sizeof(*sp))))
 		return(0);
 	increment(create);
@@ -279,7 +279,7 @@ Sfile_t *stakinstall __PARAM__((Sfile_t *stream, _stak_overflow_ oflow), (stream
 #line 195
 {
 	Sfile_t *old;
-	register struct stak *sp;
+	struct stak *sp;
 	if(!init)
 	{
 		stakinit(1);
@@ -310,10 +310,10 @@ Sfile_t *stakinstall __PARAM__((Sfile_t *stream, _stak_overflow_ oflow), (stream
 /*
  * increase the reference count on the given <stack>
  */
-int staklink __PARAM__((register Sfile_t* stream), (stream)) __OTORP__(register Sfile_t* stream;)
+int staklink __PARAM__((Sfile_t* stream), (stream)) __OTORP__(Sfile_t* stream;)
 #line 229
 {
-	register struct stak *sp = stream2stak(stream);
+	struct stak *sp = stream2stak(stream);
 	return(sp->stakref++);
 }
 
@@ -323,9 +323,9 @@ int staklink __PARAM__((register Sfile_t* stream), (stream)) __OTORP__(register
 int stakdelete __PARAM__((Sfile_t* stream), (stream)) __OTORP__(Sfile_t* stream;)
 #line 238
 {
-	register struct stak *sp = stream2stak(stream); 
-	register char *cp = sp->stakbase;
-	register struct frame *fp;
+	struct stak *sp = stream2stak(stream);
+	char *cp = sp->stakbase;
+	struct frame *fp;
 	if(--sp->stakref>0)
 		return(1);
 	increment(delete);
@@ -354,13 +354,13 @@ int stakdelete __PARAM__((Sfile_t* stream), (stream)) __OTORP__(Sfile_t* stream;
  * otherwise, the top of the stack is set to stakbot+<offset>
  *
  */
-char *stakset __PARAM__((register char* loc, unsigned offset), (loc, offset)) __OTORP__(register char* loc; unsigned offset;)
+char *stakset __PARAM__((char* loc, unsigned offset), (loc, offset)) __OTORP__(char* loc; unsigned offset;)
 #line 271
 {
-	register struct stak *sp=stakcur;
-	register char *cp;
-	register struct frame *fp;
-	register int frames = 0;
+	struct stak *sp=stakcur;
+	char *cp;
+	struct frame *fp;
+	int frames = 0;
 	if(!init)
 		stakinit(offset+1);
 	increment(set);
@@ -400,10 +400,10 @@ found:
 /*
  * allocate <n> bytes on the current stack
  */
-char *stakalloc __PARAM__((register unsigned int n), (n)) __OTORP__(register unsigned int n;)
+char *stakalloc __PARAM__((unsigned int n), (n)) __OTORP__(unsigned int n;)
 #line 316
 {
-	register unsigned char *old;
+	unsigned char *old;
 	if(!init)
 		stakinit(n);
 	increment(alloc);
@@ -418,7 +418,7 @@ char *stakalloc __PARAM__((register unsigned int n), (n)) __OTORP__(register uns
 /*
  * begin a new stack word of at least <n> bytes
  */
-char *_stakseek __PARAM__((register unsigned n), (n)) __OTORP__(register unsigned n;)
+char *_stakseek __PARAM__((unsigned n), (n)) __OTORP__(unsigned n;)
 #line 333
 {
 	if(!init)
@@ -434,10 +434,10 @@ char *_stakseek __PARAM__((register unsigned n), (n)) __OTORP__(register unsigne
  * advance the stack to the current top
  * if extra is non-zero, first add a extra bytes and zero the first
  */
-char	*stakfreeze __PARAM__((register unsigned extra), (extra)) __OTORP__(register unsigned extra;)
+char	*stakfreeze __PARAM__((unsigned extra), (extra)) __OTORP__(unsigned extra;)
 #line 348
 {
-	register unsigned char *old, *top;
+	unsigned char *old, *top;
 	if(!init)
 		stakinit(extra);
 	old = staksp->data;
@@ -462,8 +462,8 @@ char	*stakfreeze __PARAM__((register unsigned extra), (extra)) __OTORP__(registe
 char	*stakcopy __PARAM__((const char* str), (str)) __OTORP__(const char* str;)
 #line 372
 {
-	register unsigned char *cp = (unsigned char*)str;
-	register int n;
+	unsigned char *cp = (unsigned char*)str;
+	int n;
 	while(*cp++);
 	n = roundof(cp-(unsigned char*)str,sizeof(char*));
 	if(!init)
@@ -486,12 +486,12 @@ char	*stakcopy __PARAM__((const char* str), (str)) __OTORP__(const char* str;)
 static char *stakgrow __PARAM__((unsigned size), (size)) __OTORP__(unsigned size;)
 #line 395
 {
-	register int n = size;
-	register struct stak *sp = stakcur;
-	register struct frame *fp;
-	register char *cp;
-	register unsigned m = staktell();
-	register int reused = 0;
+	int n = size;
+	struct stak *sp = stakcur;
+	struct frame *fp;
+	char *cp;
+	unsigned m = staktell();
+	int reused = 0;
 	n += (m + sizeof(struct frame)+1);
 	if(sp->stakflags&STAK_SMALL)
 #ifndef USE_REALLOC

cde/programs/dtksh/ksh93/src/lib/libast/misc/stk.c

@@ -189,14 +189,14 @@ static char *overflow __PARAM__((int n), (n)) __OTORP__(int n;){
  * initialize stkstd, sfio operations may have already occcured
  */
 static void stkinit __PARAM__((int size), (size)) __OTORP__(int size;){
-	register Sfio_t *sp;
+	Sfio_t *sp;
 	init = size;
 	sp = stkopen(0);
 	init = 1;
 	stkinstall(sp,overflow);
 }
 
-static int stkexcept __PARAM__((register Sfio_t *stream, int type, Sfdisc_t* dp), (stream, type, dp)) __OTORP__(register Sfio_t *stream; int type; Sfdisc_t* dp;){
+static int stkexcept __PARAM__((Sfio_t *stream, int type, Sfdisc_t* dp), (stream, type, dp)) __OTORP__(Sfio_t *stream; int type; Sfdisc_t* dp;){
 	NoP(dp);
 	switch(type)
 	{
@@ -226,12 +226,12 @@ static int stkexcept __PARAM__((register Sfio_t *stream, int type, Sfdisc_t* dp)
  * create a stack
  */
 Sfio_t *stkopen __PARAM__((int flags), (flags)) __OTORP__(int flags;){
-	register int bsize;
-	register Sfio_t *stream;
-	register struct stk *sp;
-	register struct frame *fp;
-	register Sfdisc_t *dp;
-	register char *cp;
+	int bsize;
+	Sfio_t *stream;
+	struct stk *sp;
+	struct frame *fp;
+	Sfdisc_t *dp;
+	char *cp;
 	if(!(stream=newof((char*)0,Sfio_t, 1, sizeof(*dp)+sizeof(*sp))))
 		return(0);
 	increment(create);
@@ -273,7 +273,7 @@ Sfio_t *stkopen __PARAM__((int flags), (flags)) __OTORP__(int flags;){
  */
 Sfio_t *stkinstall __PARAM__((Sfio_t *stream, _stk_overflow_ oflow), (stream, oflow)) __OTORP__(Sfio_t *stream; _stk_overflow_ oflow;){
 	Sfio_t *old;
-	register struct stk *sp;
+	struct stk *sp;
 	if(!init)
 	{
 		stkinit(1);
@@ -304,8 +304,8 @@ Sfio_t *stkinstall __PARAM__((Sfio_t *stream, _stk_overflow_ oflow), (stream, of
 /*
  * increase the reference count on the given <stack>
  */
-int stklink __PARAM__((register Sfio_t* stream), (stream)) __OTORP__(register Sfio_t* stream;){
-	register struct stk *sp = stream2stk(stream);
+int stklink __PARAM__((Sfio_t* stream), (stream)) __OTORP__(Sfio_t* stream;){
+	struct stk *sp = stream2stk(stream);
 	return(sp->stkref++);
 }
 
@@ -313,9 +313,9 @@ int stklink __PARAM__((register Sfio_t* stream), (stream)) __OTORP__(register Sf
  * terminate a stack and free up the space
  */
 int stkclose __PARAM__((Sfio_t* stream), (stream)) __OTORP__(Sfio_t* stream;){
-	register struct stk *sp = stream2stk(stream); 
-	register char *cp = sp->stkbase;
-	register struct frame *fp;
+	struct stk *sp = stream2stk(stream);
+	char *cp = sp->stkbase;
+	struct frame *fp;
 	if(--sp->stkref>0)
 		return(1);
 	increment(delete);
@@ -344,11 +344,11 @@ int stkclose __PARAM__((Sfio_t* stream), (stream)) __OTORP__(Sfio_t* stream;){
  * otherwise, the top of the stack is set to stkbot+<offset>
  *
  */
-char *stkset __PARAM__((register Sfio_t * stream, register char* loc, unsigned offset), (stream, loc, offset)) __OTORP__(register Sfio_t * stream; register char* loc; unsigned offset;){
-	register struct stk *sp = stream2stk(stream); 
-	register char *cp;
-	register struct frame *fp;
-	register int frames = 0;
+char *stkset __PARAM__((Sfio_t * stream, char* loc, unsigned offset), (stream, loc, offset)) __OTORP__(Sfio_t * stream; char* loc; unsigned offset;){
+	struct stk *sp = stream2stk(stream);
+	char *cp;
+	struct frame *fp;
+	int frames = 0;
 	if(!init)
 		stkinit(offset+1);
 	increment(set);
@@ -388,8 +388,8 @@ found:
 /*
  * allocate <n> bytes on the current stack
  */
-char *stkalloc __PARAM__((register Sfio_t *stream, register unsigned int n), (stream, n)) __OTORP__(register Sfio_t *stream; register unsigned int n;){
-	register unsigned char *old;
+char *stkalloc __PARAM__((Sfio_t *stream, unsigned int n), (stream, n)) __OTORP__(Sfio_t *stream; unsigned int n;){
+	unsigned char *old;
 	if(!init)
 		stkinit(n);
 	increment(alloc);
@@ -404,7 +404,7 @@ char *stkalloc __PARAM__((register Sfio_t *stream, register unsigned int n), (st
 /*
  * begin a new stack word of at least <n> bytes
  */
-char *_stkseek __PARAM__((register Sfio_t *stream, register unsigned n), (stream, n)) __OTORP__(register Sfio_t *stream; register unsigned n;){
+char *_stkseek __PARAM__((Sfio_t *stream, unsigned n), (stream, n)) __OTORP__(Sfio_t *stream; unsigned n;){
 	if(!init)
 		stkinit(n);
 	increment(seek);
@@ -418,8 +418,8 @@ char *_stkseek __PARAM__((register Sfio_t *stream, register unsigned n), (stream
  * advance the stack to the current top
  * if extra is non-zero, first add a extra bytes and zero the first
  */
-char	*stkfreeze __PARAM__((register Sfio_t *stream, register unsigned extra), (stream, extra)) __OTORP__(register Sfio_t *stream; register unsigned extra;){
-	register unsigned char *old, *top;
+char	*stkfreeze __PARAM__((Sfio_t *stream, unsigned extra), (stream, extra)) __OTORP__(Sfio_t *stream; unsigned extra;){
+	unsigned char *old, *top;
 	if(!init)
 		stkinit(extra);
 	old = stream->data;
@@ -442,8 +442,8 @@ char	*stkfreeze __PARAM__((register Sfio_t *stream, register unsigned extra), (s
  * copy string <str> onto the stack as a new stack word
  */
 char	*stkcopy __PARAM__((Sfio_t *stream, const char* str), (stream, str)) __OTORP__(Sfio_t *stream; const char* str;){
-	register unsigned char *cp = (unsigned char*)str;
-	register int n;
+	unsigned char *cp = (unsigned char*)str;
+	int n;
 	while(*cp++);
 	n = roundof(cp-(unsigned char*)str,sizeof(char*));
 	if(!init)
@@ -463,13 +463,13 @@ char	*stkcopy __PARAM__((Sfio_t *stream, const char* str), (stream, str)) __OTOR
  * to the end is copied into the new stack frame
  */
 
-static char *stkgrow __PARAM__((register Sfio_t *stream, unsigned size), (stream, size)) __OTORP__(register Sfio_t *stream; unsigned size;){
-	register int n = size;
-	register struct stk *sp = stream2stk(stream);
-	register struct frame *fp;
-	register char *cp;
-	register unsigned m = stktell(stream);
-	register int reused = 0;
+static char *stkgrow __PARAM__((Sfio_t *stream, unsigned size), (stream, size)) __OTORP__(Sfio_t *stream; unsigned size;){
+	int n = size;
+	struct stk *sp = stream2stk(stream);
+	struct frame *fp;
+	char *cp;
+	unsigned m = stktell(stream);
+	int reused = 0;
 	n += (m + sizeof(struct frame)+1);
 	if(sp->stkflags&STK_SMALL)
 #ifndef USE_REALLOC

cde/programs/dtksh/ksh93/src/lib/libast/misc/systrace.c

@@ -96,8 +96,8 @@
 
 void
 systrace __PARAM__((const char* id), (id)) __OTORP__(const char* id;){
-	register int	n;
-	register char*	out;
+	int	n;
+	char*	out;
 	char*		s;
 	char		buf[PATH_MAX];
 	char*		av[7];

cde/programs/dtksh/ksh93/src/lib/libast/obsolete/fgetline.c

@@ -117,12 +117,12 @@
  */
 
 char*
-fgetline __PARAM__((register FILE* fp, int op), (fp, op)) __OTORP__(register FILE* fp; int op;)
+fgetline __PARAM__((FILE* fp, int op), (fp, op)) __OTORP__(FILE* fp; int op;)
 #line 29
 {
-	register int	c;
-	register char*	s;
-	register char*	end;
+	int	c;
+	char*	s;
+	char*	end;
 
 	static char*	buf;
 	static int	siz;

cde/programs/dtksh/ksh93/src/lib/libast/obsolete/getwinsize.c

@@ -93,6 +93,6 @@
 #include <ast.h>
 
 void
-getwinsize __PARAM__((int fd, register int* rows, register int* cols), (fd, rows, cols)) __OTORP__(int fd; register int* rows; register int* cols;){
+getwinsize __PARAM__((int fd, int* rows, int* cols), (fd, rows, cols)) __OTORP__(int fd; int* rows; int* cols;){
 	astwinsize(fd, rows, cols);
 }

cde/programs/dtksh/ksh93/src/lib/libast/obsolete/query.c

@@ -97,8 +97,8 @@ int
 query __PARAM__((int quit, const char* format, ...), (va_alist)) __OTORP__(va_dcl)
 { __OTORP__(int quit; const char* format; )
 	va_list		ap;
-	register int	n;
-	register int	c;
+	int	n;
+	int	c;
 
 	static Sfio_t*	rfp;
 	static Sfio_t*	wfp;

cde/programs/dtksh/ksh93/src/lib/libast/obsolete/tablook.c

@@ -93,6 +93,6 @@
 #include <ast.h>
 
 __V_*
-tablook __PARAM__((const __V_* tab, int siz, register const char* name), (tab, siz, name)) __OTORP__(const __V_* tab; int siz; register const char* name;){
+tablook __PARAM__((const __V_* tab, int siz, const char* name), (tab, siz, name)) __OTORP__(const __V_* tab; int siz; const char* name;){
 	return(strlook(tab, siz, name));
 }

cde/programs/dtksh/ksh93/src/lib/libast/path/pathaccess.c

@@ -94,8 +94,8 @@
 #include <ls.h>
 
 char*
-pathaccess __PARAM__((register char* path, register const char* dirs, const char* a, const char* b, register int mode), (path, dirs, a, b, mode)) __OTORP__(register char* path; register const char* dirs; const char* a; const char* b; register int mode;){
-	register int	m = 0;
+pathaccess __PARAM__((char* path, const char* dirs, const char* a, const char* b, int mode), (path, dirs, a, b, mode)) __OTORP__(char* path; const char* dirs; const char* a; const char* b; int mode;){
+	int	m = 0;
 	int		sep = ':';
 	char		cwd[PATH_MAX];
 	struct stat	st;

cde/programs/dtksh/ksh93/src/lib/libast/path/pathbin.c

@@ -94,7 +94,7 @@
 
 char*
 pathbin __PARAM__((void), ()){
-	register char*	bin;
+	char*	bin;
 
 	static char*	val;
 

cde/programs/dtksh/ksh93/src/lib/libast/path/pathcanon.c

@@ -97,11 +97,11 @@
 
 char*
 pathcanon __PARAM__((char* path, int flags), (path, flags)) __OTORP__(char* path; int flags;){
-	register char*	p;
-	register char*	r;
-	register char*	s;
-	register char*	t;
-	register int	dots;
+	char*	p;
+	char*	r;
+	char*	s;
+	char*	t;
+	int	dots;
 	int		loop;
 	int		oerrno;
 #if defined(FS_3D)

cde/programs/dtksh/ksh93/src/lib/libast/path/pathcat.c

@@ -93,8 +93,8 @@
 #include <ast.h>
 
 char*
-pathcat __PARAM__((char* path, register const char* dirs, int sep, const char* a, register const char* b), (path, dirs, sep, a, b)) __OTORP__(char* path; register const char* dirs; int sep; const char* a; register const char* b;){
-	register char*	s;
+pathcat __PARAM__((char* path, const char* dirs, int sep, const char* a, const char* b), (path, dirs, sep, a, b)) __OTORP__(char* path; const char* dirs; int sep; const char* a; const char* b;){
+	char*	s;
 
 	s = path;
 	while (*dirs && *dirs != sep) *s++ = *dirs++;

cde/programs/dtksh/ksh93/src/lib/libast/path/pathcd.c

@@ -126,9 +126,9 @@ vchdir __PARAM__((const char* path), (path)) __OTORP__(const char* path;){
 
 int
 pathcd __PARAM__((const char* path, const char* home), (path, home)) __OTORP__(const char* path; const char* home;){
-	register char*	p = (char*)path;
-	register char*	s;
-	register int	n;
+	char*	p = (char*)path;
+	char*	s;
+	int	n;
 	int		i;
 	int		r;
 

cde/programs/dtksh/ksh93/src/lib/libast/path/pathcheck.c

@@ -99,7 +99,7 @@
 int
 pathcheck __PARAM__((const char* package, const char* tool, Pathcheck_t* pc), (package, tool, pc)) __OTORP__(const char* package; const char* tool; Pathcheck_t* pc;){
 #ifdef PARANOID
-	register char*	s;
+	char*	s;
 	struct stat	st;
 
 	if (strmatch(tool, PARANOID) && environ && (s = *environ) && *s++ == '_' && *s++ == '=' && !stat(s, &st))

cde/programs/dtksh/ksh93/src/lib/libast/path/pathgetlink.c

@@ -117,10 +117,10 @@ pathgetlink __PARAM__((const char* name, char* buf, int siz), (name, buf, siz))
 #ifdef UNIV_MAX
 	if (isspace(*buf))
 	{
-		register char*	s;
-		register char*	t;
-		register char*	u;
-		register char*	v;
+		char*	s;
+		char*	t;
+		char*	u;
+		char*	v;
 		int		match = 0;
 		char		tmp[PATH_MAX];