The R Project SVN – R – Diff – /trunk/src/extra/xdr/xdr.c

  * xdr.
  */
 #include <stdlib.h>
 #include <stdio.h>
-/*char *malloc();*/
 #include <string.h> /* strlen */
+#include <stdint.h>
 #include <rpc/types.h>
 #include <rpc/xdr.h>
 /* R-specific */
 void REprintf(char*, ...);
 #define fprintf(a, b) REprintf(b)
+#ifdef UNUSED
 /*
  * constants specific to the xdr "protocol"
  */
-#define XDR_FALSE	((long) 0)
+#define XDR_FALSE	((int32_t) 0)
-#define XDR_TRUE	((long) 1)
+#define XDR_TRUE	((int32_t) 1)
 #define LASTUNSIGNED	((u_int) 0-1)
+#endif
 /*
  * for unit alignment
  */
 static char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 };
+#ifdef UNUSED
 /*
  * Free a data structure using XDR
  * Not a filter, but a convenient utility nonetheless
  */
 void
 	XDR x;
 	x.x_op = XDR_FREE;
 	(*proc)(&x, objp);
+}
+#endif
+#ifdef UNUSED
 /*
  * XDR nothing
  */
 bool_t
 xdr_void(/* xdrs, addr */)
 	/* caddr_t addr; */
+{
 	return (TRUE);
+}
+#endif
 /*
- * XDR integers
+ * XDR integers: always 32-bit in R
  */
 bool_t
 xdr_int(xdrs, ip)
 	XDR *xdrs;
 	int *ip;
+{
+//    return (xdr_long(xdrs, (int32_t *)ip));
-#ifdef lint
-	(void) (xdr_short(xdrs, (short *)ip));
+	if (xdrs->x_op == XDR_DECODE)
-	return (xdr_long(xdrs, (long *)ip));
+		return (XDR_GETLONG(xdrs, (int32_t *)ip));
-#else
-	if (sizeof (int) == sizeof (long)) {
+	if (xdrs->x_op == XDR_ENCODE)
-		return (xdr_long(xdrs, (long *)ip));
+		return (XDR_PUTLONG(xdrs, (int32_t *)ip));
-	} else {
+	if (xdrs->x_op == XDR_FREE)
-		return (xdr_short(xdrs, (short *)ip));
+		return (TRUE);
-	}
-#endif
+	return (FALSE);
+}
 /*
- * XDR unsigned integers
+ * XDR unsigned integers: always 32-bit in R
  */
 bool_t
 xdr_u_int(xdrs, up)
 	XDR *xdrs;
 	u_int *up;
+{
+//    return (xdr_u_long(xdrs, (uint32_t *)up));
+	if (xdrs->x_op == XDR_DECODE)
+		return (XDR_GETLONG(xdrs, (int32_t *)up));
+	if (xdrs->x_op == XDR_ENCODE)
+		return (XDR_PUTLONG(xdrs, (int32_t *)up));
+	if (xdrs->x_op == XDR_FREE)
+		return (TRUE);
+	return (FALSE);
-#ifdef lint
-	(void) (xdr_short(xdrs, (short *)up));
-	return (xdr_u_long(xdrs, (u_long *)up));
-#else
-	if (sizeof (u_int) == sizeof (u_long)) {
-		return (xdr_u_long(xdrs, (u_long *)up));
-	} else {
-		return (xdr_short(xdrs, (short *)up));
-	}
-#endif
+}
+#ifdef UNUSED
 /*
  * XDR long integers
  * same as xdr_u_long - open coded to save a proc call!
  */
 bool_t
 xdr_long(xdrs, lp)
 	register XDR *xdrs;
