? register-remover-net.patch
Index: bpf.c
===================================================================
RCS file: /home/ncvs/src/sys/net/bpf.c,v
retrieving revision 1.105
diff -u -r1.105 bpf.c
--- bpf.c	21 Jan 2003 08:55:58 -0000	1.105
+++ bpf.c	11 Feb 2003 12:38:46 -0000
@@ -139,10 +139,10 @@
 
 static int
 bpf_movein(uio, linktype, mp, sockp, datlen)
-	register struct uio *uio;
+	struct uio *uio;
 	int linktype, *datlen;
-	register struct mbuf **mp;
-	register struct sockaddr *sockp;
+	struct mbuf **mp;
+	struct sockaddr *sockp;
 {
 	struct mbuf *m;
 	int error;
@@ -407,7 +407,7 @@
 static	int
 bpfread(dev, uio, ioflag)
 	dev_t dev;
-	register struct uio *uio;
+	struct uio *uio;
 	int ioflag;
 {
 	struct bpf_d *d = dev->si_drv1;
@@ -512,7 +512,7 @@
  */
 static __inline void
 bpf_wakeup(d)
-	register struct bpf_d *d;
+	struct bpf_d *d;
 {
 	if (d->bd_state == BPF_WAITING) {
 		callout_stop(&d->bd_callout);
@@ -692,7 +692,7 @@
 		if (d->bd_bif != 0)
 			error = EINVAL;
 		else {
-			register u_int size = *(u_int *)addr;
+			u_int size = *(u_int *)addr;
 
 			if (size > bpf_maxbufsize)
 				*(u_int *)addr = size = bpf_maxbufsize;
@@ -1037,7 +1037,7 @@
  */
 static int
 bpfpoll(dev, events, td)
-	register dev_t dev;
+	dev_t dev;
 	int events;
 	struct thread *td;
 {
@@ -1084,11 +1084,11 @@
 void
 bpf_tap(bp, pkt, pktlen)
 	struct bpf_if *bp;
-	register u_char *pkt;
-	register u_int pktlen;
+	u_char *pkt;
+	u_int pktlen;
 {
-	register struct bpf_d *d;
-	register u_int slen;
+	struct bpf_d *d;
+	u_int slen;
 
 	BPFIF_LOCK(bp);
 	for (d = bp->bif_dlist; d != 0; d = d->bd_next) {
@@ -1114,10 +1114,10 @@
 bpf_mcopy(src_arg, dst_arg, len)
 	const void *src_arg;
 	void *dst_arg;
-	register size_t len;
+	size_t len;
 {
-	register const struct mbuf *m;
-	register u_int count;
+	const struct mbuf *m;
+	u_int count;
 	u_char *dst;
 
 	m = src_arg;
@@ -1178,14 +1178,14 @@
  */
 static void
 catchpacket(d, pkt, pktlen, snaplen, cpfn)
-	register struct bpf_d *d;
-	register u_char *pkt;
-	register u_int pktlen, snaplen;
-	register void (*cpfn)(const void *, void *, size_t);
-{
-	register struct bpf_hdr *hp;
-	register int totlen, curlen;
-	register int hdrlen = d->bd_bif->bif_hdrlen;
+	struct bpf_d *d;
+	u_char *pkt;
+	u_int pktlen, snaplen;
+	void (*cpfn)(const void *, void *, size_t);
+{
+	struct bpf_hdr *hp;
+	int totlen, curlen;
+	int hdrlen = d->bd_bif->bif_hdrlen;
 	/*
 	 * Figure out how many bytes to move.  If the packet is
 	 * greater or equal to the snapshot length, transfer that
@@ -1245,7 +1245,7 @@
  */
 static int
 bpf_allocbufs(d)
-	register struct bpf_d *d;
+	struct bpf_d *d;
 {
 	d->bd_fbuf = (caddr_t)malloc(d->bd_bufsize, M_BPF, 0);
 	if (d->bd_fbuf == 0)
@@ -1267,7 +1267,7 @@
  */
 static void
 bpf_freed(d)
-	register struct bpf_d *d;
+	struct bpf_d *d;
 {
 	/*
 	 * We don't need to lock out interrupts since this descriptor has
@@ -1510,8 +1510,8 @@
 void
 bpf_tap(bp, pkt, pktlen)
 	struct bpf_if *bp;
-	register u_char *pkt;
-	register u_int pktlen;
+	u_char *pkt;
+	u_int pktlen;
 {
 }
 
@@ -1537,10 +1537,10 @@
 
 u_int
 bpf_filter(pc, p, wirelen, buflen)
-	register const struct bpf_insn *pc;
-	register u_char *p;
+	const struct bpf_insn *pc;
+	u_char *p;
 	u_int wirelen;
-	register u_int buflen;
+	u_int buflen;
 {
 	return -1;	/* "no filter" behaviour */
 }
Index: bpf_filter.c
===================================================================
RCS file: /home/ncvs/src/sys/net/bpf_filter.c,v
retrieving revision 1.21
diff -u -r1.21 bpf_filter.c
--- bpf_filter.c	5 Jul 2002 00:06:08 -0000	1.21
+++ bpf_filter.c	11 Feb 2003 12:38:46 -0000
@@ -72,7 +72,7 @@
 #ifdef _KERNEL
 #define MINDEX(m, k) \
 { \
-	register int len = m->m_len; \
+	int len = m->m_len; \
  \
 	while (k >= len) { \
 		k -= len; \
@@ -88,13 +88,13 @@
 
 static u_int32_t
 m_xword(m, k, err)
-	register struct mbuf *m;
-	register bpf_u_int32 k;
-	register int *err;
+	struct mbuf *m;
+	bpf_u_int32 k;
+	int *err;
 {
-	register size_t len;
-	register u_char *cp, *np;
-	register struct mbuf *m0;
+	size_t len;
+	u_char *cp, *np;
+	struct mbuf *m0;
 
 	len = m->m_len;
 	while (k >= len) {
@@ -144,13 +144,13 @@
 
 static u_int16_t
 m_xhalf(m, k, err)
-	register struct mbuf *m;
-	register bpf_u_int32 k;
-	register int *err;
+	struct mbuf *m;
+	bpf_u_int32 k;
+	int *err;
 {
-	register size_t len;
-	register u_char *cp;
-	register struct mbuf *m0;
+	size_t len;
+	u_char *cp;
+	struct mbuf *m0;
 
 	len = m->m_len;
 	while (k >= len) {
@@ -183,13 +183,13 @@
  */
 u_int
 bpf_filter(pc, p, wirelen, buflen)
-	register const struct bpf_insn *pc;
-	register u_char *p;
+	const struct bpf_insn *pc;
+	u_char *p;
 	u_int wirelen;
-	register u_int buflen;
+	u_int buflen;
 {
-	register u_int32_t A = 0, X = 0;
-	register bpf_u_int32 k;
+	u_int32_t A = 0, X = 0;
+	bpf_u_int32 k;
 	int32_t mem[BPF_MEMWORDS];
 
 	if (pc == 0)
@@ -260,7 +260,7 @@
 			k = pc->k;
 			if (k >= buflen) {
 #ifdef _KERNEL
-				register struct mbuf *m;
+				struct mbuf *m;
 
 				if (buflen != 0)
 					return 0;
@@ -332,7 +332,7 @@
 			k = X + pc->k;
 			if (pc->k >= buflen || X >= buflen - pc->k) {
 #ifdef _KERNEL
-				register struct mbuf *m;
+				struct mbuf *m;
 
 				if (buflen != 0)
 					return 0;
@@ -351,7 +351,7 @@
 			k = pc->k;
 			if (k >= buflen) {
 #ifdef _KERNEL
-				register struct mbuf *m;
+				struct mbuf *m;
 
 				if (buflen != 0)
 					return 0;
@@ -521,8 +521,8 @@
 	const struct bpf_insn *f;
 	int len;
 {
-	register int i;
-	register const struct bpf_insn *p;
+	int i;
+	const struct bpf_insn *p;
 
 	for (i = 0; i < len; ++i) {
 		/*
@@ -531,7 +531,7 @@
 		 */
 		p = &f[i];
 		if (BPF_CLASS(p->code) == BPF_JMP) {
-			register int from = i + 1;
+			int from = i + 1;
 
 			if (BPF_OP(p->code) == BPF_JA) {
 				if (from >= len || p->k >= len - from)
Index: if.c
===================================================================
RCS file: /home/ncvs/src/sys/net/if.c,v
retrieving revision 1.156
diff -u -r1.156 if.c
--- if.c	24 Jan 2003 01:32:20 -0000	1.156
+++ if.c	11 Feb 2003 12:38:47 -0000
@@ -377,8 +377,8 @@
 	unsigned socksize, ifasize;
 	int namelen, masklen;
 	char workbuf[64];
-	register struct sockaddr_dl *sdl;
-	register struct ifaddr *ifa;
+	struct sockaddr_dl *sdl;
+	struct ifaddr *ifa;
 
 	IFNET_WLOCK();
 	TAILQ_INSERT_TAIL(&ifnet, ifp, if_link);
@@ -795,7 +795,7 @@
 }
 
 /*
- * Unregister a network interface cloner.
+ * Una network interface cloner.
  */
 void
 if_clone_detach(ifc)
@@ -912,8 +912,8 @@
 ifa_ifwithnet(addr)
 	struct sockaddr *addr;
 {
-	register struct ifnet *ifp;
-	register struct ifaddr *ifa;
+	struct ifnet *ifp;
+	struct ifaddr *ifa;
 	struct ifaddr *ifa_maybe = (struct ifaddr *) 0;
 	u_int af = addr->sa_family;
 	char *addr_data = addr->sa_data, *cplim;
@@ -923,7 +923,7 @@
 	 * so do that if we can.
 	 */
 	if (af == AF_LINK) {
-	    register struct sockaddr_dl *sdl = (struct sockaddr_dl *)addr;
+	    struct sockaddr_dl *sdl = (struct sockaddr_dl *)addr;
 	    if (sdl->sdl_index && sdl->sdl_index <= if_index)
 		return (ifaddr_byindex(sdl->sdl_index));
 	}
@@ -935,7 +935,7 @@
 	IFNET_RLOCK();
 	TAILQ_FOREACH(ifp, &ifnet, if_link) {
 		TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
-			register char *cp, *cp2, *cp3;
+			char *cp, *cp2, *cp3;
 
 			if (ifa->ifa_addr->sa_family != af)
 next:				continue;
@@ -1006,11 +1006,11 @@
 struct ifaddr *
 ifaof_ifpforaddr(addr, ifp)
 	struct sockaddr *addr;
-	register struct ifnet *ifp;
+	struct ifnet *ifp;
 {
-	register struct ifaddr *ifa;
-	register char *cp, *cp2, *cp3;
-	register char *cplim;
+	struct ifaddr *ifa;
+	char *cp, *cp2, *cp3;
+	char *cplim;
 	struct ifaddr *ifa_maybe = 0;
 	u_int af = addr->sa_family;
 
@@ -1057,10 +1057,10 @@
 static void
 link_rtrequest(cmd, rt, info)
 	int cmd;
-	register struct rtentry *rt;
+	struct rtentry *rt;
 	struct rt_addrinfo *info;
 {
-	register struct ifaddr *ifa;
+	struct ifaddr *ifa;
 	struct sockaddr *dst;
 	struct ifnet *ifp;
 
@@ -1084,10 +1084,10 @@
  */
 void
 if_unroute(ifp, flag, fam)
-	register struct ifnet *ifp;
+	struct ifnet *ifp;
 	int flag, fam;
 {
-	register struct ifaddr *ifa;
+	struct ifaddr *ifa;
 
 	ifp->if_flags &= ~flag;
 	getmicrotime(&ifp->if_lastchange);
@@ -1105,10 +1105,10 @@
  */
 void
 if_route(ifp, flag, fam)
-	register struct ifnet *ifp;
+	struct ifnet *ifp;
 	int flag, fam;
 {
-	register struct ifaddr *ifa;
+	struct ifaddr *ifa;
 
 	ifp->if_flags |= flag;
 	getmicrotime(&ifp->if_lastchange);
@@ -1128,7 +1128,7 @@
  */
 void
 if_down(ifp)
-	register struct ifnet *ifp;
+	struct ifnet *ifp;
 {
 
 	if_unroute(ifp, IFF_UP, AF_UNSPEC);
@@ -1141,7 +1141,7 @@
  */
 void
 if_up(ifp)
-	register struct ifnet *ifp;
+	struct ifnet *ifp;
 {
 
 	if_route(ifp, IFF_UP, AF_UNSPEC);
@@ -1152,9 +1152,9 @@
  */
 static void
 if_qflush(ifq)
-	register struct ifqueue *ifq;
+	struct ifqueue *ifq;
 {
-	register struct mbuf *m, *n;
+	struct mbuf *m, *n;
 
 	n = ifq->ifq_head;
 	while ((m = n) != 0) {
@@ -1175,7 +1175,7 @@
 if_slowtimo(arg)
 	void *arg;
 {
-	register struct ifnet *ifp;
+	struct ifnet *ifp;
 	int s = splimp();
 
 	IFNET_RLOCK();
Index: if_atmsubr.c
===================================================================
RCS file: /home/ncvs/src/sys/net/if_atmsubr.c,v
retrieving revision 1.19
diff -u -r1.19 if_atmsubr.c
--- if_atmsubr.c	21 Jan 2003 08:55:58 -0000	1.19
+++ if_atmsubr.c	11 Feb 2003 12:38:47 -0000
@@ -91,7 +91,7 @@
 
 int
 atm_output(ifp, m0, dst, rt0)
-	register struct ifnet *ifp;
+	struct ifnet *ifp;
 	struct mbuf *m0;
 	struct sockaddr *dst;
 	struct rtentry *rt0;
@@ -228,11 +228,11 @@
 void
 atm_input(ifp, ah, m, rxhand)
 	struct ifnet *ifp;
-	register struct atm_pseudohdr *ah;
+	struct atm_pseudohdr *ah;
 	struct mbuf *m;
 	void *rxhand;
 {
-	register struct ifqueue *inq;
+	struct ifqueue *inq;
 	u_int16_t etype = ETHERTYPE_IP; /* default */
 	int s;
 
@@ -311,10 +311,10 @@
  */
 void
 atm_ifattach(ifp)
-	register struct ifnet *ifp;
+	struct ifnet *ifp;
 {
-	register struct ifaddr *ifa;
-	register struct sockaddr_dl *sdl;
+	struct ifaddr *ifa;
+	struct sockaddr_dl *sdl;
 
 	ifp->if_type = IFT_ATM;
 	ifp->if_addrlen = 0;
Index: if_ef.c
===================================================================
RCS file: /home/ncvs/src/sys/net/if_ef.c,v
retrieving revision 1.21
diff -u -r1.21 if_ef.c
--- if_ef.c	21 Jan 2003 08:55:59 -0000	1.21
+++ if_ef.c	11 Feb 2003 12:38:47 -0000
@@ -157,7 +157,7 @@
 		if_down(ifp);
 		if (ifp->if_flags & IFF_RUNNING) {
 		    /* find internet addresses and delete routes */
-		    register struct ifaddr *ifa;
+		    struct ifaddr *ifa;
 		    TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
 			    rtinit(ifa, (int)RTM_DELETE, 0);
 		    }
Index: if_ethersubr.c
===================================================================
RCS file: /home/ncvs/src/sys/net/if_ethersubr.c,v
retrieving revision 1.133
diff -u -r1.133 if_ethersubr.c
--- if_ethersubr.c	21 Jan 2003 08:55:59 -0000	1.133
+++ if_ethersubr.c	11 Feb 2003 12:38:47 -0000
@@ -139,7 +139,7 @@
  */
 int
 ether_output(ifp, m, dst, rt0)
-	register struct ifnet *ifp;
+	struct ifnet *ifp;
 	struct mbuf *m;
 	struct sockaddr *dst;
 	struct rtentry *rt0;
@@ -147,8 +147,8 @@
 	short type;
 	int error = 0, hdrcmplt = 0;
  	u_char esrc[6], edst[6];
-	register struct rtentry *rt;
-	register struct ether_header *eh;
+	struct rtentry *rt;
+	struct ether_header *eh;
 	int loop_copy = 0;
 	int hlen;	/* link layer header lenght */
 	struct arpcom *ac = IFP2AC(ifp);
@@ -669,7 +669,7 @@
 	struct ifqueue *inq;
 	u_short ether_type;
 #if defined(NETATALK)
-	register struct llc *l;
+	struct llc *l;
 #endif
 	struct ip_fw *rule = NULL;
 
@@ -923,8 +923,8 @@
 void
 ether_ifattach(struct ifnet *ifp, const u_int8_t *llc)
 {
-	register struct ifaddr *ifa;
-	register struct sockaddr_dl *sdl;
+	struct ifaddr *ifa;
+	struct sockaddr_dl *sdl;
 
 	ifp->if_type = IFT_ETHER;
 	ifp->if_addrlen = ETHER_ADDR_LEN;
@@ -1004,7 +1004,7 @@
 		 */
 		case AF_IPX:
 			{
-			register struct ipx_addr *ina = &(IA_SIPX(ifa)->sipx_addr);
+			struct ipx_addr *ina = &(IA_SIPX(ifa)->sipx_addr);
 			struct arpcom *ac = IFP2AC(ifp);
 
 			if (ipx_nullhost(*ina))
@@ -1030,7 +1030,7 @@
 		 */
 		case AF_NS:
 		{
-			register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
+			struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
 			struct arpcom *ac = IFP2AC(ifp);
 
 			if (ns_nullhost(*ina))
Index: if_iso88025subr.c
===================================================================
RCS file: /home/ncvs/src/sys/net/if_iso88025subr.c,v
retrieving revision 1.25
diff -u -r1.25 if_iso88025subr.c
--- if_iso88025subr.c	21 Jan 2003 08:55:59 -0000	1.25
+++ if_iso88025subr.c	11 Feb 2003 12:38:47 -0000
@@ -91,8 +91,8 @@
 void
 iso88025_ifattach(struct ifnet *ifp)
 {
-    register struct ifaddr *ifa = NULL;
-    register struct sockaddr_dl *sdl;
+    struct ifaddr *ifa = NULL;
+    struct sockaddr_dl *sdl;
 
     ifp->if_type = IFT_ISO88025;
     ifp->if_addrlen = ISO88025_ADDR_LEN;
@@ -152,7 +152,7 @@
                  */
                 case AF_IPX:
                         {
-                        register struct ipx_addr *ina = &(IA_SIPX(ifa)->sipx_addr);
+                        struct ipx_addr *ina = &(IA_SIPX(ifa)->sipx_addr);
                         struct arpcom *ac = IFP2AC(ifp);
 
                         if (ipx_nullhost(*ina))
@@ -414,8 +414,8 @@
 	struct iso88025_header *th;
 	struct mbuf *m;
 {
-	register struct ifqueue *inq;
-	register struct llc *l;
+	struct ifqueue *inq;
+	struct llc *l;
 
 	if ((ifp->if_flags & IFF_UP) == 0) {
 		m_freem(m);
Index: if_loop.c
===================================================================
RCS file: /home/ncvs/src/sys/net/if_loop.c,v
retrieving revision 1.77
diff -u -r1.77 if_loop.c
--- if_loop.c	21 Jan 2003 08:55:59 -0000	1.77
+++ if_loop.c	11 Feb 2003 12:38:47 -0000
@@ -193,9 +193,9 @@
 int
 looutput(ifp, m, dst, rt)
 	struct ifnet *ifp;
-	register struct mbuf *m;
+	struct mbuf *m;
 	struct sockaddr *dst;
-	register struct rtentry *rt;
+	struct rtentry *rt;
 {
 	if ((m->m_flags & M_PKTHDR) == 0)
 		panic("looutput no HDR");
@@ -402,13 +402,13 @@
 /* ARGSUSED */
 int
 loioctl(ifp, cmd, data)
-	register struct ifnet *ifp;
+	struct ifnet *ifp;
 	u_long cmd;
 	caddr_t data;
 {
-	register struct ifaddr *ifa;
-	register struct ifreq *ifr = (struct ifreq *)data;
-	register int error = 0;
+	struct ifaddr *ifa;
+	struct ifreq *ifr = (struct ifreq *)data;
+	int error = 0;
 
 	switch (cmd) {
 
Index: if_media.c
===================================================================
RCS file: /home/ncvs/src/sys/net/if_media.c,v
retrieving revision 1.17
diff -u -r1.17 if_media.c
--- if_media.c	26 Jun 2002 03:34:50 -0000	1.17
+++ if_media.c	11 Feb 2003 12:38:47 -0000
@@ -113,7 +113,7 @@
 	int data;
 	void *aux;
 {
-	register struct ifmedia_entry *entry;
+	struct ifmedia_entry *entry;
 
 #ifdef IFMEDIA_DEBUG
 	if (ifmedia_debug) {
Index: if_ppp.c
===================================================================
RCS file: /home/ncvs/src/sys/net/if_ppp.c,v
retrieving revision 1.88
diff -u -r1.88 if_ppp.c
--- if_ppp.c	2 Feb 2003 18:15:28 -0000	1.88
+++ if_ppp.c	11 Feb 2003 12:38:47 -0000
@@ -612,14 +612,14 @@
  */
 static int
 pppsioctl(ifp, cmd, data)
-    register struct ifnet *ifp;
+    struct ifnet *ifp;
     u_long cmd;
     caddr_t data;
 {
     struct thread *td = curthread;	/* XXX */
-    register struct ppp_softc *sc = ifp->if_softc;
-    register struct ifaddr *ifa = (struct ifaddr *)data;
-    register struct ifreq *ifr = (struct ifreq *)data;
+    struct ppp_softc *sc = ifp->if_softc;
+    struct ifaddr *ifa = (struct ifaddr *)data;
+    struct ifreq *ifr = (struct ifreq *)data;
     struct ppp_stats *psp;
 #ifdef	PPP_COMPRESS
     struct ppp_comp_stats *pcp;
@@ -747,7 +747,7 @@
     struct sockaddr *dst;
     struct rtentry *rtp;
 {
-    register struct ppp_softc *sc = ifp->if_softc;
+    struct ppp_softc *sc = ifp->if_softc;
     int protocol, address, control;
     u_char *cp;
     int s, error;
Index: if_sl.c
===================================================================
RCS file: /home/ncvs/src/sys/net/if_sl.c,v
retrieving revision 1.107
diff -u -r1.107 if_sl.c
--- if_sl.c	21 Jan 2003 08:55:59 -0000	1.107
+++ if_sl.c	11 Feb 2003 12:38:47 -0000
@@ -336,9 +336,9 @@
 static int
 slopen(dev, tp)
 	dev_t dev;
-	register struct tty *tp;
+	struct tty *tp;
 {
-	register struct sl_softc *sc;
+	struct sl_softc *sc;
 	int s, error;
 
 	error = suser(curthread);
@@ -401,7 +401,7 @@
 	struct tty *tp;
 	int flag;
 {
-	register struct sl_softc *sc;
+	struct sl_softc *sc;
 	int s;
 
 	ttyflush(tp, FREAD | FWRITE);
@@ -540,13 +540,13 @@
 static int
 sloutput(ifp, m, dst, rtp)
 	struct ifnet *ifp;
-	register struct mbuf *m;
+	struct mbuf *m;
 	struct sockaddr *dst;
 	struct rtentry *rtp;
 {
-	register struct sl_softc *sc = ifp->if_softc;
-	register struct ip *ip;
-	register struct ifqueue *ifq;
+	struct sl_softc *sc = ifp->if_softc;
+	struct ip *ip;
+	struct ifqueue *ifq;
 	int s;
 
 	/*
@@ -594,14 +594,14 @@
  */
 static int
 slstart(tp)
-	register struct tty *tp;
+	struct tty *tp;
 {
-	register struct sl_softc *sc = (struct sl_softc *)tp->t_sc;
-	register struct mbuf *m;
-	register u_char *cp;
-	register struct ip *ip;
+	struct sl_softc *sc = (struct sl_softc *)tp->t_sc;
+	struct mbuf *m;
+	u_char *cp;
+	struct ip *ip;
 	int s;
-	register int len = 0;
+	int len = 0;
 
 	for (;;) {
 		/*
@@ -652,8 +652,8 @@
 			 * and/or the copy should be negligible cost compared
 			 * to the packet transmission time).
 			 */
-			register struct mbuf *m1 = m;
-			register u_char *cp;
+			struct mbuf *m1 = m;
+			u_char *cp;
 
 			if (sc->bpfbuf == NULL)
 				MALLOC(sc->bpfbuf, u_char *,
@@ -663,7 +663,7 @@
 				cp = sc->bpfbuf + SLIP_HDRLEN;
 				len = 0;
 				do {
-					register int mlen = m1->m_len;
+					int mlen = m1->m_len;
 
 					bcopy(mtod(m1, caddr_t), cp, mlen);
 					cp += mlen;
@@ -714,7 +714,7 @@
 		}
 
 		while (m) {
-			register u_char *ep;
+			u_char *ep;
 
 			cp = mtod(m, u_char *); ep = cp + m->m_len;
 			while (cp < ep) {
@@ -722,7 +722,7 @@
 				 * Find out how many bytes in the string we can
 				 * handle without doing something special.
 				 */
-				register u_char *bp = cp;
+				u_char *bp = cp;
 
 				while (cp < ep) {
 					switch (*cp++) {
@@ -787,8 +787,8 @@
  */
 static struct mbuf *
 sl_btom(sc, len)
-	register struct sl_softc *sc;
-	register int len;
+	struct sl_softc *sc;
+	int len;
 {
 	struct mbuf *m, *newm;
 
@@ -834,12 +834,12 @@
  */
 static int
 slinput(c, tp)
-	register int c;
-	register struct tty *tp;
+	int c;
+	struct tty *tp;
 {
-	register struct sl_softc *sc;
-	register struct mbuf *m;
-	register int len;
+	struct sl_softc *sc;
+	struct mbuf *m;
+	int len;
 	u_char chdr[CHDR_LEN];
 
 	tk_nin++;
@@ -953,7 +953,7 @@
 			 * decompression probably moved the buffer
 			 * pointer.  Then, invoke BPF.
 			 */
-			register u_char *hp = sc->sc_buf - SLIP_HDRLEN;
+			u_char *hp = sc->sc_buf - SLIP_HDRLEN;
 
 			hp[SLX_DIR] = SLIPDIR_IN;
 			bcopy(chdr, &hp[SLX_CHDR], CHDR_LEN);
@@ -1000,13 +1000,13 @@
  */
 static int
 slioctl(ifp, cmd, data)
-	register struct ifnet *ifp;
+	struct ifnet *ifp;
 	u_long cmd;
 	caddr_t data;
 {
-	register struct ifaddr *ifa = (struct ifaddr *)data;
-	register struct ifreq *ifr = (struct ifreq *)data;
-	register int s, error = 0;
+	struct ifaddr *ifa = (struct ifaddr *)data;
+	struct ifreq *ifr = (struct ifreq *)data;
+	int s, error = 0;
 	struct sl_softc *sc = ifp->if_softc;
 
 	s = splimp();
@@ -1095,7 +1095,7 @@
 	void *chan;
 {
 	struct sl_softc *sc = chan;
-	register struct tty *tp = sc->sc_ttyp;
+	struct tty *tp = sc->sc_ttyp;
 	int s;
 
 	if (sc->sc_outfill && tp != NULL) {
Index: if_tun.c
===================================================================
RCS file: /home/ncvs/src/sys/net/if_tun.c,v
retrieving revision 1.115
diff -u -r1.115 if_tun.c
--- if_tun.c	30 Jan 2003 13:13:11 -0000	1.115
+++ if_tun.c	11 Feb 2003 12:38:48 -0000
@@ -316,7 +316,7 @@
 	}
 
 	if (ifp->if_flags & IFF_RUNNING) {
-		register struct ifaddr *ifa;
+		struct ifaddr *ifa;
 
 		s = splimp();
 		/* find internet addresses and delete routes */
@@ -342,7 +342,7 @@
 tuninit(struct ifnet *ifp)
 {
 	struct tun_softc *tp = ifp->if_softc;
-	register struct ifaddr *ifa;
+	struct ifaddr *ifa;
 	int error = 0;
 
 	TUNDEBUG("%s%d: tuninit\n", ifp->if_name, ifp->if_unit);
Index: ppp_tty.c
===================================================================
RCS file: /home/ncvs/src/sys/net/ppp_tty.c,v
retrieving revision 1.54
diff -u -r1.54 ppp_tty.c
--- ppp_tty.c	21 Jan 2003 08:55:59 -0000	1.54
+++ ppp_tty.c	11 Feb 2003 12:38:48 -0000
@@ -175,10 +175,10 @@
 static int
 pppopen(dev, tp)
     dev_t dev;
-    register struct tty *tp;
+    struct tty *tp;
 {
     struct thread *td = curthread;		/* XXX */
-    register struct ppp_softc *sc;
+    struct ppp_softc *sc;
     int error, s;
 
     if ((error = suser(td)) != 0)
@@ -248,7 +248,7 @@
     struct tty *tp;
     int flag;
 {
-    register struct ppp_softc *sc;
+    struct ppp_softc *sc;
     int s;
 
     s = spltty();
@@ -298,9 +298,9 @@
  */
 static void
 pppasyncsetmtu(sc)
-register struct ppp_softc *sc;
+struct ppp_softc *sc;
 {
-    register struct tty *tp = (struct tty *) sc->sc_devp;
+    struct tty *tp = (struct tty *) sc->sc_devp;
     int s;
 
     s = spltty();
@@ -317,13 +317,13 @@
  */
 static int
 pppread(tp, uio, flag)
-    register struct tty *tp;
+    struct tty *tp;
     struct uio *uio;
     int flag;
 {
-    register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
+    struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
     struct mbuf *m, *m0;
-    register int s;
+    int s;
     int error = 0;
 
     if (sc == NULL)
@@ -376,11 +376,11 @@
  */
 static int
 pppwrite(tp, uio, flag)
-    register struct tty *tp;
+    struct tty *tp;
     struct uio *uio;
     int flag;
 {
-    register struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
+    struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
     struct mbuf *m, *m0, **mp;
     struct sockaddr dst;
     int len, error, s;
@@ -548,12 +548,12 @@
  */
 static void
 pppasyncstart(sc)
-    register struct ppp_softc *sc;
+    struct ppp_softc *sc;
 {
-    register struct tty *tp = (struct tty *) sc->sc_devp;
-    register struct mbuf *m;
-    register int len;
-    register u_char *start, *stop, *cp;
+    struct tty *tp = (struct tty *) sc->sc_devp;
+    struct mbuf *m;
+    int len;
+    u_char *start, *stop, *cp;
     int n, ndone, done, idle;
     int s;
 
@@ -754,9 +754,9 @@
  */
 static int
 pppstart(tp)
-    register struct tty *tp;
+    struct tty *tp;
 {
-    register struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc;
+    struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc;
 
     /*
      * Call output process whether or not there is any output.
@@ -801,7 +801,7 @@
  */
 static void
 pppgetm(sc)
-    register struct ppp_softc *sc;
+    struct ppp_softc *sc;
 {
     struct mbuf *m, **mp;
     int len;
@@ -836,9 +836,9 @@
 static int
 pppinput(c, tp)
     int c;
-    register struct tty *tp;
+    struct tty *tp;
 {
-    register struct ppp_softc *sc;
+    struct ppp_softc *sc;
     struct mbuf *m;
     int ilen, s;
 
Index: radix.c
===================================================================
RCS file: /home/ncvs/src/sys/net/radix.c,v
retrieving revision 1.31
diff -u -r1.31 radix.c
--- radix.c	8 Feb 2003 01:44:09 -0000	1.31
+++ radix.c	11 Feb 2003 12:38:48 -0000
@@ -120,8 +120,8 @@
 	void *v_arg;
 	struct radix_node *head;
 {
-	register struct radix_node *x;
-	register caddr_t v;
+	struct radix_node *x;
+	caddr_t v;
 
 	for (x = head, v = v_arg; x->rn_bit >= 0;) {
 		if (x->rn_bmask & v[x->rn_offset])
@@ -137,8 +137,8 @@
 	struct radix_node *head;
 	void *v_arg, *m_arg;
 {
-	register struct radix_node *x;
-	register caddr_t v = v_arg, m = m_arg;
+	struct radix_node *x;
+	caddr_t v = v_arg, m = m_arg;
 
 	for (x = head; x->rn_bit >= 0;) {
 		if ((x->rn_bmask & m[x->rn_offset]) &&
@@ -154,8 +154,8 @@
 rn_refines(m_arg, n_arg)
 	void *m_arg, *n_arg;
 {
-	register caddr_t m = m_arg, n = n_arg;
-	register caddr_t lim, lim2 = lim = n + *(u_char *)n;
+	caddr_t m = m_arg, n = n_arg;
+	caddr_t lim, lim2 = lim = n + *(u_char *)n;
 	int longer = (*(u_char *)n++) - (int)(*(u_char *)m++);
 	int masks_are_equal = 1;
 
@@ -182,7 +182,7 @@
 	void *v_arg, *m_arg;
 	struct radix_node_head *head;
 {
-	register struct radix_node *x;
+	struct radix_node *x;
 	caddr_t netmask = 0;
 
 	if (m_arg) {
@@ -202,10 +202,10 @@
 static int
 rn_satisfies_leaf(trial, leaf, skip)
 	char *trial;
-	register struct radix_node *leaf;
+	struct radix_node *leaf;
 	int skip;
 {
-	register char *cp = trial, *cp2 = leaf->rn_key, *cp3 = leaf->rn_mask;
+	char *cp = trial, *cp2 = leaf->rn_key, *cp3 = leaf->rn_mask;
 	char *cplim;
 	int length = min(*(u_char *)cp, *(u_char *)cp2);
 
@@ -226,12 +226,12 @@
 	struct radix_node_head *head;
 {
 	caddr_t v = v_arg;
-	register struct radix_node *t = head->rnh_treetop, *x;
-	register caddr_t cp = v, cp2;
+	struct radix_node *t = head->rnh_treetop, *x;
+	caddr_t cp = v, cp2;
 	caddr_t cplim;
 	struct radix_node *saved_t, *top = t;
 	int off = t->rn_offset, vlen = *(u_char *)cp, matched_off;
-	register int test, b, rn_bit;
+	int test, b, rn_bit;
 
 	/*
 	 * Open code rn_search(v, top) to avoid overhead of extra
@@ -296,7 +296,7 @@
 	t = saved_t;
 	/* start searching up the tree */
 	do {
-		register struct radix_mask *m;
+		struct radix_mask *m;
 		t = t->rn_parent;
 		m = t->rn_mklist;
 		/*
@@ -336,7 +336,7 @@
 	int b;
 	struct radix_node nodes[2];
 {
-	register struct radix_node *tt = nodes, *t = tt + 1;
+	struct radix_node *tt = nodes, *t = tt + 1;
 	t->rn_bit = b;
 	t->rn_bmask = 0x80 >> (b & 7);
 	t->rn_left = tt;
@@ -365,16 +365,16 @@
 	caddr_t v = v_arg;
 	struct radix_node *top = head->rnh_treetop;
 	int head_off = top->rn_offset, vlen = (int)*((u_char *)v);
-	register struct radix_node *t = rn_search(v_arg, top);
-	register caddr_t cp = v + head_off;
-	register int b;
+	struct radix_node *t = rn_search(v_arg, top);
+	caddr_t cp = v + head_off;
+	int b;
 	struct radix_node *tt;
     	/*
 	 * Find first bit at which v and t->rn_key differ
 	 */
     {
-	register caddr_t cp2 = t->rn_key + head_off;
-	register int cmp_res;
+	caddr_t cp2 = t->rn_key + head_off;
+	int cmp_res;
 	caddr_t cplim = v + vlen;
 
 	while (cp < cplim)
@@ -389,7 +389,7 @@
 		cmp_res >>= 1;
     }
     {
-	register struct radix_node *p, *x = top;
+	struct radix_node *p, *x = top;
 	cp = v;
 	do {
 		p = x;
@@ -431,9 +431,9 @@
 	void *n_arg;
 {
 	caddr_t netmask = (caddr_t)n_arg;
-	register struct radix_node *x;
-	register caddr_t cp, cplim;
-	register int b = 0, mlen, j;
+	struct radix_node *x;
+	caddr_t cp, cplim;
+	int b = 0, mlen, j;
 	int maskduplicated, m0, isnormal;
 	struct radix_node *saved_x;
 	static int last_zeroed = 0;
@@ -502,7 +502,7 @@
 rn_lexobetter(m_arg, n_arg)
 	void *m_arg, *n_arg;
 {
-	register u_char *mp = m_arg, *np = n_arg, *lim;
+	u_char *mp = m_arg, *np = n_arg, *lim;
 
 	if (*mp > *np)
 		return 1;  /* not really, but need to check longer one first */
@@ -515,10 +515,10 @@
 
 static struct radix_mask *
 rn_new_radix_mask(tt, next)
-	register struct radix_node *tt;
-	register struct radix_mask *next;
+	struct radix_node *tt;
+	struct radix_mask *next;
 {
-	register struct radix_mask *m;
+	struct radix_mask *m;
 
 	MKGet(m);
 	if (m == 0) {
@@ -544,7 +544,7 @@
 	struct radix_node treenodes[2];
 {
 	caddr_t v = (caddr_t)v_arg, netmask = (caddr_t)n_arg;
-	register struct radix_node *t, *x = 0, *tt;
+	struct radix_node *t, *x = 0, *tt;
 	struct radix_node *saved_tt, *top = head->rnh_treetop;
 	short b = 0, b_leaf = 0;
 	int keyduplicated;
@@ -700,7 +700,7 @@
 	void *v_arg, *netmask_arg;
 	struct radix_node_head *head;
 {
-	register struct radix_node *t, *p, *x, *tt;
+	struct radix_node *t, *p, *x, *tt;
 	struct radix_mask *m, *saved_m, **mp;
 	struct radix_node *dupedkey, *saved_tt, *top;
 	caddr_t v, netmask;
@@ -895,7 +895,7 @@
 	struct radix_node *base, *next;
 	u_char *xa = (u_char *)a;
 	u_char *xm = (u_char *)m;
-	register struct radix_node *rn, *last = 0 /* shut up gcc */;
+	struct radix_node *rn, *last = 0 /* shut up gcc */;
 	int stopping = 0;
 	int lastb;
 
@@ -983,7 +983,7 @@
 {
 	int error;
 	struct radix_node *base, *next;
-	register struct radix_node *rn = h->rnh_treetop;
+	struct radix_node *rn = h->rnh_treetop;
 	/*
 	 * This gets complicated because we may delete the node
 	 * while applying the function f to it, so we need to calculate
@@ -1021,8 +1021,8 @@
 	void **head;
 	int off;
 {
-	register struct radix_node_head *rnh;
-	register struct radix_node *t, *tt, *ttt;
+	struct radix_node_head *rnh;
+	struct radix_node *t, *tt, *ttt;
 	if (*head)
 		return (1);
 	R_Malloc(rnh, struct radix_node_head *, sizeof (*rnh));
Index: raw_cb.c
===================================================================
RCS file: /home/ncvs/src/sys/net/raw_cb.c,v
retrieving revision 1.24
diff -u -r1.24 raw_cb.c
--- raw_cb.c	21 Jan 2003 08:55:59 -0000	1.24
+++ raw_cb.c	11 Feb 2003 12:38:48 -0000
@@ -64,10 +64,10 @@
  */
 int
 raw_attach(so, proto)
-	register struct socket *so;
+	struct socket *so;
 	int proto;
 {
-	register struct rawcb *rp = sotorawcb(so);
+	struct rawcb *rp = sotorawcb(so);
 	int error;
 
 	/*
@@ -93,7 +93,7 @@
  */
 void
 raw_detach(rp)
-	register struct rawcb *rp;
+	struct rawcb *rp;
 {
 	struct socket *so = rp->rcb_socket;
 
@@ -130,11 +130,11 @@
 
 int
 raw_bind(so, nam)
-	register struct socket *so;
+	struct socket *so;
 	struct mbuf *nam;
 {
 	struct sockaddr *addr = mtod(nam, struct sockaddr *);
-	register struct rawcb *rp;
+	struct rawcb *rp;
 
 	if (ifnet == 0)
 		return (EADDRNOTAVAIL);
Index: raw_usrreq.c
===================================================================
RCS file: /home/ncvs/src/sys/net/raw_usrreq.c,v
retrieving revision 1.28
diff -u -r1.28 raw_usrreq.c
--- raw_usrreq.c	28 Dec 2002 02:29:19 -0000	1.28
+++ raw_usrreq.c	11 Feb 2003 12:38:48 -0000
@@ -67,11 +67,11 @@
 void
 raw_input(m0, proto, src, dst)
 	struct mbuf *m0;
-	register struct sockproto *proto;
+	struct sockproto *proto;
 	struct sockaddr *src, *dst;
 {
-	register struct rawcb *rp;
-	register struct mbuf *m = m0;
+	struct rawcb *rp;
+	struct mbuf *m = m0;
 	struct socket *last;
 
 	last = 0;
Index: route.c
===================================================================
RCS file: /home/ncvs/src/sys/net/route.c,v
retrieving revision 1.78
diff -u -r1.78 route.c
--- route.c	21 Jan 2003 08:55:59 -0000	1.78
+++ route.c	11 Feb 2003 12:38:48 -0000
@@ -86,14 +86,14 @@
  */
 void
 rtalloc(ro)
-	register struct route *ro;
+	struct route *ro;
 {
 	rtalloc_ign(ro, 0UL);
 }
 
 void
 rtalloc_ign(ro, ignore)
-	register struct route *ro;
+	struct route *ro;
 	u_long ignore;
 {
 	struct rtentry *rt;
@@ -117,13 +117,13 @@
  */
 struct rtentry *
 rtalloc1(dst, report, ignflags)
-	register struct sockaddr *dst;
+	struct sockaddr *dst;
 	int report;
 	u_long ignflags;
 {
-	register struct radix_node_head *rnh = rt_tables[dst->sa_family];
-	register struct rtentry *rt;
-	register struct radix_node *rn;
+	struct radix_node_head *rnh = rt_tables[dst->sa_family];
+	struct rtentry *rt;
+	struct radix_node *rn;
 	struct rtentry *newrt = 0;
 	struct rt_addrinfo info;
 	u_long nflags;
@@ -214,7 +214,7 @@
  */
 void
 rtfree(rt)
-	register struct rtentry *rt;
+	struct rtentry *rt;
 {
 	/*
 	 * find the tree for that address family
@@ -409,7 +409,7 @@
 	int flags;
 	struct sockaddr	*dst, *gateway;
 {
-	register struct ifaddr *ifa;
+	struct ifaddr *ifa;
 	if ((flags & RTF_GATEWAY) == 0) {
 		/*
 		 * If we are adding a route to an interface,
@@ -534,9 +534,9 @@
 	struct rtentry **ret_nrt;
 {
 	int s = splnet(); int error = 0;
-	register struct rtentry *rt;
-	register struct radix_node *rn;
-	register struct radix_node_head *rnh;
+	struct rtentry *rt;
+	struct radix_node *rn;
+	struct radix_node_head *rnh;
 	struct ifaddr *ifa;
 	struct sockaddr *ndst;
 #define senderr(x) { error = x ; goto bad; }
@@ -911,7 +911,7 @@
 {
 	caddr_t new, old;
 	int dlen = ROUNDUP(dst->sa_len), glen = ROUNDUP(gate->sa_len);
-	register struct rtentry *rt = rt0;
+	struct rtentry *rt = rt0;
 	struct radix_node_head *rnh = rt_tables[dst->sa_family];
 
 	/*
@@ -1016,9 +1016,9 @@
 rt_maskedcopy(src, dst, netmask)
 	struct sockaddr *src, *dst, *netmask;
 {
-	register u_char *cp1 = (u_char *)src;
-	register u_char *cp2 = (u_char *)dst;
-	register u_char *cp3 = (u_char *)netmask;
+	u_char *cp1 = (u_char *)src;
+	u_char *cp2 = (u_char *)dst;
+	u_char *cp3 = (u_char *)netmask;
 	u_char *cplim = cp2 + *cp3;
 	u_char *cplim2 = cp2 + *cp1;
 
@@ -1038,12 +1038,12 @@
  */
 int
 rtinit(ifa, cmd, flags)
-	register struct ifaddr *ifa;
+	struct ifaddr *ifa;
 	int cmd, flags;
 {
-	register struct rtentry *rt;
-	register struct sockaddr *dst;
-	register struct sockaddr *deldst;
+	struct rtentry *rt;
+	struct sockaddr *dst;
+	struct sockaddr *deldst;
 	struct sockaddr *netmask;
 	struct mbuf *m = 0;
 	struct rtentry *nrt = 0;
Index: rtsock.c
===================================================================
RCS file: /home/ncvs/src/sys/net/rtsock.c,v
retrieving revision 1.87
diff -u -r1.87 rtsock.c
--- rtsock.c	21 Jan 2003 08:55:59 -0000	1.87
+++ rtsock.c	11 Feb 2003 12:38:48 -0000
@@ -274,11 +274,11 @@
 /*ARGSUSED*/
 static int
 route_output(m, so)
-	register struct mbuf *m;
+	struct mbuf *m;
 	struct socket *so;
 {
-	register struct rt_msghdr *rtm = 0;
-	register struct rtentry *rt = 0;
+	struct rt_msghdr *rtm = 0;
+	struct rtentry *rt = 0;
 	struct rtentry *saved_nrt = 0;
 	struct radix_node_head *rnh;
 	struct rt_addrinfo info;
@@ -430,7 +430,7 @@
 			    (error = rt_setgate(rt, rt_key(rt), gate)) != 0)
 				senderr(error);
 			if ((ifa = info.rti_ifa) != NULL) {
-				register struct ifaddr *oifa = rt->rt_ifa;
+				struct ifaddr *oifa = rt->rt_ifa;
 				if (oifa != ifa) {
 				    if (oifa) {
 					if (oifa->ifa_rtrequest)
@@ -472,7 +472,7 @@
 	if (rt)
 		rtfree(rt);
     {
-	register struct rawcb *rp = 0;
+	struct rawcb *rp = 0;
 	/*
 	 * Check to see if we don't want our own messages.
 	 */
@@ -510,7 +510,7 @@
 static void
 rt_setmetrics(which, in, out)
 	u_long which;
-	register struct rt_metrics *in, *out;
+	struct rt_metrics *in, *out;
 {
 #define metric(f, e) if (which & (f)) out->e = in->e;
 	metric(RTV_RPIPE, rmx_recvpipe);
@@ -536,11 +536,11 @@
  */
 static int
 rt_xaddrs(cp, cplim, rtinfo)
-	register caddr_t cp, cplim;
-	register struct rt_addrinfo *rtinfo;
+	caddr_t cp, cplim;
+	struct rt_addrinfo *rtinfo;
 {
-	register struct sockaddr *sa;
-	register int i;
+	struct sockaddr *sa;
+	int i;
 
 	for (i = 0; (i < RTAX_MAX) && (cp < cplim); i++) {
 		if ((rtinfo->rti_addrs & (1 << i)) == 0)
@@ -575,12 +575,12 @@
 static struct mbuf *
 rt_msg1(type, rtinfo)
 	int type;
-	register struct rt_addrinfo *rtinfo;
+	struct rt_addrinfo *rtinfo;
 {
-	register struct rt_msghdr *rtm;
-	register struct mbuf *m;
-	register int i;
-	register struct sockaddr *sa;
+	struct rt_msghdr *rtm;
+	struct mbuf *m;
+	int i;
+	struct sockaddr *sa;
 	int len, dlen;
 
 	switch (type) {
@@ -643,11 +643,11 @@
 static int
 rt_msg2(type, rtinfo, cp, w)
 	int type;
-	register struct rt_addrinfo *rtinfo;
+	struct rt_addrinfo *rtinfo;
 	caddr_t cp;
 	struct walkarg *w;
 {
-	register int i;
+	int i;
 	int len, dlen, second_time = 0;
 	caddr_t cp0;
 
@@ -671,7 +671,7 @@
 	if (cp0)
 		cp += len;
 	for (i = 0; i < RTAX_MAX; i++) {
-		register struct sockaddr *sa;
+		struct sockaddr *sa;
 
 		if ((sa = rtinfo->rti_info[i]) == 0)
 			continue;
@@ -685,7 +685,7 @@
 	}
 	len = ALIGN(len);
 	if (cp == 0 && w != NULL && !second_time) {
-		register struct walkarg *rw = w;
+		struct walkarg *rw = w;
 
 		if (rw->w_req) {
 			if (rw->w_tmemsize < len) {
@@ -704,7 +704,7 @@
 		}
 	}
 	if (cp) {
-		register struct rt_msghdr *rtm = (struct rt_msghdr *)cp0;
+		struct rt_msghdr *rtm = (struct rt_msghdr *)cp0;
 
 		rtm->rtm_version = RTM_VERSION;
 		rtm->rtm_type = type;
@@ -722,10 +722,10 @@
 void
 rt_missmsg(type, rtinfo, flags, error)
 	int type, flags, error;
-	register struct rt_addrinfo *rtinfo;
+	struct rt_addrinfo *rtinfo;
 {
-	register struct rt_msghdr *rtm;
-	register struct mbuf *m;
+	struct rt_msghdr *rtm;
+	struct mbuf *m;
 	struct sockaddr *sa = rtinfo->rti_info[RTAX_DST];
 
 	if (route_cb.any_count == 0)
@@ -747,9 +747,9 @@
  */
 void
 rt_ifmsg(ifp)
-	register struct ifnet *ifp;
+	struct ifnet *ifp;
 {
-	register struct if_msghdr *ifm;
+	struct if_msghdr *ifm;
 	struct mbuf *m;
 	struct rt_addrinfo info;
 
@@ -779,8 +779,8 @@
 void
 rt_newaddrmsg(cmd, ifa, error, rt)
 	int cmd, error;
-	register struct ifaddr *ifa;
-	register struct rtentry *rt;
+	struct ifaddr *ifa;
+	struct rtentry *rt;
 {
 	struct rt_addrinfo info;
 	struct sockaddr *sa = 0;
@@ -794,7 +794,7 @@
 		bzero((caddr_t)&info, sizeof(info));
 		if ((cmd == RTM_ADD && pass == 1) ||
 		    (cmd == RTM_DELETE && pass == 2)) {
-			register struct ifa_msghdr *ifam;
+			struct ifa_msghdr *ifam;
 			int ncmd = cmd == RTM_ADD ? RTM_NEWADDR : RTM_DELADDR;
 
 			ifaaddr = sa = ifa->ifa_addr;
@@ -811,7 +811,7 @@
 		}
 		if ((cmd == RTM_ADD && pass == 2) ||
 		    (cmd == RTM_DELETE && pass == 1)) {
-			register struct rt_msghdr *rtm;
+			struct rt_msghdr *rtm;
 
 			if (rt == 0)
 				continue;
@@ -905,8 +905,8 @@
 	struct radix_node *rn;
 	void *vw;
 {
-	register struct walkarg *w = vw;
-	register struct rtentry *rt = (struct rtentry *)rn;
+	struct walkarg *w = vw;
+	struct rtentry *rt = (struct rtentry *)rn;
 	int error = 0, size;
 	struct rt_addrinfo info;
 
@@ -925,7 +925,7 @@
 	}
 	size = rt_msg2(RTM_GET, &info, 0, w);
 	if (w->w_req && w->w_tmem) {
-		register struct rt_msghdr *rtm = (struct rt_msghdr *)w->w_tmem;
+		struct rt_msghdr *rtm = (struct rt_msghdr *)w->w_tmem;
 
 		rtm->rtm_flags = rt->rt_flags;
 		rtm->rtm_use = rt->rt_use;
@@ -942,10 +942,10 @@
 static int
 sysctl_iflist(af, w)
 	int	af;
-	register struct	walkarg *w;
+	struct	walkarg *w;
 {
-	register struct ifnet *ifp;
-	register struct ifaddr *ifa;
+	struct ifnet *ifp;
+	struct ifaddr *ifa;
 	struct	rt_addrinfo info;
 	int	len, error = 0;
 
@@ -959,7 +959,7 @@
 		len = rt_msg2(RTM_IFINFO, &info, (caddr_t)0, w);
 		ifpaddr = 0;
 		if (w->w_req && w->w_tmem) {
-			register struct if_msghdr *ifm;
+			struct if_msghdr *ifm;
 
 			ifm = (struct if_msghdr *)w->w_tmem;
 			ifm->ifm_index = ifp->if_index;
@@ -981,7 +981,7 @@
 			brdaddr = ifa->ifa_dstaddr;
 			len = rt_msg2(RTM_NEWADDR, &info, 0, w);
 			if (w->w_req && w->w_tmem) {
-				register struct ifa_msghdr *ifam;
+				struct ifa_msghdr *ifam;
 
 				ifam = (struct ifa_msghdr *)w->w_tmem;
 				ifam->ifam_index = ifa->ifa_ifp->if_index;
@@ -1005,7 +1005,7 @@
 {
 	int	*name = (int *)arg1;
 	u_int	namelen = arg2;
-	register struct radix_node_head *rnh;
+	struct radix_node_head *rnh;
 	int	i, s, error = EINVAL;
 	u_char  af;
 	struct	walkarg w;
Index: slcompress.c
===================================================================
RCS file: /home/ncvs/src/sys/net/slcompress.c,v
retrieving revision 1.17
diff -u -r1.17 slcompress.c
--- slcompress.c	25 Aug 2002 13:17:25 -0000	1.17
+++ slcompress.c	11 Feb 2003 12:38:48 -0000
@@ -71,8 +71,8 @@
 	struct slcompress *comp;
 	int max_state;
 {
-	register u_int i;
-	register struct cstate *tstate = comp->tstate;
+	u_int i;
+	struct cstate *tstate = comp->tstate;
 
 	if (max_state == -1) {
 		max_state = MAX_STATES - 1;
@@ -161,18 +161,18 @@
 u_int
 sl_compress_tcp(m, ip, comp, compress_cid)
 	struct mbuf *m;
-	register struct ip *ip;
+	struct ip *ip;
 	struct slcompress *comp;
 	int compress_cid;
 {
-	register struct cstate *cs = comp->last_cs->cs_next;
-	register u_int hlen = ip->ip_hl;
-	register struct tcphdr *oth;
-	register struct tcphdr *th;
-	register u_int deltaS, deltaA;
-	register u_int changes = 0;
+	struct cstate *cs = comp->last_cs->cs_next;
+	u_int hlen = ip->ip_hl;
+	struct tcphdr *oth;
+	struct tcphdr *th;
+	u_int deltaS, deltaA;
+	u_int changes = 0;
 	u_char new_seq[16];
-	register u_char *cp = new_seq;
+	u_char *cp = new_seq;
 
 	/*
 	 * Bail if this is an IP fragment or if the TCP packet isn't
@@ -209,8 +209,8 @@
 		 * states via linear search.  If we don't find a state
 		 * for the datagram, the oldest state is (re-)used.
 		 */
-		register struct cstate *lcs;
-		register struct cstate *lastcs = comp->last_cs;
+		struct cstate *lcs;
+		struct cstate *lastcs = comp->last_cs;
 
 		do {
 			lcs = cs; cs = cs->cs_next;
@@ -475,13 +475,13 @@
 	u_char **hdrp;
 	u_int *hlenp;
 {
-	register u_char *cp;
-	register u_int hlen, changes;
-	register struct tcphdr *th;
-	register struct cstate *cs;
-	register struct ip *ip;
-	register u_int16_t *bp;
-	register u_int vjlen;
+	u_char *cp;
+	u_int hlen, changes;
+	struct tcphdr *th;
+	struct cstate *cs;
+	struct ip *ip;
+	u_int16_t *bp;
+	u_int vjlen;
 
 	switch (type) {
 
@@ -549,7 +549,7 @@
 	switch (changes & SPECIALS_MASK) {
 	case SPECIAL_I:
 		{
-		register u_int i = ntohs(cs->cs_ip.ip_len) - cs->cs_hlen;
+		u_int i = ntohs(cs->cs_ip.ip_len) - cs->cs_hlen;
 		th->th_ack = htonl(ntohl(th->th_ack) + i);
 		th->th_seq = htonl(ntohl(th->th_seq) + i);
 		}
Index: zlib.c
===================================================================
RCS file: /home/ncvs/src/sys/net/zlib.c,v
retrieving revision 1.17
diff -u -r1.17 zlib.c
--- zlib.c	2 Feb 2003 13:52:24 -0000	1.17
+++ zlib.c	11 Feb 2003 12:38:48 -0000
@@ -1272,9 +1272,9 @@
     IPos cur_match;                             /* current match */
 {
     unsigned chain_length = s->max_chain_length;/* max hash chain length */
-    register Bytef *scan = s->window + s->strstart; /* current string */
-    register Bytef *match;                       /* matched string */
-    register int len;                           /* length of current match */
+    Bytef *scan = s->window + s->strstart; /* current string */
+    Bytef *match;                       /* matched string */
+    int len;                           /* length of current match */
     int best_len = s->prev_length;              /* best match length so far */
     int nice_match = s->nice_match;             /* stop if match long enough */
     IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
@@ -1289,13 +1289,13 @@
     /* Compare two bytes at a time. Note: this is not always beneficial.
      * Try with and without -DUNALIGNED_OK to check.
      */
-    register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
-    register ush scan_start = *(ushf*)scan;
-    register ush scan_end   = *(ushf*)(scan+best_len-1);
+    Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
+    ush scan_start = *(ushf*)scan;
+    ush scan_end   = *(ushf*)(scan+best_len-1);
 #else
-    register Bytef *strend = s->window + s->strstart + MAX_MATCH;
-    register Byte scan_end1  = scan[best_len-1];
-    register Byte scan_end   = scan[best_len];
+    Bytef *strend = s->window + s->strstart + MAX_MATCH;
+    Byte scan_end1  = scan[best_len-1];
+    Byte scan_end   = scan[best_len];
 #endif
 
     /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
@@ -1447,8 +1447,8 @@
 local void fill_window(s)
     deflate_state *s;
 {
-    register unsigned n, m;
-    register Posf *p;
+    unsigned n, m;
+    Posf *p;
     unsigned more;    /* Amount of free space at the end of the window. */
     uInt wsize = s->w_size;
 
@@ -2913,7 +2913,7 @@
     unsigned code; /* the value to invert */
     int len;       /* its bit length */
 {
-    register unsigned res = 0;
+    unsigned res = 0;
     do {
         res |= code & 1;
         code >>= 1, res <<= 1;
@@ -4212,16 +4212,16 @@
   uInt f;                       /* i repeats in table every f entries */
   int g;                        /* maximum code length */
   int h;                        /* table level */
-  register uInt i;              /* counter, current code */
-  register uInt j;              /* counter */
-  register int k;               /* number of bits in current code */
+  uInt i;              /* counter, current code */
+  uInt j;              /* counter */
+  int k;               /* number of bits in current code */
   int l;                        /* bits per table (returned in m) */
-  register uIntf *p;            /* pointer into c[], b[], or v[] */
+  uIntf *p;            /* pointer into c[], b[], or v[] */
   inflate_huft *q;              /* points to current table */
   struct inflate_huft_s r;      /* table entry for structure assignment */
   inflate_huft *u[BMAX];        /* table stack */
   uInt v[N_MAX];                /* values in order of bit length */
-  register int w;               /* bits before this table == (l * h) */
+  int w;               /* bits before this table == (l * h) */
   uInt x[BMAX+1];               /* bit offsets, then code stack */
   uIntf *xp;                    /* pointer into x */
   int y;                        /* number of dummy codes added */
@@ -4551,7 +4551,7 @@
    list of the tables it made, with the links in a dummy first entry of
    each table. */
 {
-  register inflate_huft *p, *q, *r;
+  inflate_huft *p, *q, *r;
 
   /* Reverse linked list */
   p = Z_NULL;