cde/lib/tt/mini_isam/isdatconv.c

   1 /*%%  (c) Copyright 1993, 1994 Hewlett-Packard Company                   */
   2 /*%%  (c) Copyright 1993, 1994 International Business Machines Corp.     */
   3 /*%%  (c) Copyright 1993, 1994 Sun Microsystems, Inc.                    */
   4 /*%%  (c) Copyright 1993, 1994 Novell, Inc.                              */
   5 /*%%  $XConsortium: isdatconv.c /main/3 1995/10/23 11:37:16 rswiston $                                                   */
   6 #ifndef lint
   7 static char sccsid[] = "@(#)isdatconv.c 1.5 89/07/17 Copyr 1988 Sun Micro";
   8 #endif
   9 /*
  10  * Copyright (c) 1988 by Sun Microsystems, Inc.
  11  */
  12
  13 /*
  14  * isdatconv.c
  15  *
  16  * Description:
  17  *      Conversion function between machine dependent and the X/OPEN
  18  *      machine independent formats.
  19  *
  20  * Some pieces of code may not be very "structured", but they result in
  21  * optimized code with the -O compiler option.
  22  *
  23  */
  24
  25 #include "isam_impl.h"
  26
  27 #define BLANK   ' '
  28
  29 /* conversion functions for sparc architecture */
  30
  31 /* ldlong() - Load a long integer from a potentially  unaligned address */
  32
  33 long
  34 ldlong(p)
  35     register char       *p;
  36 {
  37     int i;
  38 #if LONG_BIT == 64
  39     register unsigned long val;
  40 #else
  41     register unsigned int val;
  42 #endif
  43
  44     val = 0;
  45     for (i=0; i<LONGSIZE ; i++)
  46         val = (val << 8) + *((unsigned char *)p++);
  47
  48     return ((long)val);
  49 }
  50
  51 /* stlong() - Store a long integer at a potentially unaligned address */
  52
  53 int
  54 stlong(val, p)
  55     register long       val;
  56     register char       *p;
  57 {
  58     int i;
  59     p += LONGSIZE;
  60
  61     for (i=0; i<LONGSIZE ; i++)
  62         *--p = (val >> 8*i) & 255;
  63
  64     return(0);
  65 }
  66
  67 /* ldint() - Load a short integer from a potentially  unaligned address */
  68
  69 short
  70 ldint(p)
  71     register char       *p;
  72 {
  73     register unsigned int val;
  74
  75     val = *((unsigned char *)p++);
  76     val = (val << 8) + *((unsigned char *)p++);
  77
  78     return ((short)val);
  79 }
  80
  81
  82 /* ldunshort - load a unshort integer : for 64K record length */
  83
  84 u_short
  85 ldunshort(p)
  86     register char       *p;
  87 {
  88     register unsigned int val;
  89
  90     val = *((unsigned char *)p++);
  91     val = (val << 8) + *((unsigned char *)p++);
  92
  93     return ((u_short)val);
  94 }
  95
  96 /* stint() - Store a short integer at a potentially unaligned address */
  97
  98 int
  99 stint(val, p)
 100     register short      val;
 101     register char       *p;
 102 {
 103     p += SHORTSIZE;
 104     *--p = val & 255;
 105     *--p = (val >> 8) & 255;
 106
 107     return(0);
 108 }
 109
 110 /* ldchar() - Load character field */
 111
 112 int
 113 ldchar(src, len, dst)
 114     char                *src;
 115     register char       *dst;
 116     int                 len;
 117 {
 118     register char       *p;
 119
 120     if (len <= 0)
 121         return;
 122
 123     /* Load the entire string. */
 124     memcpy((void *) dst, (const void *) src, len);
 125
 126     /* Remove trailing blanks. */
 127     p = dst + len;
 128     while (--p >= dst) {
 129         if (*p != BLANK) {
 130             break;
 131         }
 132     }
 133
 134     *++p = '\0';
 135 }
 136
 137 int
 138 stchar(src, dst, len)
 139     register char       *src;
 140     register char       *dst;
 141     register int        len;
 142 {
 143     register char       c;
 144
 145     if (len <= 0)
 146         return;
 147
 148     /* Copy up to NULL character. */
 149     do {
 150         if ((c = *src++) == '\0')
 151             break;
 152         *dst++ = c;
 153     } while (--len > 0);
 154
 155     /* Pad with blanks. */
 156     if (len > 0)
 157         (void) memset((void *) dst, BLANK, len);
 158 }
 159
 160 /* ldchar2() - Load character field (C style, NULL padded) */
 161
 162 int
 163 ldchar2(src, len, dst)
 164     char                *src;
 165     register char       *dst;
 166     int                 len;
 167 {
 168     register char       *p;
 169
 170     if (len <= 0)
 171         return;
 172
 173     /* Load the entire string. */
 174     memcpy((void *) dst, (const void *) src, len);
 175     *(dst + len) = NULL;
 176 }
 177
 178 int
 179 stchar2(src, dst, len)
 180     register char       *src;
 181     register char       *dst;
 182     register int        len;
 183 {
 184     register char       c;
 185
 186     if (len <= 0)
 187         return;
 188
 189     /* Copy up to a NULL character. */
 190     do {
 191         if ((c = *src++) == '\0')
 192             break;
 193         *dst++ = c;
 194     } while (--len > 0);
 195
 196     /* Pad with NULLs. */
 197     if (len > 0)
 198         memset(dst, 0, len);
 199 }
 200
 201 /* ldfloat() - Load a float number from a potentially  unaligned address */
 202
 203 float
 204 ldfloat(p)
 205     register char       *p;
 206 {
 207     union {
 208         float fval;
 209         int   ival;
 210     } uval;
 211     register unsigned int val;
 212
 213     val = *((unsigned char *)p++);
 214     val = (val << 8) + *((unsigned char *)p++);
 215     val = (val << 8) + *((unsigned char *)p++);
 216     val = (val << 8) + *((unsigned char *)p++);
 217
 218     uval.ival = val;
 219     return (uval.fval);
 220 }
 221
 222 /* stfloat() - Store a float number at a potentially unaligned address */
 223
 224 int
 225 stfloat(f, p)
 226     float               f;                   /* Bug - it is passed as double */
 227     register char       *p;
 228 {
 229     register unsigned   val;
 230     union {
 231         float fval;
 232         int   ival;
 233     } uval;
 234
 235     uval.fval = f;                           /* This fixes compiler bug */
 236     val = uval.ival;
 237
 238     p += LONGSIZE;
 239     *--p = val & 255;
 240     *--p = (val >> 8) & 255;
 241     *--p = (val >> 16) & 255;
 242     *--p = (val >> 24) & 255;
 243
 244     return(0);
 245 }
 246
 247 #if sparc | mc68000    /* MRJ */
 248
 249 /* ldbld() - Load a double float number from a potentially unaligned address */
 250
 251 double
 252 lddbl(p)
 253     register char       *p;
 254 {
 255     double val;
 256
 257     memcpy((void *)&val, (const void *) p, DOUBLESIZE);
 258     return (val);
 259 }
 260
 261 /* stdbl() - Store a double float number at a potentially unaligned address */
 262
 263 int
 264 stdbl(val, p)
 265     double              val;
 266     register char       *p;
 267 {
 268     memcpy ( p,(char *)&val, DOUBLESIZE);
 269 }
 270
 271 #else      /* 386i -- do it the long way round....  */
 272
 273 /* ldbld() - Load a double float number from a potentially unaligned address */
 274
 275 double
 276 lddbl(p)
 277     register char       *p;
 278 {
 279     union {
 280         double rval;
 281         char   sval[DOUBLESIZE];
 282     } x;
 283
 284     char  *q;
 285     int  i;
 286
 287     q  =  x.sval;
 288     p +=  DOUBLESIZE;
 289
 290     for (i=0; i<DOUBLESIZE; i++)
 291         *q++ = *--p;
 292     return (x.rval);
 293 }
 294
 295 /* stdbl() - Store a double float number at a potentially unaligned address */
 296
 297 int
 298 stdbl(val, p)
 299     double              val;
 300     register char       *p;
 301 {
 302     union {
 303         double rval;
 304         char   sval[DOUBLESIZE];
 305     } x;
 306
 307     char  *q;
 308     int  i;
 309
 310     x.rval = val;
 311     q  =  x.sval;
 312     p +=  DOUBLESIZE;
 313
 314     for (i=0; i<DOUBLESIZE; i++)
 315         *--p = *q++ ;
 316
 317     return(0);
 318 }
 319
 320
 321 #endif    /* sparc */
 322
 323