Annotation of embedaddon/ntp/libparse/ieee754io.c, revision 1.1
1.1 ! misho 1: /*
! 2: * /src/NTP/ntp4-dev/libntp/ieee754io.c,v 4.12 2005/04/16 17:32:10 kardel RELEASE_20050508_A
! 3: *
! 4: * ieee754io.c,v 4.12 2005/04/16 17:32:10 kardel RELEASE_20050508_A
! 5: *
! 6: * $Created: Sun Jul 13 09:12:02 1997 $
! 7: *
! 8: * Copyright (c) 1997-2005 by Frank Kardel <kardel <AT> ntp.org>
! 9: *
! 10: * Redistribution and use in source and binary forms, with or without
! 11: * modification, are permitted provided that the following conditions
! 12: * are met:
! 13: * 1. Redistributions of source code must retain the above copyright
! 14: * notice, this list of conditions and the following disclaimer.
! 15: * 2. Redistributions in binary form must reproduce the above copyright
! 16: * notice, this list of conditions and the following disclaimer in the
! 17: * documentation and/or other materials provided with the distribution.
! 18: * 3. Neither the name of the author nor the names of its contributors
! 19: * may be used to endorse or promote products derived from this software
! 20: * without specific prior written permission.
! 21: *
! 22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
! 23: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 24: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 25: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
! 26: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 27: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 28: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 29: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 30: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 31: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 32: * SUCH DAMAGE.
! 33: *
! 34: */
! 35:
! 36: #ifdef HAVE_CONFIG_H
! 37: #include "config.h"
! 38: #endif
! 39:
! 40: #include <stdio.h>
! 41: #include "l_stdlib.h"
! 42: #include "ntp_stdlib.h"
! 43: #include "ntp_fp.h"
! 44: #include "ieee754io.h"
! 45:
! 46: static unsigned char get_byte (unsigned char *, offsets_t, int *);
! 47: #ifdef __not_yet__
! 48: static void put_byte (unsigned char *, offsets_t, int *, unsigned char);
! 49: #endif
! 50:
! 51: #ifdef LIBDEBUG
! 52:
! 53: #include "lib_strbuf.h"
! 54:
! 55: static char *
! 56: fmt_blong(
! 57: unsigned long val,
! 58: int cnt
! 59: )
! 60: {
! 61: char *buf, *s;
! 62: int i = cnt;
! 63:
! 64: val <<= 32 - cnt;
! 65: LIB_GETBUF(buf);
! 66: s = buf;
! 67:
! 68: while (i--)
! 69: {
! 70: if (val & 0x80000000)
! 71: {
! 72: *s++ = '1';
! 73: }
! 74: else
! 75: {
! 76: *s++ = '0';
! 77: }
! 78: val <<= 1;
! 79: }
! 80: *s = '\0';
! 81: return buf;
! 82: }
! 83:
! 84: static char *
! 85: fmt_flt(
! 86: unsigned int sign,
! 87: unsigned long mh,
! 88: unsigned long ml,
! 89: unsigned long ch
! 90: )
! 91: {
! 92: char *buf;
! 93:
! 94: LIB_GETBUF(buf);
! 95: sprintf(buf, "%c %s %s %s", sign ? '-' : '+',
! 96: fmt_blong(ch, 11),
! 97: fmt_blong(mh, 20),
! 98: fmt_blong(ml, 32));
! 99: return buf;
! 100: }
! 101:
! 102: static char *
! 103: fmt_hex(
! 104: unsigned char *bufp,
! 105: int length
! 106: )
! 107: {
! 108: char *buf;
! 109: int i;
! 110:
! 111: LIB_GETBUF(buf);
! 112: for (i = 0; i < length; i++)
! 113: {
! 114: sprintf(buf+i*2, "%02x", bufp[i]);
! 115: }
! 116: return buf;
! 117: }
! 118:
! 119: #endif
! 120:
! 121: static unsigned char
! 122: get_byte(
! 123: unsigned char *bufp,
! 124: offsets_t offset,
! 125: int *fieldindex
! 126: )
! 127: {
! 128: unsigned char val;
! 129:
! 130: val = *(bufp + offset[*fieldindex]);
! 131: #ifdef LIBDEBUG
! 132: if (debug > 4)
! 133: printf("fetchieee754: getbyte(0x%08x, %d) = 0x%02x\n", (unsigned int)(bufp)+offset[*fieldindex], *fieldindex, val);
! 134: #endif
! 135: (*fieldindex)++;
! 136: return val;
! 137: }
! 138:
! 139: #ifdef __not_yet__
! 140: static void
! 141: put_byte(
! 142: unsigned char *bufp,
! 143: offsets_t offsets,
! 144: int *fieldindex,
! 145: unsigned char val
! 146: )
! 147: {
! 148: *(bufp + offsets[*fieldindex]) = val;
! 149: (*fieldindex)++;
! 150: }
! 151: #endif
! 152:
! 153: /*
! 154: * make conversions to and from external IEEE754 formats and internal
! 155: * NTP FP format.
! 156: */
! 157: int
! 158: fetch_ieee754(
! 159: unsigned char **buffpp,
! 160: int size,
! 161: l_fp *lfpp,
! 162: offsets_t offsets
! 163: )
! 164: {
! 165: unsigned char *bufp = *buffpp;
! 166: unsigned int sign;
! 167: unsigned int bias;
! 168: unsigned int maxexp;
! 169: int mbits;
! 170: u_long mantissa_low;
! 171: u_long mantissa_high;
! 172: u_long characteristic;
! 173: long exponent;
! 174: #ifdef LIBDEBUG
! 175: int length;
! 176: #endif
! 177: unsigned char val;
! 178: int fieldindex = 0;
! 179:
! 180: switch (size)
! 181: {
! 182: case IEEE_DOUBLE:
! 183: #ifdef LIBDEBUG
! 184: length = 8;
! 185: #endif
! 186: mbits = 52;
! 187: bias = 1023;
! 188: maxexp = 2047;
! 189: break;
! 190:
! 191: case IEEE_SINGLE:
! 192: #ifdef LIBDEBUG
! 193: length = 4;
! 194: #endif
! 195: mbits = 23;
! 196: bias = 127;
! 197: maxexp = 255;
! 198: break;
! 199:
! 200: default:
! 201: return IEEE_BADCALL;
! 202: }
! 203:
! 204: val = get_byte(bufp, offsets, &fieldindex); /* fetch sign byte & first part of characteristic */
! 205:
! 206: sign = (val & 0x80) != 0;
! 207: characteristic = (val & 0x7F);
! 208:
! 209: val = get_byte(bufp, offsets, &fieldindex); /* fetch rest of characteristic and start of mantissa */
! 210:
! 211: switch (size)
! 212: {
! 213: case IEEE_SINGLE:
! 214: characteristic <<= 1;
! 215: characteristic |= (val & 0x80) != 0; /* grab last characteristic bit */
! 216:
! 217: mantissa_high = 0;
! 218:
! 219: mantissa_low = (val &0x7F) << 16;
! 220: mantissa_low |= get_byte(bufp, offsets, &fieldindex) << 8;
! 221: mantissa_low |= get_byte(bufp, offsets, &fieldindex);
! 222: break;
! 223:
! 224: case IEEE_DOUBLE:
! 225: characteristic <<= 4;
! 226: characteristic |= (val & 0xF0) >> 4; /* grab lower characteristic bits */
! 227:
! 228: mantissa_high = (val & 0x0F) << 16;
! 229: mantissa_high |= get_byte(bufp, offsets, &fieldindex) << 8;
! 230: mantissa_high |= get_byte(bufp, offsets, &fieldindex);
! 231:
! 232: mantissa_low = get_byte(bufp, offsets, &fieldindex) << 24;
! 233: mantissa_low |= get_byte(bufp, offsets, &fieldindex) << 16;
! 234: mantissa_low |= get_byte(bufp, offsets, &fieldindex) << 8;
! 235: mantissa_low |= get_byte(bufp, offsets, &fieldindex);
! 236: break;
! 237:
! 238: default:
! 239: return IEEE_BADCALL;
! 240: }
! 241: #ifdef LIBDEBUG
! 242: if (debug > 4)
! 243: {
! 244: double d;
! 245: float f;
! 246:
! 247: if (size == IEEE_SINGLE)
! 248: {
! 249: int i;
! 250:
! 251: for (i = 0; i < length; i++)
! 252: {
! 253: *((unsigned char *)(&f)+i) = *(*buffpp + offsets[i]);
! 254: }
! 255: d = f;
! 256: }
! 257: else
! 258: {
! 259: int i;
! 260:
! 261: for (i = 0; i < length; i++)
! 262: {
! 263: *((unsigned char *)(&d)+i) = *(*buffpp + offsets[i]);
! 264: }
! 265: }
! 266:
! 267: printf("fetchieee754: FP: %s -> %s -> %e(=%s)\n", fmt_hex(*buffpp, length),
! 268: fmt_flt(sign, mantissa_high, mantissa_low, characteristic),
! 269: d, fmt_hex((unsigned char *)&d, length));
! 270: }
! 271: #endif
! 272:
! 273: *buffpp += fieldindex;
! 274:
! 275: /*
! 276: * detect funny numbers
! 277: */
! 278: if (characteristic == maxexp)
! 279: {
! 280: /*
! 281: * NaN or Infinity
! 282: */
! 283: if (mantissa_low || mantissa_high)
! 284: {
! 285: /*
! 286: * NaN
! 287: */
! 288: return IEEE_NAN;
! 289: }
! 290: else
! 291: {
! 292: /*
! 293: * +Inf or -Inf
! 294: */
! 295: return sign ? IEEE_NEGINFINITY : IEEE_POSINFINITY;
! 296: }
! 297: }
! 298: else
! 299: {
! 300: /*
! 301: * collect real numbers
! 302: */
! 303:
! 304: L_CLR(lfpp);
! 305:
! 306: /*
! 307: * check for overflows
! 308: */
! 309: exponent = characteristic - bias;
! 310:
! 311: if (exponent > 31) /* sorry - hardcoded */
! 312: {
! 313: /*
! 314: * overflow only in respect to NTP-FP representation
! 315: */
! 316: return sign ? IEEE_NEGOVERFLOW : IEEE_POSOVERFLOW;
! 317: }
! 318: else
! 319: {
! 320: int frac_offset; /* where the fraction starts */
! 321:
! 322: frac_offset = mbits - exponent;
! 323:
! 324: if (characteristic == 0)
! 325: {
! 326: /*
! 327: * de-normalized or tiny number - fits only as 0
! 328: */
! 329: return IEEE_OK;
! 330: }
! 331: else
! 332: {
! 333: /*
! 334: * adjust for implied 1
! 335: */
! 336: if (mbits > 31)
! 337: mantissa_high |= 1 << (mbits - 32);
! 338: else
! 339: mantissa_low |= 1 << mbits;
! 340:
! 341: /*
! 342: * take mantissa apart - if only all machine would support
! 343: * 64 bit operations 8-(
! 344: */
! 345: if (frac_offset > mbits)
! 346: {
! 347: lfpp->l_ui = 0; /* only fractional number */
! 348: frac_offset -= mbits + 1; /* will now contain right shift count - 1*/
! 349: if (mbits > 31)
! 350: {
! 351: lfpp->l_uf = mantissa_high << (63 - mbits);
! 352: lfpp->l_uf |= mantissa_low >> (mbits - 33);
! 353: lfpp->l_uf >>= frac_offset;
! 354: }
! 355: else
! 356: {
! 357: lfpp->l_uf = mantissa_low >> frac_offset;
! 358: }
! 359: }
! 360: else
! 361: {
! 362: if (frac_offset > 32)
! 363: {
! 364: /*
! 365: * must split in high word
! 366: */
! 367: lfpp->l_ui = mantissa_high >> (frac_offset - 32);
! 368: lfpp->l_uf = (mantissa_high & ((1 << (frac_offset - 32)) - 1)) << (64 - frac_offset);
! 369: lfpp->l_uf |= mantissa_low >> (frac_offset - 32);
! 370: }
! 371: else
! 372: {
! 373: /*
! 374: * must split in low word
! 375: */
! 376: lfpp->l_ui = mantissa_high << (32 - frac_offset);
! 377: lfpp->l_ui |= (mantissa_low >> frac_offset) & ((1 << (32 - frac_offset)) - 1);
! 378: lfpp->l_uf = (mantissa_low & ((1 << frac_offset) - 1)) << (32 - frac_offset);
! 379: }
! 380: }
! 381:
! 382: /*
! 383: * adjust for sign
! 384: */
! 385: if (sign)
! 386: {
! 387: L_NEG(lfpp);
! 388: }
! 389:
! 390: return IEEE_OK;
! 391: }
! 392: }
! 393: }
! 394: }
! 395:
! 396: int
! 397: put_ieee754(
! 398: unsigned char **bufpp,
! 399: int size,
! 400: l_fp *lfpp,
! 401: offsets_t offsets
! 402: )
! 403: {
! 404: l_fp outlfp;
! 405: #ifdef LIBDEBUG
! 406: unsigned int sign;
! 407: unsigned int bias;
! 408: #endif
! 409: /*unsigned int maxexp;*/
! 410: int mbits;
! 411: int msb;
! 412: u_long mantissa_low = 0;
! 413: u_long mantissa_high = 0;
! 414: #ifdef LIBDEBUG
! 415: u_long characteristic = 0;
! 416: long exponent;
! 417: #endif
! 418: /*int length;*/
! 419: unsigned long mask;
! 420:
! 421: outlfp = *lfpp;
! 422:
! 423: switch (size)
! 424: {
! 425: case IEEE_DOUBLE:
! 426: /*length = 8;*/
! 427: mbits = 52;
! 428: #ifdef LIBDEBUG
! 429: bias = 1023;
! 430: #endif
! 431: /*maxexp = 2047;*/
! 432: break;
! 433:
! 434: case IEEE_SINGLE:
! 435: /*length = 4;*/
! 436: mbits = 23;
! 437: #ifdef LIBDEBUG
! 438: bias = 127;
! 439: #endif
! 440: /*maxexp = 255;*/
! 441: break;
! 442:
! 443: default:
! 444: return IEEE_BADCALL;
! 445: }
! 446:
! 447: /*
! 448: * find sign
! 449: */
! 450: if (L_ISNEG(&outlfp))
! 451: {
! 452: L_NEG(&outlfp);
! 453: #ifdef LIBDEBUG
! 454: sign = 1;
! 455: #endif
! 456: }
! 457: else
! 458: {
! 459: #ifdef LIBDEBUG
! 460: sign = 0;
! 461: #endif
! 462: }
! 463:
! 464: if (L_ISZERO(&outlfp))
! 465: {
! 466: #ifdef LIBDEBUG
! 467: exponent = mantissa_high = mantissa_low = 0; /* true zero */
! 468: #endif
! 469: }
! 470: else
! 471: {
! 472: /*
! 473: * find number of significant integer bits
! 474: */
! 475: mask = 0x80000000;
! 476: if (outlfp.l_ui)
! 477: {
! 478: msb = 63;
! 479: while (mask && ((outlfp.l_ui & mask) == 0))
! 480: {
! 481: mask >>= 1;
! 482: msb--;
! 483: }
! 484: }
! 485: else
! 486: {
! 487: msb = 31;
! 488: while (mask && ((outlfp.l_uf & mask) == 0))
! 489: {
! 490: mask >>= 1;
! 491: msb--;
! 492: }
! 493: }
! 494:
! 495: switch (size)
! 496: {
! 497: case IEEE_SINGLE:
! 498: mantissa_high = 0;
! 499: if (msb >= 32)
! 500: {
! 501: mantissa_low = (outlfp.l_ui & ((1 << (msb - 32)) - 1)) << (mbits - (msb - 32));
! 502: mantissa_low |= outlfp.l_uf >> (mbits - (msb - 32));
! 503: }
! 504: else
! 505: {
! 506: mantissa_low = (outlfp.l_uf << (mbits - msb)) & ((1 << mbits) - 1);
! 507: }
! 508: break;
! 509:
! 510: case IEEE_DOUBLE:
! 511: if (msb >= 32)
! 512: {
! 513: mantissa_high = (outlfp.l_ui << (mbits - msb)) & ((1 << (mbits - 32)) - 1);
! 514: mantissa_high |= outlfp.l_uf >> (32 - (mbits - msb));
! 515: mantissa_low = (outlfp.l_ui & ((1 << (msb - mbits)) - 1)) << (32 - (msb - mbits));
! 516: mantissa_low |= outlfp.l_uf >> (msb - mbits);
! 517: }
! 518: else
! 519: {
! 520: mantissa_high = outlfp.l_uf << (mbits - 32 - msb);
! 521: mantissa_low = outlfp.l_uf << (mbits - 32);
! 522: }
! 523: }
! 524:
! 525: #ifdef LIBDEBUG
! 526: exponent = msb - 32;
! 527: characteristic = exponent + bias;
! 528:
! 529: if (debug > 4)
! 530: printf("FP: %s\n", fmt_flt(sign, mantissa_high, mantissa_low, characteristic));
! 531: #endif
! 532: }
! 533: return IEEE_OK;
! 534: }
! 535:
! 536:
! 537: #if defined(DEBUG) && defined(LIBDEBUG)
! 538: int main(
! 539: int argc,
! 540: char **argv
! 541: )
! 542: {
! 543: static offsets_t native_off = { 0, 1, 2, 3, 4, 5, 6, 7 };
! 544: double f = 1.0;
! 545: double *f_p = &f;
! 546: l_fp fp;
! 547:
! 548: if (argc == 2)
! 549: {
! 550: if (sscanf(argv[1], "%lf", &f) != 1)
! 551: {
! 552: printf("cannot convert %s to a float\n", argv[1]);
! 553: return 1;
! 554: }
! 555: }
! 556:
! 557: printf("double: %s %s\n", fmt_blong(*(unsigned long *)&f, 32), fmt_blong(*(unsigned long *)((char *)(&f)+4), 32));
! 558: printf("fetch from %f = %d\n", f, fetch_ieee754((void *)&f_p, IEEE_DOUBLE, &fp, native_off));
! 559: printf("fp [%s %s] = %s\n", fmt_blong(fp.l_ui, 32), fmt_blong(fp.l_uf, 32), mfptoa(fp.l_ui, fp.l_uf, 15));
! 560: f_p = &f;
! 561: put_ieee754((void *)&f_p, IEEE_DOUBLE, &fp, native_off);
! 562:
! 563: return 0;
! 564: }
! 565:
! 566: #endif
! 567: /*
! 568: * History:
! 569: *
! 570: * ieee754io.c,v
! 571: * Revision 4.12 2005/04/16 17:32:10 kardel
! 572: * update copyright
! 573: *
! 574: * Revision 4.11 2004/11/14 15:29:41 kardel
! 575: * support PPSAPI, upgrade Copyright to Berkeley style
! 576: *
! 577: * Revision 4.8 1999/02/21 12:17:36 kardel
! 578: * 4.91f reconcilation
! 579: *
! 580: * Revision 4.7 1999/02/21 11:26:03 kardel
! 581: * renamed index to fieldindex to avoid index() name clash
! 582: *
! 583: * Revision 4.6 1998/11/15 20:27:52 kardel
! 584: * Release 4.0.73e13 reconcilation
! 585: *
! 586: * Revision 4.5 1998/08/16 19:01:51 kardel
! 587: * debug information only compile for LIBDEBUG case
! 588: *
! 589: * Revision 4.4 1998/08/09 09:39:28 kardel
! 590: * Release 4.0.73e2 reconcilation
! 591: *
! 592: * Revision 4.3 1998/06/13 11:56:19 kardel
! 593: * disabled putbute() for the time being
! 594: *
! 595: * Revision 4.2 1998/06/12 15:16:58 kardel
! 596: * ansi2knr compatibility
! 597: *
! 598: * Revision 4.1 1998/05/24 07:59:56 kardel
! 599: * conditional debug support
! 600: *
! 601: * Revision 4.0 1998/04/10 19:46:29 kardel
! 602: * Start 4.0 release version numbering
! 603: *
! 604: * Revision 1.1 1998/04/10 19:27:46 kardel
! 605: * initial NTP VERSION 4 integration of PARSE with GPS166 binary support
! 606: *
! 607: * Revision 1.1 1997/10/06 21:05:45 kardel
! 608: * new parse structure
! 609: *
! 610: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ieee754io.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / libparse