Update.cvs/libc-ud-970326cvs/libc-970329cvs/libc-970328cvs/libc-970327

1997-03-27 02:28  Ulrich Drepper  <drepper@cygnus.com>

	* gmon/gmon.c (monstartup): Mark all messages.
	(write_call_graph): Rewrite to use larger I/O vector for writev
	call to reduce syscall overhead.
	(write_bb_counts): Simplify writev handling.

	* inet/rexec.c: Make string parameters `const'.
	* resolv/netdb.h: Add prototypes for rcmd, rexec, ruserok, and
	rresvport.

	* math/Makefile: Don't define CFLAGS-* macros to prevent inlining
	in libm-test.
	* math/libm-test.c (this_does_nothing): Remove functions.  It's
	notuseful on any platform but ix86.
	(inverse_func_pair_test): Don't use this_does_nothing.  Use
	memory reference.
	(identities1_test): Likewise.
	(identities2_test): Likewise.
	(identities3_test): Likewise.
	(basic_test): Likewise.
	Patch by Andreas Schwab.
	(BUILD_COMPLEX): New macro.  Create complex number from real and
	imaginary parts.  This works around bugs/inefficiencies in current
	gcc.
	(cexp_test): Use BUILD_COMPLEX.  Add more tests.

	* nss/nsswitch.c: Fix typo.

	* posix/glob.h: Add declaration for glob_pattern_p.
	* posix/glob.c: Rename glob_pattern_p to __glob_pattern_p and
	make glob_pattern_p a weak alias.  This function is used in other
	packages (e.g. bash).

	* signal/Makefile (routines): Add sigisempty, sigandset, and
	sigorset.
	* signal/signal.h: Add prototypes for sigisempty, sigandset, and
	sigorset.
	* signal/sigisempty.c: New file.
	* signal/sigandset.c: New file.
	* signal/sigorset.c: New file.
	* sysdeps/generic/sigset.h: Define __sigisemptyset, __sigandset,
	and __sigorset.
	* sysdeps/unix/sysv/linux/sigset.h: Likewise.

	* stdlib/strtod.c: Handle `n-char-sequence' in NaN parsing.  It
	determines the bits in the mantissa part of the NaN.
	* stdlib/strtof.c: Define SET_MANTISSA for float type.
	* wcsmbs/wcstof.c: Define SET_MANTISSA for float type.
	* stdlib/strtold.c: Define SET_MANTISSA for long double type.
	* wcsmbs/wcstold.c: Define SET_MANTISSA for long double type.

	* sysdeps/libm-ieee754/s_cexp.c: Use explicit assignment to
	complex number components.  Some more corrects for special cases.
	* sysdeps/libm-ieee754/s_cexpf.c: Likewise.
	* sysdeps/libm-ieee754/s_cexpl.c: Likewise.

	* sysdeps/sparc/elf/start.S: Remove as per request of Miguel de Icaza.

	* sysdeps/unix/sysv/linux/netinet/icmp.h: Remove since we have
	ip_icmp.h.  Reported by HJ Lu.

1997-03-25 03:50  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* sysdeps/m68k/Makefile (CFLAGS-rtld.c): Add -Wno-unused.

	* sysdeps/m68k/dl-machine.h (elf_machine_rela): Rewritten as for
	i386.
	(elf_machine_lookup_noexec_p, elf_machine_lookup_noplt_p,
	ELF_MACHINE_RELOC_NOPLT): Define.

1997-03-25 03:48  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* grp/grp.h: Include <stddef.h> only once.

1997-03-25 09:38  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* sysdeps/unix/sysv/linux/termbits.h (OXTABS): Don't define.
	* sysdeps/unix/sysv/linux/alpha/termbits.h (OXTABS): Likewise.

	* termios/sys/ttydefaults.h (TTYDEF_OFLAG): Use either OXTABS or
	TAB3, if one of them is defined.

1997-03-26 04:53  Ulrich Drepper  <drepper@cygnus.com>

	* posix/glob.c (next_brace_sub): Decrement depth counter when '}'
	is found.
	Patch by Dennis Henriksen <opus@flamingo.osrl.dk>.