-	long *lp;
+	int32_t *lp;
+{
 	if (xdrs->x_op == XDR_ENCODE)
 		return (XDR_PUTLONG(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;
+	uint32_t *ulp;
+{
 	if (xdrs->x_op == XDR_DECODE)
-		return (XDR_GETLONG(xdrs, (long *)ulp));
+		return (XDR_GETLONG(xdrs, (int32_t *)ulp));
 	if (xdrs->x_op == XDR_ENCODE)
-		return (XDR_PUTLONG(xdrs, (long *)ulp));
+		return (XDR_PUTLONG(xdrs, (int32_t *)ulp));
 	if (xdrs->x_op == XDR_FREE)
 		return (TRUE);
 	return (FALSE);
+}
 bool_t
 xdr_short(xdrs, sp)
 	register XDR *xdrs;
 	short *sp;
+{
-	long l;
+	int32_t l;
 	switch (xdrs->x_op) {
 	case XDR_ENCODE:
-		l = (long) *sp;
+		l = (int32_t) *sp;
 		return (XDR_PUTLONG(xdrs, &l));
 	case XDR_DECODE:
 		if (!XDR_GETLONG(xdrs, &l)) {
 			return (FALSE);
 bool_t
 xdr_u_short(xdrs, usp)
 	register XDR *xdrs;
 	u_short *usp;
+{
-	u_long l;
+	uint32_t l;
 	switch (xdrs->x_op) {
 	case XDR_ENCODE:
-		l = (u_long) *usp;
+		l = (uint32_t) *usp;
 		return (XDR_PUTLONG(xdrs, &l));
 	case XDR_DECODE:
 		if (!XDR_GETLONG(xdrs, &l)) {
 			return (FALSE);
 		return (TRUE);
+	}
 	return (FALSE);
+}
 /*
  * XDR a char
  */
 bool_t
 xdr_char(xdrs, cp)
 bool_t
 xdr_bool(xdrs, bp)
 	register XDR *xdrs;
 	bool_t *bp;
+{
-	long lb;
+	int32_t lb;
 	switch (xdrs->x_op) {
 	case XDR_ENCODE:
 		lb = *bp ? XDR_TRUE : XDR_FALSE;
 	enum sizecheck { SIZEVAL };	/* used to find the size of an enum */
 	/*
 	 * enums are treated as ints
 	 */
-	if (sizeof (enum sizecheck) == sizeof (long)) {
+	if (sizeof (enum sizecheck) == sizeof (int32_t)) {
-		return (xdr_long(xdrs, (long *)ep));
+		return (xdr_long(xdrs, (int32_t *)ep));
 	} else if (sizeof (enum sizecheck) == sizeof (short)) {
 		return (xdr_short(xdrs, (short *)ep));
 	} else {
 		return (FALSE);
+	}
 #else
 	(void) (xdr_short(xdrs, (short *)ep));
-	return (xdr_long(xdrs, (long *)ep));
+	return (xdr_long(xdrs, (int32_t *)ep));
 #endif
+}
+#endif
 /*
  * XDR opaque data
  * Allows the specification of a fixed size sequence of opaque bytes.
  * cp points to the opaque object and cnt gives the byte length.
 		return (TRUE);
+	}
 	return (FALSE);
+}
+#ifdef UNUSED
 /*
  * Implemented here due to commonality of the object.
  */
 bool_t
 xdr_netobj(xdrs, np)
 	 * no match - execute the default xdr routine if there is one
 	 */
 	return ((dfault == NULL_xdrproc_t) ? FALSE :
 	    (*dfault)(xdrs, unp, LASTUNSIGNED));
+}
+#endif
 /*
  * Non-portable xdr primitives.
  * Care should be taken when moving these routines to new architectures.
  */
 		return (TRUE);
+	}
 	return (FALSE);
+}
+#ifdef UNUSED
 /*
  * Wrapper for xdr_string that can be called directly from
  * routines like clnt_call
  */
 bool_t
 	if (xdr_string(xdrs, cpp, LASTUNSIGNED)) {
 		return (TRUE);
+	}
 	return (FALSE);
+}
+#endif

The R Project SVN R

(root)/trunk/src/extra/xdr/xdr.c – Rev 38709 → 56474