home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / comm / tcp / amitcp-sdk / src / rpclib / xdr_float.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-29  |  5.9 KB  |  248 lines
  1. /*
  2.  *      $Id: xdr_float.c,v 4.2 1994/09/29 23:48:50 jraja Exp $
  3.  *
  4.  *      Generic XDR routines impelmentation.
  5.  *
  6.  *      Copyright © 1994 AmiTCP/IP Group,
  7.  *                       Network Solutions Development Inc.
  8.  *                       All rights reserved. 
  9.  */
  10.  
  11. /* @(#)xdr_float.c    2.1 88/07/29 4.0 RPCSRC */
  12. #if !defined(lint) && defined(SCCSIDS)
  13. static char sccsid[] = "@(#)xdr_float.c 1.12 87/08/11 Copyr 1984 Sun Micro";
  14. #endif
  15.  
  16. /*
  17.  * Copyright (C) 1984, Sun Microsystems, Inc.
  18.  *
  19.  * These are the "floating point" xdr routines used to (de)serialize
  20.  * most common data items.  See xdr.h for more info on the interface to
  21.  * xdr.
  22.  */
  23.  
  24. #include <sys/param.h>
  25. #include <stdio.h>
  26. #include <rpc/types.h>
  27. #include <rpc/xdr.h>
  28.  
  29. /*
  30.  * NB: Not portable.
  31.  * This routine works on Suns (Sky / 68000's) and Vaxen.
  32.  */
  33.  
  34. #ifdef vax
  35.  
  36. /* What IEEE single precision floating point looks like on a Vax */
  37. struct    ieee_single {
  38.     unsigned int    mantissa: 23;
  39.     unsigned int    exp     : 8;
  40.     unsigned int    sign    : 1;
  41. };
  42.  
  43. /* Vax single precision floating point */
  44. struct    vax_single {
  45.     unsigned int    mantissa1 : 7;
  46.     unsigned int    exp       : 8;
  47.     unsigned int    sign      : 1;
  48.     unsigned int    mantissa2 : 16;
  49. };
  50.  
  51. #define VAX_SNG_BIAS    0x81
  52. #define IEEE_SNG_BIAS    0x7f
  53.  
  54. static struct sgl_limits {
  55.     struct vax_single s;
  56.     struct ieee_single ieee;
  57. } sgl_limits[2] = {
  58.     {{ 0x7f, 0xff, 0x0, 0xffff },    /* Max Vax */
  59.     { 0x0, 0xff, 0x0 }},        /* Max IEEE */
  60.     {{ 0x0, 0x0, 0x0, 0x0 },    /* Min Vax */
  61.     { 0x0, 0x0, 0x0 }}        /* Min IEEE */
  62. };
  63. #endif /* vax */
  64.  
  65. bool_t XDRFUN
  66. xdr_float(xdrs, fp)
  67.     register XDR *xdrs;
  68.     register float *fp;
  69. {
  70. #if !defined(_M68000) && !defined(mc68000) && !defined(sparc)
  71.     struct ieee_single is;
  72.     struct vax_single vs, *vsp;
  73.     struct sgl_limits *lim;
  74.     int i;
  75. #endif
  76.     switch (xdrs->x_op) {
  77.  
  78.     case XDR_ENCODE:
  79. #if defined(_M68000) || defined(mc68000) || defined(sparc)
  80.         return (XDR_PUTLONG(xdrs, (long *)fp));
  81. #else
  82.         vs = *((struct vax_single *)fp);
  83.         for (i = 0, lim = sgl_limits;
  84.             i < sizeof(sgl_limits)/sizeof(struct sgl_limits);
  85.             i++, lim++) {
  86.             if ((vs.mantissa2 == lim->s.mantissa2) &&
  87.                 (vs.exp == lim->s.exp) &&
  88.                 (vs.mantissa1 == lim->s.mantissa1)) {
  89.                 is = lim->ieee;
  90.                 goto shipit;
  91.             }
  92.         }
  93.         is.exp = vs.exp - VAX_SNG_BIAS + IEEE_SNG_BIAS;
  94.         is.mantissa = (vs.mantissa1 << 16) | vs.mantissa2;
  95.     shipit:
  96.         is.sign = vs.sign;
  97.         return (XDR_PUTLONG(xdrs, (long *)&is));
  98. #endif
  99.  
  100.     case XDR_DECODE:
  101. #if defined(_M68000) || defined(mc68000) || defined(sparc)
  102.         return (XDR_GETLONG(xdrs, (long *)fp));
  103. #else
  104.         vsp = (struct vax_single *)fp;
  105.         if (!XDR_GETLONG(xdrs, (long *)&is))
  106.             return (FALSE);
  107.         for (i = 0, lim = sgl_limits;
  108.             i < sizeof(sgl_limits)/sizeof(struct sgl_limits);
  109.             i++, lim++) {
  110.             if ((is.exp == lim->ieee.exp) &&
  111.                 (is.mantissa == lim->ieee.mantissa)) {
  112.                 *vsp = lim->s;
  113.                 goto doneit;
  114.             }
  115.         }
  116.         vsp->exp = is.exp - IEEE_SNG_BIAS + VAX_SNG_BIAS;
  117.         vsp->mantissa2 = is.mantissa;
  118.         vsp->mantissa1 = (is.mantissa >> 16);
  119.     doneit:
  120.         vsp->sign = is.sign;
  121.         return (TRUE);
  122. #endif
  123.  
  124.     case XDR_FREE:
  125.         return (TRUE);
  126.     }
  127.     return (FALSE);
  128. }
  129.  
  130. /*
  131.  * This routine works on Suns (Sky / 68000's) and Vaxen.
  132.  */
  133.  
  134. #ifdef vax
  135. /* What IEEE double precision floating point looks like on a Vax */
  136. struct    ieee_double {
  137.     unsigned int    mantissa1 : 20;
  138.     unsigned int    exp       : 11;
  139.     unsigned int    sign      : 1;
  140.     unsigned int    mantissa2 : 32;
  141. };
  142.  
  143. /* Vax double precision floating point */
  144. struct  vax_double {
  145.     unsigned int    mantissa1 : 7;
  146.     unsigned int    exp       : 8;
  147.     unsigned int    sign      : 1;
  148.     unsigned int    mantissa2 : 16;
  149.     unsigned int    mantissa3 : 16;
  150.     unsigned int    mantissa4 : 16;
  151. };
  152.  
  153. #define VAX_DBL_BIAS    0x81
  154. #define IEEE_DBL_BIAS    0x3ff
  155. #define MASK(nbits)    ((1 << nbits) - 1)
  156.  
  157. static struct dbl_limits {
  158.     struct    vax_double d;
  159.     struct    ieee_double ieee;
  160. } dbl_limits[2] = {
  161.     {{ 0x7f, 0xff, 0x0, 0xffff, 0xffff, 0xffff },    /* Max Vax */
  162.     { 0x0, 0x7ff, 0x0, 0x0 }},            /* Max IEEE */
  163.     {{ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},        /* Min Vax */
  164.     { 0x0, 0x0, 0x0, 0x0 }}                /* Min IEEE */
  165. };
  166.  
  167. #endif /* vax */
  168.  
  169.  
  170. bool_t XDRFUN
  171. xdr_double(xdrs, dp)
  172.     register XDR *xdrs;
  173.     double *dp;
  174. {
  175.     register long *lp;
  176. #if !defined(_M68000) && !defined(mc68000) && !defined(sparc)
  177.     struct    ieee_double id;
  178.     struct    vax_double vd;
  179.     register struct dbl_limits *lim;
  180.     int i;
  181. #endif
  182.  
  183.     switch (xdrs->x_op) {
  184.  
  185.     case XDR_ENCODE:
  186. #if defined(_M68000) || defined(mc68000) || defined(sparc)
  187.         lp = (long *)dp;
  188. #else
  189.         vd = *((struct vax_double *)dp);
  190.         for (i = 0, lim = dbl_limits;
  191.             i < sizeof(dbl_limits)/sizeof(struct dbl_limits);
  192.             i++, lim++) {
  193.             if ((vd.mantissa4 == lim->d.mantissa4) &&
  194.                 (vd.mantissa3 == lim->d.mantissa3) &&
  195.                 (vd.mantissa2 == lim->d.mantissa2) &&
  196.                 (vd.mantissa1 == lim->d.mantissa1) &&
  197.                 (vd.exp == lim->d.exp)) {
  198.                 id = lim->ieee;
  199.                 goto shipit;
  200.             }
  201.         }
  202.         id.exp = vd.exp - VAX_DBL_BIAS + IEEE_DBL_BIAS;
  203.         id.mantissa1 = (vd.mantissa1 << 13) | (vd.mantissa2 >> 3);
  204.         id.mantissa2 = ((vd.mantissa2 & MASK(3)) << 29) |
  205.                 (vd.mantissa3 << 13) |
  206.                 ((vd.mantissa4 >> 3) & MASK(13));
  207.     shipit:
  208.         id.sign = vd.sign;
  209.         lp = (long *)&id;
  210. #endif
  211.         return (XDR_PUTLONG(xdrs, lp++) && XDR_PUTLONG(xdrs, lp));
  212.  
  213.     case XDR_DECODE:
  214. #if defined(_M68000) || defined(mc68000) || defined(sparc)
  215.         lp = (long *)dp;
  216.         return (XDR_GETLONG(xdrs, lp++) && XDR_GETLONG(xdrs, lp));
  217. #else
  218.         lp = (long *)&id;
  219.         if (!XDR_GETLONG(xdrs, lp++) || !XDR_GETLONG(xdrs, lp))
  220.             return (FALSE);
  221.         for (i = 0, lim = dbl_limits;
  222.             i < sizeof(dbl_limits)/sizeof(struct dbl_limits);
  223.             i++, lim++) {
  224.             if ((id.mantissa2 == lim->ieee.mantissa2) &&
  225.                 (id.mantissa1 == lim->ieee.mantissa1) &&
  226.                 (id.exp == lim->ieee.exp)) {
  227.                 vd = lim->d;
  228.                 goto doneit;
  229.             }
  230.         }
  231.         vd.exp = id.exp - IEEE_DBL_BIAS + VAX_DBL_BIAS;
  232.         vd.mantissa1 = (id.mantissa1 >> 13);
  233.         vd.mantissa2 = ((id.mantissa1 & MASK(13)) << 3) |
  234.                 (id.mantissa2 >> 29);
  235.         vd.mantissa3 = (id.mantissa2 >> 13);
  236.         vd.mantissa4 = (id.mantissa2 << 3);
  237.     doneit:
  238.         vd.sign = id.sign;
  239.         *dp = *((double *)&vd);
  240.         return (TRUE);
  241. #endif
  242.  
  243.     case XDR_FREE:
  244.         return (TRUE);
  245.     }
  246.     return (FALSE);
  247. }
  248.