1997-03-25  16:25  Thorsten Kukuk  <kukuk@vt.uni-paderborn.de>

	* sunrpc/Makefile: Comment gccwarn out.
	* sunrpc/auth_none.c: Fix prototypes and parameters for compiling
	with enabled warnings.
	* sunrpc/auth_unix.c: Likewise.
	* sunrpc/authuxprot.c: Likewise.
	* sunrpc/bindrsvprt.c: Likewise.
	* sunrpc/clnt_gen.c: Likewise.
	* sunrpc/clnt_perr.c: Likewise.
	* sunrpc/clnt_raw.c: Likewise.
	* sunrpc/clnt_simp.c: Likewise.
	* sunrpc/clnt_tcp.c: Likewise.
	* sunrpc/clnt_udp.c: Likewise.
	* sunrpc/get_myaddr.c: Likewise.
	* sunrpc/getrpcport.c: Likewise.
	* sunrpc/pm_getmaps.c: Likewise.
	* sunrpc/pm_getport.c: Likewise.
	* sunrpc/pmap_clnt.c: Likewise.
	* sunrpc/pmap_prot.c: Likewise.
	* sunrpc/pmap_prot2.c: Likewise.
	* sunrpc/pmap_rmt.c: Likewise.
	* sunrpc/rpc/auth.h: Likewise.
	* sunrpc/rpc/clnt.h: Likewise.
	* sunrpc/rpc/pmap_clnt.h: Likewise.
	* sunrpc/rpc/svc.h: Likewise.
	* sunrpc/rpc/svc_auth.h: Likewise.
	* sunrpc/rpc/types.h: Likewise.
	* sunrpc/rpc/xdr.h: Likewise.
	* sunrpc/rpc_clntout.c: Likewise.
	* sunrpc/rpc_cmsg.c: Likewise.
	* sunrpc/rpc_dtable.c: Likewise.
	* sunrpc/rpc_prot.c: Likewise.
	* sunrpc/svc.c: Likewise.
	* sunrpc/svc_auth.c: Likewise.
	* sunrpc/svc_authux.c: Likewise.
	* sunrpc/svc_raw.c: Likewise.
	* sunrpc/svc_run.c: Likewise.
	* sunrpc/svc_simple.c: Likewise.
	* sunrpc/svc_tcp.c: Likewise.
	* sunrpc/svc_udp.c: Likewise.
	* sunrpc/xdr.c: Likewise.
	* sunrpc/xdr_array.c: Likewise.
	* sunrpc/xdr_mem.c: Likewise.
	* sunrpc/xdr_rec.c: Likewise.
	* sunrpc/xdr_ref.c: Likewise.
	* sunrpc/xdr_stdio.c: Likewise.

1997-03-25 13:39  Ulrich Drepper  <drepper@cygnus.com>

	* math/libm-test.c (log2_test): Compile this function and call it.
	(exp2_test): Likewise, but check whether function really exists
	before testing.

	* math/Makefile (libm-calls): Add s_log2 and s_exp2.

1997-03-25 04:50  Ulrich Drepper  <drepper@cygnus.com>

	Implement exp2 function.
	* sysdeps/libm-i387/s_exp2.S: New file.
	* sysdeps/libm-i387/s_exp2f.S: New file.
	* sysdeps/libm-i387/s_exp2l.S: New file.

	Implement log2 function.
	* sysdeps/libm-i387/s_log2.S: New file.
	* sysdeps/libm-i387/s_log2f.S: New file.
	* sysdeps/libm-i387/s_log2l.S: New file.
	* sysdeps/libm-ieee754/s_log2.c: New file.
	* sysdeps/libm-ieee754/s_log2f.c: New file.
	* sysdeps/stub/s_log2.c: New file.  Stub version.

1 files changed, 431 insertions, 388 deletions

diff --git a/sunrpc/xdr.c b/sunrpc/xdr.c
index 969fa6b..d666119 100644
--- a/sunrpc/xdr.c
+++ b/sunrpc/xdr.c
@@ -57,72 +57,72 @@ static char sccsid[] = "@(#)xdr.c 1.35 87/08/12";
 /*
  * for unit alignment
  */
-static char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 };
+static const char xdr_zero[BYTES_PER_XDR_UNIT] =
+{0, 0, 0, 0};
 
 /*
  * Free a data structure using XDR
  * Not a filter, but a convenient utility nonetheless
  */
 void
-xdr_free(proc, objp)
-	xdrproc_t proc;
-	char *objp;
+xdr_free (proc, objp)
+     xdrproc_t proc;
+     char *objp;
 {
-	XDR x;
+  XDR x;
 
-	x.x_op = XDR_FREE;
-	(*proc)(&x, objp);
+  x.x_op = XDR_FREE;
+  (*proc) (&x, objp);
 }
 
 /*
  * XDR nothing
  */
 bool_t
-xdr_void(/* xdrs, addr */)
-	/* XDR *xdrs; */
-	/* caddr_t addr; */
+xdr_void (void)
 {
-
-	return (TRUE);
+  return TRUE;
 }
 
 /*
  * XDR integers
  */
 bool_t
-xdr_int(xdrs, ip)
-	XDR *xdrs;
-	int *ip;
+xdr_int (xdrs, ip)
+     XDR *xdrs;
+     int *ip;
 {
 
 #ifdef lint
-	(void) (xdr_short(xdrs, (short *)ip));
-	return (xdr_long(xdrs, (long *)ip));
+  (void) (xdr_short (xdrs, (short *) ip));
+  return (xdr_long (xdrs, (long *) ip));
 #else
-# if INT_MAX < LONG_MAX
-	long l;
-
-	switch (xdrs->x_op) {
-	      case XDR_ENCODE:
-		l = (long) *ip;
-		return XDR_PUTLONG(xdrs, &l);
-
-	      case XDR_DECODE:
-		if (!XDR_GETLONG(xdrs, &l)) {
-			return FALSE;
-		}
-		*ip = (int) l;
-	      case XDR_FREE:
-		return TRUE;
+#if INT_MAX < LONG_MAX
+  long l;
+
+  switch (xdrs->x_op)
+    {
+    case XDR_ENCODE:
+      l = (long) *ip;
+      return XDR_PUTLONG (xdrs, &l);
+
+    case XDR_DECODE:
+      if (!XDR_GETLONG (xdrs, &l))
+	{
+	  return FALSE;
 	}
-	return FALSE;
-# elif INT_MAX == LONG_MAX
-	return xdr_long(xdrs, (long *)ip);
-# elif INT_MAX == SHRT_MAX
-	return xdr_short(xdrs, (short *)ip);
-# else
-#	error unexpected integer sizes in_xdr_int()
-# endif
+      *ip = (int) l;
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
+#elif INT_MAX == LONG_MAX
+  return xdr_long (xdrs, (long *) ip);
+#elif INT_MAX == SHRT_MAX
+  return xdr_short (xdrs, (short *) ip);
+#else
+#error unexpected integer sizes in_xdr_int()
+#endif
 #endif
 }
 
@@ -130,38 +130,40 @@ xdr_int(xdrs, ip)
  * XDR unsigned integers
  */
 bool_t
-xdr_u_int(xdrs, up)
-	XDR *xdrs;
-	u_int *up;
+xdr_u_int (xdrs, up)
+     XDR *xdrs;
+     u_int *up;
 {
 #ifdef lint
-	(void) (xdr_short(xdrs, (short *)up));
-	return (xdr_u_long(xdrs, (u_long *)up));
+  (void) (xdr_short (xdrs, (short *) up));
+  return (xdr_u_long (xdrs, (u_long *) up));
 #else
-# if UINT_MAX < ULONG_MAX
-	u_long l;
-
-	switch (xdrs->x_op) {
-	      case XDR_ENCODE:
-		l = (u_long) *up;
-		return XDR_PUTLONG(xdrs, &l);
-
-	      case XDR_DECODE:
-		if (!XDR_GETLONG(xdrs, &l)) {
-			return FALSE;
-		}
-		*up = (u_int) l;
-	      case XDR_FREE:
-		return TRUE;
+#if UINT_MAX < ULONG_MAX
+  u_long l;
+
+  switch (xdrs->x_op)
+    {
+    case XDR_ENCODE:
+      l = (u_long) * up;
+      return XDR_PUTLONG (xdrs, &l);
+
+    case XDR_DECODE:
+      if (!XDR_GETLONG (xdrs, &l))
+	{
+	  return FALSE;
 	}
-	return FALSE;
-# elif UINT_MAX == ULONG_MAX
-	return xdr_u_long(xdrs, (u_long *)up);
-# elif UINT_MAX == USHRT_MAX
-	return xdr_short(xdrs, (short *)up);
-# else
-#	error unexpected integer sizes in_xdr_u_int()
-# endif
+      *up = (u_int) l;
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
+#elif UINT_MAX == ULONG_MAX
+  return xdr_u_long (xdrs, (u_long *) up);
+#elif UINT_MAX == USHRT_MAX
+  return xdr_short (xdrs, (short *) up);
+#else
+#error unexpected integer sizes in_xdr_u_int()
+#endif
 #endif
 }
 
@@ -170,21 +172,21 @@ xdr_u_int(xdrs, up)
  * same as xdr_u_long - open coded to save a proc call!
  */
 bool_t
-xdr_long(xdrs, lp)
-	register XDR *xdrs;
-	long *lp;
+xdr_long (xdrs, lp)
+     XDR *xdrs;
+     long *lp;
 {
 
-	if (xdrs->x_op == XDR_ENCODE)
-		return (XDR_PUTLONG(xdrs, lp));
+  if (xdrs->x_op == XDR_ENCODE)
+    return XDR_PUTLONG (xdrs, lp);
 
-	if (xdrs->x_op == XDR_DECODE)
-		return (XDR_GETLONG(xdrs, lp));
+  if (xdrs->x_op == XDR_DECODE)
+    return XDR_GETLONG (xdrs, lp);
 
-	if (xdrs->x_op == XDR_FREE)
-		return (TRUE);
+  if (xdrs->x_op == XDR_FREE)
+    return TRUE;
 
-	return (FALSE);
+  return FALSE;
 }
 
 /*
@@ -192,77 +194,82 @@ xdr_long(xdrs, lp)
  * same as xdr_long - open coded to save a proc call!
  */
 bool_t
-xdr_u_long(xdrs, ulp)
-	register XDR *xdrs;
-	u_long *ulp;
+xdr_u_long (xdrs, ulp)
+     XDR *xdrs;
+     u_long *ulp;
 {
-	switch (xdrs->x_op) {
-	      case XDR_DECODE:
-		return XDR_GETLONG(xdrs, (long *)ulp);
-
-	      case XDR_ENCODE:
-		return XDR_PUTLONG(xdrs, (long *)ulp);
-
-	      case XDR_FREE:
-		return TRUE;
-	}
-	return FALSE;
+  switch (xdrs->x_op)
+    {
+    case XDR_DECODE:
+      return XDR_GETLONG (xdrs, (long *) ulp);
+
+    case XDR_ENCODE:
+      return XDR_PUTLONG (xdrs, (long *) ulp);
+
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
 }
 
 /*
  * XDR short integers
  */
 bool_t
-xdr_short(xdrs, sp)
-	register XDR *xdrs;
-	short *sp;
+xdr_short (xdrs, sp)
+     XDR *xdrs;
+     short *sp;
 {
-	long l;
-
-	switch (xdrs->x_op) {
-	      case XDR_ENCODE:
-		l = (long) *sp;
-		return XDR_PUTLONG(xdrs, &l);
-
-	      case XDR_DECODE:
-		if (!XDR_GETLONG(xdrs, &l)) {
-			return FALSE;
-		}
-		*sp = (short) l;
-		return TRUE;
-
-	      case XDR_FREE:
-		return TRUE;
+  long l;
+
+  switch (xdrs->x_op)
+    {
+    case XDR_ENCODE:
+      l = (long) *sp;
+      return XDR_PUTLONG (xdrs, &l);
+
+    case XDR_DECODE:
+      if (!XDR_GETLONG (xdrs, &l))
+	{
+	  return FALSE;
 	}
-	return FALSE;
+      *sp = (short) l;
+      return TRUE;
+
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
 }
 
 /*
  * XDR unsigned short integers
  */
 bool_t
-xdr_u_short(xdrs, usp)
-	register XDR *xdrs;
-	u_short *usp;
+xdr_u_short (xdrs, usp)
+     XDR *xdrs;
+     u_short *usp;
 {
-	u_long l;
-
-	switch (xdrs->x_op) {
-	      case XDR_ENCODE:
-		l = (u_long) *usp;
-		return XDR_PUTLONG(xdrs, &l);
-
-	      case XDR_DECODE:
-		if (!XDR_GETLONG(xdrs, &l)) {
-			return FALSE;
-		}
-		*usp = (u_short) l;
-		return TRUE;
-
-	      case XDR_FREE:
-		return TRUE;
+  u_long l;
+
+  switch (xdrs->x_op)
+    {
+    case XDR_ENCODE:
+      l = (u_long) * usp;
+      return XDR_PUTLONG (xdrs, &l);
+
+    case XDR_DECODE:
+      if (!XDR_GETLONG (xdrs, &l))
+	{
+	  return FALSE;
 	}
-	return FALSE;
+      *usp = (u_short) l;
+      return TRUE;
+
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
 }
 
 
@@ -270,110 +277,124 @@ xdr_u_short(xdrs, usp)
  * XDR a char
  */
 bool_t
-xdr_char(xdrs, cp)
-	XDR *xdrs;
-	char *cp;
+xdr_char (xdrs, cp)
+     XDR *xdrs;
+     char *cp;
 {
-	int i;
-
-	i = (*cp);
-	if (!xdr_int(xdrs, &i)) {
-		return FALSE;
-	}
-	*cp = i;
-	return TRUE;
+  int i;
+
+  i = (*cp);
+  if (!xdr_int (xdrs, &i))
+    {
+      return FALSE;
+    }
+  *cp = i;
+  return TRUE;
 }
 
 /*
  * XDR an unsigned char
  */
 bool_t
-xdr_u_char(xdrs, cp)
-	XDR *xdrs;
-	u_char *cp;
+xdr_u_char (xdrs, cp)
+     XDR *xdrs;
+     u_char *cp;
 {
-	u_int u;
-
-	u = (*cp);
-	if (!xdr_u_int(xdrs, &u)) {
-		return FALSE;
-	}
-	*cp = u;
-	return TRUE;
+  u_int u;
+
+  u = (*cp);
+  if (!xdr_u_int (xdrs, &u))
+    {
+      return FALSE;
+    }
+  *cp = u;
+  return TRUE;
 }
 
 /*
  * XDR booleans
  */
 bool_t
-xdr_bool(xdrs, bp)
-	register XDR *xdrs;
-	bool_t *bp;
+xdr_bool (xdrs, bp)
+     XDR *xdrs;
+     bool_t *bp;
 {
-	long lb;
-
-	switch (xdrs->x_op) {
-	      case XDR_ENCODE:
-		lb = *bp ? XDR_TRUE : XDR_FALSE;
-		return XDR_PUTLONG(xdrs, &lb);
-
-	      case XDR_DECODE:
-		if (!XDR_GETLONG(xdrs, &lb)) {
-			return FALSE;
-		}
-		*bp = (lb == XDR_FALSE) ? FALSE : TRUE;
-		return TRUE;
-
-	      case XDR_FREE:
-		return TRUE;
+  long lb;
+
+  switch (xdrs->x_op)
+    {
+    case XDR_ENCODE:
+      lb = *bp ? XDR_TRUE : XDR_FALSE;
+      return XDR_PUTLONG (xdrs, &lb);
+
+    case XDR_DECODE:
+      if (!XDR_GETLONG (xdrs, &lb))
+	{
+	  return FALSE;
 	}
-	return FALSE;
+      *bp = (lb == XDR_FALSE) ? FALSE : TRUE;
+      return TRUE;
+
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
 }
 
 /*
  * XDR enumerations
  */
 bool_t
-xdr_enum(xdrs, ep)
-	XDR *xdrs;
-	enum_t *ep;
+xdr_enum (xdrs, ep)
+     XDR *xdrs;
+     enum_t *ep;
 {
 #ifndef lint
-	enum sizecheck { SIZEVAL };	/* used to find the size of an enum */
-
-	/*
-	 * enums are treated as ints
-	 */
-	if (sizeof (enum sizecheck) == 4) {
-# if INT_MAX < LONG_MAX
-		long l;
-
-		switch (xdrs->x_op) {
-		      case XDR_ENCODE:
-			l = *ep;
-			return XDR_PUTLONG(xdrs, &l);
-
-		      case XDR_DECODE:
-			if (!XDR_GETLONG(xdrs, &l)) {
-				return FALSE;
-			}
-			*ep = l;
-		      case XDR_FREE:
-			return TRUE;
-
-		}
-		return FALSE;
-# else
-		return (xdr_long(xdrs, (long *)ep));
-# endif
-	} else if (sizeof (enum sizecheck) == sizeof (short)) {
-		return xdr_short(xdrs, (short *)ep);
-	} else {
-		return FALSE;
+  enum sizecheck
+    {
+      SIZEVAL
+    };				/* used to find the size of an enum */
+
+  /*
+   * enums are treated as ints
+   */
+  if (sizeof (enum sizecheck) == 4)
+    {
+#if INT_MAX < LONG_MAX
+      long l;
+
+      switch (xdrs->x_op)
+	{
+	case XDR_ENCODE:
+	  l = *ep;
+	  return XDR_PUTLONG (xdrs, &l);
+
+	case XDR_DECODE:
+	  if (!XDR_GETLONG (xdrs, &l))
+	    {
+	      return FALSE;
+	    }
+	  *ep = l;
+	case XDR_FREE:
+	  return TRUE;
+
 	}
+      return FALSE;
+#else
+      return xdr_long (xdrs, (long *) ep);
+#endif
+    }
+  else if (sizeof (enum sizecheck) == sizeof (short))
+    {
+      return xdr_short (xdrs, (short *) ep);
+    }
+  else
+    {
+      return FALSE;
+    }
 #else /* lint */
-	(void) (xdr_short(xdrs, (short *)ep));
-	return (xdr_long(xdrs, (long *)ep));
+  (void) (xdr_short (xdrs, (short *) ep));
+  return xdr_long (xdrs, (long *) ep);
 #endif /* lint */
 }
 
@@ -383,48 +404,51 @@ xdr_enum(xdrs, ep)
  * cp points to the opaque object and cnt gives the byte length.
  */
 bool_t
-xdr_opaque(xdrs, cp, cnt)
-	register XDR *xdrs;
-	caddr_t cp;
-	register u_int cnt;
+xdr_opaque (xdrs, cp, cnt)
+     XDR *xdrs;
+     caddr_t cp;
+     u_int cnt;
 {
-	register u_int rndup;
-	static crud[BYTES_PER_XDR_UNIT];
-
-	/*
-	 * if no data we are done
-	 */
-	if (cnt == 0)
-		return TRUE;
-
-	/*
-	 * round byte count to full xdr units
-	 */
-	rndup = cnt % BYTES_PER_XDR_UNIT;
-	if (rndup > 0)
-		rndup = BYTES_PER_XDR_UNIT - rndup;
-
-	switch (xdrs->x_op) {
-	      case XDR_DECODE:
-		if (!XDR_GETBYTES(xdrs, cp, cnt)) {
-			return FALSE;
-		}
-		if (rndup == 0)
-			return TRUE;
-		return XDR_GETBYTES(xdrs, crud, rndup);
-
-	      case XDR_ENCODE:
-		if (!XDR_PUTBYTES(xdrs, cp, cnt)) {
-			return FALSE;
-		}
-		if (rndup == 0)
-			return TRUE;
-		return XDR_PUTBYTES(xdrs, xdr_zero, rndup);
-
-	      case XDR_FREE:
-		return TRUE;
+  u_int rndup;
+  static char crud[BYTES_PER_XDR_UNIT];
+
+  /*
+   * if no data we are done
+   */
+  if (cnt == 0)
+    return TRUE;
+
+  /*
+   * round byte count to full xdr units
+   */
+  rndup = cnt % BYTES_PER_XDR_UNIT;
+  if (rndup > 0)
+    rndup = BYTES_PER_XDR_UNIT - rndup;
+
+  switch (xdrs->x_op)
+    {
+    case XDR_DECODE:
+      if (!XDR_GETBYTES (xdrs, cp, cnt))
+	{
+	  return FALSE;
 	}
-	return FALSE;
+      if (rndup == 0)
+	return TRUE;
+      return XDR_GETBYTES (xdrs, (caddr_t)crud, rndup);
+
+    case XDR_ENCODE:
+      if (!XDR_PUTBYTES (xdrs, cp, cnt))
+	{
+	  return FALSE;
+	}
+      if (rndup == 0)
+	return TRUE;
+      return XDR_PUTBYTES (xdrs, xdr_zero, rndup);
+
+    case XDR_FREE:
+      return TRUE;
+    }
+  return FALSE;
 }
 
 /*
@@ -433,66 +457,73 @@ xdr_opaque(xdrs, cp, cnt)
  * If *cpp is NULL maxsize bytes are allocated
  */
 bool_t
-xdr_bytes(xdrs, cpp, sizep, maxsize)
-	register XDR *xdrs;
-	char **cpp;
-	register u_int *sizep;
-	u_int maxsize;
+xdr_bytes (xdrs, cpp, sizep, maxsize)
+     XDR *xdrs;
+     char **cpp;
+     u_int *sizep;
+     u_int maxsize;
 {
-	register char *sp = *cpp;  /* sp is the actual string pointer */
-	register u_int nodesize;
-
-	/*
-	 * first deal with the length since xdr bytes are counted
-	 */
-	if (! xdr_u_int(xdrs, sizep)) {
-		return FALSE;
+  char *sp = *cpp;	/* sp is the actual string pointer */
+  u_int nodesize;
+
+  /*
+   * first deal with the length since xdr bytes are counted
+   */
+  if (!xdr_u_int (xdrs, sizep))
+    {
+      return FALSE;
+    }
+  nodesize = *sizep;
+  if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE))
+    {
+      return FALSE;
+    }
+
+  /*
+   * now deal with the actual bytes
+   */
+  switch (xdrs->x_op)
+    {
+    case XDR_DECODE:
+      if (nodesize == 0)
+	{
+	  return TRUE;
+	}
+      if (sp == NULL)
+	{
+	  *cpp = sp = (char *) mem_alloc (nodesize);
 	}
-	nodesize = *sizep;
-	if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE)) {
-		return FALSE;
+      if (sp == NULL)
+	{
+	  (void) fprintf (stderr, "xdr_bytes: out of memory\n");
+	  return FALSE;
 	}
+      /* fall into ... */
 
-	/*
-	 * now deal with the actual bytes
-	 */
-	switch (xdrs->x_op) {
-	      case XDR_DECODE:
-		if (nodesize == 0) {
-			return TRUE;
-		}
-		if (sp == NULL) {
-			*cpp = sp = (char *)mem_alloc(nodesize);
-		}
-		if (sp == NULL) {
-			(void) fprintf(stderr, "xdr_bytes: out of memory\n");
-			return FALSE;
-		}
-		/* fall into ... */
-
-	      case XDR_ENCODE:
-		return xdr_opaque(xdrs, sp, nodesize);
-
-	      case XDR_FREE:
-		if (sp != NULL) {
-			mem_free(sp, nodesize);
-			*cpp = NULL;
-		}
-		return TRUE;
+    case XDR_ENCODE:
+      return xdr_opaque (xdrs, sp, nodesize);
+
+    case XDR_FREE:
+      if (sp != NULL)
+	{
+	  mem_free (sp, nodesize);
+	  *cpp = NULL;
 	}
-	return FALSE;
+      return TRUE;
+    }
+  return FALSE;
 }
 
 /*
  * Implemented here due to commonality of the object.
  */
 bool_t
-xdr_netobj(xdrs, np)
-	XDR *xdrs;
-	struct netobj *np;
+xdr_netobj (xdrs, np)
+     XDR *xdrs;
+     struct netobj *np;
 {
 
-	return xdr_bytes(xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ);
+  return xdr_bytes (xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ);
 }
 
 /*
@@ -507,37 +538,39 @@ xdr_netobj(xdrs, np)
  * If there is no specific or default routine an error is returned.
  */
 bool_t
-xdr_union(xdrs, dscmp, unp, choices, dfault)
-	register XDR *xdrs;
-	enum_t *dscmp;		/* enum to decide which arm to work on */
-	char *unp;		/* the union itself */
-	struct xdr_discrim *choices;	/* [value, xdr proc] for each arm */
-	xdrproc_t dfault;	/* default xdr routine */
+xdr_union (xdrs, dscmp, unp, choices, dfault)
+     XDR *xdrs;
+     enum_t *dscmp;		/* enum to decide which arm to work on */
+     char *unp;			/* the union itself */
+     const struct xdr_discrim *choices;	/* [value, xdr proc] for each arm */
+     xdrproc_t dfault;		/* default xdr routine */
 {
-	register enum_t dscm;
-
-	/*
-	 * we deal with the discriminator;  it's an enum
-	 */
-	if (! xdr_enum(xdrs, dscmp)) {
-		return FALSE;
-	}
-	dscm = *dscmp;
-
-	/*
-	 * search choices for a value that matches the discriminator.
-	 * if we find one, execute the xdr routine for that value.
-	 */
-	for (; choices->proc != NULL_xdrproc_t; choices++) {
-		if (choices->value == dscm)
-			return (*(choices->proc))(xdrs, unp, LASTUNSIGNED);
-	}
-
-	/*
-	 * no match - execute the default xdr routine if there is one
-	 */
-	return ((dfault == NULL_xdrproc_t) ? FALSE :
-	    (*dfault)(xdrs, unp, LASTUNSIGNED));
+  enum_t dscm;
+
+  /*
+   * we deal with the discriminator;  it's an enum
+   */
+  if (!xdr_enum (xdrs, dscmp))
+    {
+      return FALSE;
+    }
+  dscm = *dscmp;
+
+  /*
+   * search choices for a value that matches the discriminator.
+   * if we find one, execute the xdr routine for that value.
+   */
+  for (; choices->proc != NULL_xdrproc_t; choices++)
+    {
+      if (choices->value == dscm)
+	return (*(choices->proc)) (xdrs, unp, LASTUNSIGNED);
+    }
+
+  /*
+   * no match - execute the default xdr routine if there is one
+   */
+  return ((dfault == NULL_xdrproc_t) ? FALSE :
+	  (*dfault) (xdrs, unp, LASTUNSIGNED));
 }
 
 
@@ -556,64 +589,73 @@ xdr_union(xdrs, dscmp, unp, choices, dfault)
  * of the string as specified by a protocol.
  */
 bool_t
-xdr_string(xdrs, cpp, maxsize)
-	register XDR *xdrs;
-	char **cpp;
-	u_int maxsize;
+xdr_string (xdrs, cpp, maxsize)
+     XDR *xdrs;
+     char **cpp;
+     u_int maxsize;
 {
-	register char *sp = *cpp;  /* sp is the actual string pointer */
-	u_int size;
-	u_int nodesize;
-
-	/*
-	 * first deal with the length since xdr strings are counted-strings
-	 */
-	switch (xdrs->x_op) {
-	      case XDR_FREE:
-		if (sp == NULL) {
-			return TRUE;	/* already free */
-		}
-		/* fall through... */
-	      case XDR_ENCODE:
-		if (sp == NULL)
-		  	return FALSE;
-		size = strlen(sp);
-		break;
+  char *sp = *cpp;	/* sp is the actual string pointer */
+  u_int size;
+  u_int nodesize;
+
+  /*
+   * first deal with the length since xdr strings are counted-strings
+   */
+  switch (xdrs->x_op)
+    {
+    case XDR_FREE:
+      if (sp == NULL)
+	{
+	  return TRUE;		/* already free */
 	}
-	if (! xdr_u_int(xdrs, &size)) {
-		return FALSE;
-	}
-	if (size > maxsize) {
-		return FALSE;
+      /* fall through... */
+    case XDR_ENCODE:
+      if (sp == NULL)
+	return FALSE;
+      size = strlen (sp);
+      break;
+    case XDR_DECODE:
+      break;
+    }
+  if (!xdr_u_int (xdrs, &size))
+    {
+      return FALSE;
+    }
+  if (size > maxsize)
+    {
+      return FALSE;
+    }
+  nodesize = size + 1;
+
+  /*
+   * now deal with the actual bytes
+   */
+  switch (xdrs->x_op)
+    {
+    case XDR_DECODE:
+      if (nodesize == 0)
+	{
+	  return TRUE;
 	}
-	nodesize = size + 1;
-
-	/*
-	 * now deal with the actual bytes
-	 */
-	switch (xdrs->x_op) {
-	      case XDR_DECODE:
-		if (nodesize == 0) {
-			return TRUE;
-		}
-		if (sp == NULL)
-			*cpp = sp = (char *)mem_alloc(nodesize);
-		if (sp == NULL) {
-			(void) fprintf(stderr, "xdr_string: out of memory\n");
-			return FALSE;
-		}
-		sp[size] = 0;
-		/* fall into ... */
-
-	      case XDR_ENCODE:
-		return xdr_opaque(xdrs, sp, size);
-
-	      case XDR_FREE:
-		mem_free(sp, nodesize);
-		*cpp = NULL;
-		return TRUE;
+      if (sp == NULL)
+	*cpp = sp = (char *) mem_alloc (nodesize);
+      if (sp == NULL)
+	{
+	  (void) fprintf (stderr, "xdr_string: out of memory\n");
+	  return FALSE;
 	}
-	return FALSE;
+      sp[size] = 0;
+      /* fall into ... */
+
+    case XDR_ENCODE:
+      return xdr_opaque (xdrs, sp, size);
+
+    case XDR_FREE:
+      mem_free (sp, nodesize);
+      *cpp = NULL;
+      return TRUE;
+    }
+  return FALSE;
 }
 
 /*
@@ -621,12 +663,13 @@ xdr_string(xdrs, cpp, maxsize)
  * routines like clnt_call
  */
 bool_t
-xdr_wrapstring(xdrs, cpp)
-	XDR *xdrs;
-	char **cpp;
+xdr_wrapstring (xdrs, cpp)
+     XDR *xdrs;
+     char **cpp;
 {
-	if (xdr_string(xdrs, cpp, LASTUNSIGNED)) {
-		return TRUE;
-	}
-	return FALSE;
+  if (xdr_string (xdrs, cpp, LASTUNSIGNED))
+    {
+      return TRUE;
+    }
+  return FALSE;
 }