![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to doprnt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / lib / libc / stdio|
Return to doprnt.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / lib / libc / stdio |
1.1 ! root 1: /* ! 2: * Copyright (c) 1988 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted provided ! 6: * that: (1) source distributions retain this entire copyright notice and ! 7: * comment, and (2) distributions including binaries display the following ! 8: * acknowledgement: ``This product includes software developed by the ! 9: * University of California, Berkeley and its contributors'' in the ! 10: * documentation or other materials provided with the distribution and in ! 11: * all advertising materials mentioning features or use of this software. ! 12: * Neither the name of the University nor the names of its contributors may ! 13: * be used to endorse or promote products derived from this software without ! 14: * specific prior written permission. ! 15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 18: */ ! 19: ! 20: #if defined(LIBC_SCCS) && !defined(lint) ! 21: static char sccsid[] = "@(#)doprnt.c 5.39 (Berkeley) 6/28/90"; ! 22: #endif /* LIBC_SCCS and not lint */ ! 23: ! 24: #include <sys/types.h> ! 25: #include <varargs.h> ! 26: #include <stdio.h> ! 27: #include <ctype.h> ! 28: ! 29: /* 11-bit exponent (VAX G floating point) is 308 decimal digits */ ! 30: #define MAXEXP 308 ! 31: /* 128 bit fraction takes up 39 decimal digits; max reasonable precision */ ! 32: #define MAXFRACT 39 ! 33: ! 34: #define DEFPREC 6 ! 35: ! 36: #define BUF (MAXEXP+MAXFRACT+1) /* + decimal point */ ! 37: ! 38: #define PUTC(ch) (void) putc(ch, fp) ! 39: ! 40: #define ARG(basetype) \ ! 41: _ulong = flags&LONGINT ? va_arg(argp, long basetype) : \ ! 42: flags&SHORTINT ? (short basetype)va_arg(argp, int) : \ ! 43: va_arg(argp, int) ! 44: ! 45: #define todigit(c) ((c) - '0') ! 46: #define tochar(n) ((n) + '0') ! 47: ! 48: /* have to deal with the negative buffer count kludge */ ! 49: #define NEGATIVE_COUNT_KLUDGE ! 50: ! 51: #define LONGINT 0x01 /* long integer */ ! 52: #define LONGDBL 0x02 /* long double; unimplemented */ ! 53: #define SHORTINT 0x04 /* short integer */ ! 54: #define ALT 0x08 /* alternate form */ ! 55: #define LADJUST 0x10 /* left adjustment */ ! 56: #define ZEROPAD 0x20 /* zero (as opposed to blank) pad */ ! 57: #define HEXPREFIX 0x40 /* add 0x or 0X prefix */ ! 58: ! 59: _doprnt(fmt0, argp, fp) ! 60: u_char *fmt0; ! 61: va_list argp; ! 62: register FILE *fp; ! 63: { ! 64: register u_char *fmt; /* format string */ ! 65: register int ch; /* character from fmt */ ! 66: register int cnt; /* return value accumulator */ ! 67: register int n; /* random handy integer */ ! 68: register char *t; /* buffer pointer */ ! 69: double _double; /* double precision arguments %[eEfgG] */ ! 70: u_long _ulong; /* integer arguments %[diouxX] */ ! 71: int base; /* base for [diouxX] conversion */ ! 72: int dprec; /* decimal precision in [diouxX] */ ! 73: int fieldsz; /* field size expanded by sign, etc */ ! 74: int flags; /* flags as above */ ! 75: int fpprec; /* `extra' floating precision in [eEfgG] */ ! 76: int prec; /* precision from format (%.3d), or -1 */ ! 77: int realsz; /* field size expanded by decimal precision */ ! 78: int size; /* size of converted field or string */ ! 79: int width; /* width from format (%8d), or 0 */ ! 80: char sign; /* sign prefix (' ', '+', '-', or \0) */ ! 81: char softsign; /* temporary negative sign for floats */ ! 82: char *digs; /* digits for [diouxX] conversion */ ! 83: char buf[BUF]; /* space for %c, %[diouxX], %[eEfgG] */ ! 84: ! 85: if (fp->_flag & _IORW) { ! 86: fp->_flag |= _IOWRT; ! 87: fp->_flag &= ~(_IOEOF|_IOREAD); ! 88: } ! 89: if ((fp->_flag & _IOWRT) == 0) ! 90: return (EOF); ! 91: ! 92: fmt = fmt0; ! 93: digs = "0123456789abcdef"; ! 94: for (cnt = 0;; ++fmt) { ! 95: n = fp->_cnt; ! 96: for (t = (char *)fp->_ptr; (ch = *fmt) && ch != '%'; ! 97: ++cnt, ++fmt) ! 98: if (--n < 0 ! 99: #ifdef NEGATIVE_COUNT_KLUDGE ! 100: && (!(fp->_flag & _IOLBF) || -n >= fp->_bufsiz) ! 101: #endif ! 102: || ch == '\n' && fp->_flag & _IOLBF) { ! 103: fp->_cnt = n; ! 104: fp->_ptr = t; ! 105: (void) _flsbuf((u_char)ch, fp); ! 106: n = fp->_cnt; ! 107: t = (char *)fp->_ptr; ! 108: } else ! 109: *t++ = ch; ! 110: fp->_cnt = n; ! 111: fp->_ptr = t; ! 112: if (!ch) ! 113: return (cnt); ! 114: ! 115: flags = 0; dprec = 0; fpprec = 0; width = 0; ! 116: prec = -1; ! 117: sign = '\0'; ! 118: ! 119: rflag: switch (*++fmt) { ! 120: case ' ': ! 121: /* ! 122: * ``If the space and + flags both appear, the space ! 123: * flag will be ignored.'' ! 124: * -- ANSI X3J11 ! 125: */ ! 126: if (!sign) ! 127: sign = ' '; ! 128: goto rflag; ! 129: case '#': ! 130: flags |= ALT; ! 131: goto rflag; ! 132: case '*': ! 133: /* ! 134: * ``A negative field width argument is taken as a ! 135: * - flag followed by a positive field width.'' ! 136: * -- ANSI X3J11 ! 137: * They don't exclude field widths read from args. ! 138: */ ! 139: if ((width = va_arg(argp, int)) >= 0) ! 140: goto rflag; ! 141: width = -width; ! 142: /* FALLTHROUGH */ ! 143: case '-': ! 144: flags |= LADJUST; ! 145: goto rflag; ! 146: case '+': ! 147: sign = '+'; ! 148: goto rflag; ! 149: case '.': ! 150: if (*++fmt == '*') ! 151: n = va_arg(argp, int); ! 152: else { ! 153: n = 0; ! 154: while (isascii(*fmt) && isdigit(*fmt)) ! 155: n = 10 * n + todigit(*fmt++); ! 156: --fmt; ! 157: } ! 158: prec = n < 0 ? -1 : n; ! 159: goto rflag; ! 160: case '0': ! 161: /* ! 162: * ``Note that 0 is taken as a flag, not as the ! 163: * beginning of a field width.'' ! 164: * -- ANSI X3J11 ! 165: */ ! 166: flags |= ZEROPAD; ! 167: goto rflag; ! 168: case '1': case '2': case '3': case '4': ! 169: case '5': case '6': case '7': case '8': case '9': ! 170: n = 0; ! 171: do { ! 172: n = 10 * n + todigit(*fmt); ! 173: } while (isascii(*++fmt) && isdigit(*fmt)); ! 174: width = n; ! 175: --fmt; ! 176: goto rflag; ! 177: case 'L': ! 178: flags |= LONGDBL; ! 179: goto rflag; ! 180: case 'h': ! 181: flags |= SHORTINT; ! 182: goto rflag; ! 183: case 'l': ! 184: flags |= LONGINT; ! 185: goto rflag; ! 186: case 'c': ! 187: *(t = buf) = va_arg(argp, int); ! 188: size = 1; ! 189: sign = '\0'; ! 190: goto pforw; ! 191: case 'D': ! 192: flags |= LONGINT; ! 193: /*FALLTHROUGH*/ ! 194: case 'd': ! 195: case 'i': ! 196: ARG(int); ! 197: if ((long)_ulong < 0) { ! 198: _ulong = -_ulong; ! 199: sign = '-'; ! 200: } ! 201: base = 10; ! 202: goto number; ! 203: case 'e': ! 204: case 'E': ! 205: case 'f': ! 206: case 'g': ! 207: case 'G': ! 208: _double = va_arg(argp, double); ! 209: /* ! 210: * don't do unrealistic precision; just pad it with ! 211: * zeroes later, so buffer size stays rational. ! 212: */ ! 213: if (prec > MAXFRACT) { ! 214: if (*fmt != 'g' && *fmt != 'G' || (flags&ALT)) ! 215: fpprec = prec - MAXFRACT; ! 216: prec = MAXFRACT; ! 217: } ! 218: else if (prec == -1) ! 219: prec = DEFPREC; ! 220: /* ! 221: * softsign avoids negative 0 if _double is < 0 and ! 222: * no significant digits will be shown ! 223: */ ! 224: if (_double < 0) { ! 225: softsign = '-'; ! 226: _double = -_double; ! 227: } ! 228: else ! 229: softsign = 0; ! 230: /* ! 231: * cvt may have to round up past the "start" of the ! 232: * buffer, i.e. ``intf("%.2f", (double)9.999);''; ! 233: * if the first char isn't NULL, it did. ! 234: */ ! 235: *buf = NULL; ! 236: size = cvt(_double, prec, flags, &softsign, *fmt, buf, ! 237: buf + sizeof(buf)); ! 238: if (softsign) ! 239: sign = '-'; ! 240: t = *buf ? buf : buf + 1; ! 241: goto pforw; ! 242: case 'n': ! 243: if (flags & LONGINT) ! 244: *va_arg(argp, long *) = cnt; ! 245: else if (flags & SHORTINT) ! 246: *va_arg(argp, short *) = cnt; ! 247: else ! 248: *va_arg(argp, int *) = cnt; ! 249: break; ! 250: case 'O': ! 251: flags |= LONGINT; ! 252: /*FALLTHROUGH*/ ! 253: case 'o': ! 254: ARG(unsigned); ! 255: base = 8; ! 256: goto nosign; ! 257: case 'p': ! 258: /* ! 259: * ``The argument shall be a pointer to void. The ! 260: * value of the pointer is converted to a sequence ! 261: * of printable characters, in an implementation- ! 262: * defined manner.'' ! 263: * -- ANSI X3J11 ! 264: */ ! 265: /* NOSTRICT */ ! 266: _ulong = (u_long)va_arg(argp, void *); ! 267: base = 16; ! 268: goto nosign; ! 269: case 's': ! 270: if (!(t = va_arg(argp, char *))) ! 271: t = "(null)"; ! 272: if (prec >= 0) { ! 273: /* ! 274: * can't use strlen; can only look for the ! 275: * NUL in the first `prec' characters, and ! 276: * strlen() will go further. ! 277: */ ! 278: char *p, *memchr(); ! 279: ! 280: if (p = memchr(t, 0, prec)) { ! 281: size = p - t; ! 282: if (size > prec) ! 283: size = prec; ! 284: } else ! 285: size = prec; ! 286: } else ! 287: size = strlen(t); ! 288: sign = '\0'; ! 289: goto pforw; ! 290: case 'U': ! 291: flags |= LONGINT; ! 292: /*FALLTHROUGH*/ ! 293: case 'u': ! 294: ARG(unsigned); ! 295: base = 10; ! 296: goto nosign; ! 297: case 'X': ! 298: digs = "0123456789ABCDEF"; ! 299: /* FALLTHROUGH */ ! 300: case 'x': ! 301: ARG(unsigned); ! 302: base = 16; ! 303: /* leading 0x/X only if non-zero */ ! 304: if (flags & ALT && _ulong != 0) ! 305: flags |= HEXPREFIX; ! 306: ! 307: /* unsigned conversions */ ! 308: nosign: sign = '\0'; ! 309: /* ! 310: * ``... diouXx conversions ... if a precision is ! 311: * specified, the 0 flag will be ignored.'' ! 312: * -- ANSI X3J11 ! 313: */ ! 314: number: if ((dprec = prec) >= 0) ! 315: flags &= ~ZEROPAD; ! 316: ! 317: /* ! 318: * ``The result of converting a zero value with an ! 319: * explicit precision of zero is no characters.'' ! 320: * -- ANSI X3J11 ! 321: */ ! 322: t = buf + BUF; ! 323: if (_ulong != 0 || prec != 0) { ! 324: do { ! 325: *--t = digs[_ulong % base]; ! 326: _ulong /= base; ! 327: } while (_ulong); ! 328: digs = "0123456789abcdef"; ! 329: if (flags & ALT && base == 8 && *t != '0') ! 330: *--t = '0'; /* octal leading 0 */ ! 331: } ! 332: size = buf + BUF - t; ! 333: ! 334: pforw: ! 335: /* ! 336: * All reasonable formats wind up here. At this point, ! 337: * `t' points to a string which (if not flags&LADJUST) ! 338: * should be padded out to `width' places. If ! 339: * flags&ZEROPAD, it should first be prefixed by any ! 340: * sign or other prefix; otherwise, it should be blank ! 341: * padded before the prefix is emitted. After any ! 342: * left-hand padding and prefixing, emit zeroes ! 343: * required by a decimal [diouxX] precision, then print ! 344: * the string proper, then emit zeroes required by any ! 345: * leftover floating precision; finally, if LADJUST, ! 346: * pad with blanks. ! 347: */ ! 348: ! 349: /* ! 350: * compute actual size, so we know how much to pad ! 351: * fieldsz excludes decimal prec; realsz includes it ! 352: */ ! 353: fieldsz = size + fpprec; ! 354: if (sign) ! 355: fieldsz++; ! 356: if (flags & HEXPREFIX) ! 357: fieldsz += 2; ! 358: realsz = dprec > fieldsz ? dprec : fieldsz; ! 359: ! 360: /* right-adjusting blank padding */ ! 361: if ((flags & (LADJUST|ZEROPAD)) == 0 && width) ! 362: for (n = realsz; n < width; n++) ! 363: PUTC(' '); ! 364: /* prefix */ ! 365: if (sign) ! 366: PUTC(sign); ! 367: if (flags & HEXPREFIX) { ! 368: PUTC('0'); ! 369: PUTC((char)*fmt); ! 370: } ! 371: /* right-adjusting zero padding */ ! 372: if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD) ! 373: for (n = realsz; n < width; n++) ! 374: PUTC('0'); ! 375: /* leading zeroes from decimal precision */ ! 376: for (n = fieldsz; n < dprec; n++) ! 377: PUTC('0'); ! 378: ! 379: /* the string or number proper */ ! 380: n = size; ! 381: if (fp->_cnt - n >= 0 && (fp->_flag & _IOLBF) == 0) { ! 382: fp->_cnt -= n; ! 383: bcopy(t, (char *)fp->_ptr, n); ! 384: fp->_ptr += n; ! 385: } else ! 386: while (--n >= 0) ! 387: PUTC(*t++); ! 388: /* trailing f.p. zeroes */ ! 389: while (--fpprec >= 0) ! 390: PUTC('0'); ! 391: /* left-adjusting padding (always blank) */ ! 392: if (flags & LADJUST) ! 393: for (n = realsz; n < width; n++) ! 394: PUTC(' '); ! 395: /* finally, adjust cnt */ ! 396: cnt += width > realsz ? width : realsz; ! 397: break; ! 398: case '\0': /* "%?" prints ?, unless ? is NULL */ ! 399: return (cnt); ! 400: default: ! 401: PUTC((char)*fmt); ! 402: cnt++; ! 403: } ! 404: } ! 405: /* NOTREACHED */ ! 406: } ! 407: ! 408: static ! 409: cvt(number, prec, flags, signp, fmtch, startp, endp) ! 410: double number; ! 411: register int prec; ! 412: int flags; ! 413: u_char fmtch; ! 414: char *signp, *startp, *endp; ! 415: { ! 416: register char *p, *t; ! 417: register double fract; ! 418: int dotrim, expcnt, gformat; ! 419: double integer, tmp, modf(); ! 420: char *exponent(), *round(); ! 421: ! 422: #ifdef hp300 ! 423: if (expcnt = isspecial(number, startp, signp)) ! 424: return(expcnt); ! 425: #endif ! 426: ! 427: dotrim = expcnt = gformat = 0; ! 428: fract = modf(number, &integer); ! 429: ! 430: /* get an extra slot for rounding. */ ! 431: t = ++startp; ! 432: ! 433: /* ! 434: * get integer portion of number; put into the end of the buffer; the ! 435: * .01 is added for modf(356.0 / 10, &integer) returning .59999999... ! 436: */ ! 437: for (p = endp - 1; integer; ++expcnt) { ! 438: tmp = modf(integer / 10, &integer); ! 439: *p-- = tochar((int)((tmp + .01) * 10)); ! 440: } ! 441: switch(fmtch) { ! 442: case 'f': ! 443: /* reverse integer into beginning of buffer */ ! 444: if (expcnt) ! 445: for (; ++p < endp; *t++ = *p); ! 446: else ! 447: *t++ = '0'; ! 448: /* ! 449: * if precision required or alternate flag set, add in a ! 450: * decimal point. ! 451: */ ! 452: if (prec || flags&ALT) ! 453: *t++ = '.'; ! 454: /* if requires more precision and some fraction left */ ! 455: if (fract) { ! 456: if (prec) ! 457: do { ! 458: fract = modf(fract * 10, &tmp); ! 459: *t++ = tochar((int)tmp); ! 460: } while (--prec && fract); ! 461: if (fract) ! 462: startp = round(fract, (int *)NULL, startp, ! 463: t - 1, (char)0, signp); ! 464: } ! 465: for (; prec--; *t++ = '0'); ! 466: break; ! 467: case 'e': ! 468: case 'E': ! 469: eformat: if (expcnt) { ! 470: *t++ = *++p; ! 471: if (prec || flags&ALT) ! 472: *t++ = '.'; ! 473: /* if requires more precision and some integer left */ ! 474: for (; prec && ++p < endp; --prec) ! 475: *t++ = *p; ! 476: /* ! 477: * if done precision and more of the integer component, ! 478: * round using it; adjust fract so we don't re-round ! 479: * later. ! 480: */ ! 481: if (!prec && ++p < endp) { ! 482: fract = 0; ! 483: startp = round((double)0, &expcnt, startp, ! 484: t - 1, *p, signp); ! 485: } ! 486: /* adjust expcnt for digit in front of decimal */ ! 487: --expcnt; ! 488: } ! 489: /* until first fractional digit, decrement exponent */ ! 490: else if (fract) { ! 491: /* adjust expcnt for digit in front of decimal */ ! 492: for (expcnt = -1;; --expcnt) { ! 493: fract = modf(fract * 10, &tmp); ! 494: if (tmp) ! 495: break; ! 496: } ! 497: *t++ = tochar((int)tmp); ! 498: if (prec || flags&ALT) ! 499: *t++ = '.'; ! 500: } ! 501: else { ! 502: *t++ = '0'; ! 503: if (prec || flags&ALT) ! 504: *t++ = '.'; ! 505: } ! 506: /* if requires more precision and some fraction left */ ! 507: if (fract) { ! 508: if (prec) ! 509: do { ! 510: fract = modf(fract * 10, &tmp); ! 511: *t++ = tochar((int)tmp); ! 512: } while (--prec && fract); ! 513: if (fract) ! 514: startp = round(fract, &expcnt, startp, ! 515: t - 1, (char)0, signp); ! 516: } ! 517: /* if requires more precision */ ! 518: for (; prec--; *t++ = '0'); ! 519: ! 520: /* unless alternate flag, trim any g/G format trailing 0's */ ! 521: if (gformat && !(flags&ALT)) { ! 522: while (t > startp && *--t == '0'); ! 523: if (*t == '.') ! 524: --t; ! 525: ++t; ! 526: } ! 527: t = exponent(t, expcnt, fmtch); ! 528: break; ! 529: case 'g': ! 530: case 'G': ! 531: /* a precision of 0 is treated as a precision of 1. */ ! 532: if (!prec) ! 533: ++prec; ! 534: /* ! 535: * ``The style used depends on the value converted; style e ! 536: * will be used only if the exponent resulting from the ! 537: * conversion is less than -4 or greater than the precision.'' ! 538: * -- ANSI X3J11 ! 539: */ ! 540: if (expcnt > prec || !expcnt && fract && fract < .0001) { ! 541: /* ! 542: * g/G format counts "significant digits, not digits of ! 543: * precision; for the e/E format, this just causes an ! 544: * off-by-one problem, i.e. g/G considers the digit ! 545: * before the decimal point significant and e/E doesn't ! 546: * count it as precision. ! 547: */ ! 548: --prec; ! 549: fmtch -= 2; /* G->E, g->e */ ! 550: gformat = 1; ! 551: goto eformat; ! 552: } ! 553: /* ! 554: * reverse integer into beginning of buffer, ! 555: * note, decrement precision ! 556: */ ! 557: if (expcnt) ! 558: for (; ++p < endp; *t++ = *p, --prec); ! 559: else ! 560: *t++ = '0'; ! 561: /* ! 562: * if precision required or alternate flag set, add in a ! 563: * decimal point. If no digits yet, add in leading 0. ! 564: */ ! 565: if (prec || flags&ALT) { ! 566: dotrim = 1; ! 567: *t++ = '.'; ! 568: } ! 569: else ! 570: dotrim = 0; ! 571: /* if requires more precision and some fraction left */ ! 572: if (fract) { ! 573: if (prec) { ! 574: do { ! 575: fract = modf(fract * 10, &tmp); ! 576: *t++ = tochar((int)tmp); ! 577: } while(!tmp); ! 578: while (--prec && fract) { ! 579: fract = modf(fract * 10, &tmp); ! 580: *t++ = tochar((int)tmp); ! 581: } ! 582: } ! 583: if (fract) ! 584: startp = round(fract, (int *)NULL, startp, ! 585: t - 1, (char)0, signp); ! 586: } ! 587: /* alternate format, adds 0's for precision, else trim 0's */ ! 588: if (flags&ALT) ! 589: for (; prec--; *t++ = '0'); ! 590: else if (dotrim) { ! 591: while (t > startp && *--t == '0'); ! 592: if (*t != '.') ! 593: ++t; ! 594: } ! 595: } ! 596: return(t - startp); ! 597: } ! 598: ! 599: static char * ! 600: round(fract, exp, start, end, ch, signp) ! 601: double fract; ! 602: int *exp; ! 603: register char *start, *end; ! 604: char ch, *signp; ! 605: { ! 606: double tmp; ! 607: ! 608: if (fract) ! 609: (void)modf(fract * 10, &tmp); ! 610: else ! 611: tmp = todigit(ch); ! 612: if (tmp > 4) ! 613: for (;; --end) { ! 614: if (*end == '.') ! 615: --end; ! 616: if (++*end <= '9') ! 617: break; ! 618: *end = '0'; ! 619: if (end == start) { ! 620: if (exp) { /* e/E; increment exponent */ ! 621: *end = '1'; ! 622: ++*exp; ! 623: } ! 624: else { /* f; add extra digit */ ! 625: *--end = '1'; ! 626: --start; ! 627: } ! 628: break; ! 629: } ! 630: } ! 631: /* ``"%.3f", (double)-0.0004'' gives you a negative 0. */ ! 632: else if (*signp == '-') ! 633: for (;; --end) { ! 634: if (*end == '.') ! 635: --end; ! 636: if (*end != '0') ! 637: break; ! 638: if (end == start) ! 639: *signp = 0; ! 640: } ! 641: return(start); ! 642: } ! 643: ! 644: static char * ! 645: exponent(p, exp, fmtch) ! 646: register char *p; ! 647: register int exp; ! 648: u_char fmtch; ! 649: { ! 650: register char *t; ! 651: char expbuf[MAXEXP]; ! 652: ! 653: *p++ = fmtch; ! 654: if (exp < 0) { ! 655: exp = -exp; ! 656: *p++ = '-'; ! 657: } ! 658: else ! 659: *p++ = '+'; ! 660: t = expbuf + MAXEXP; ! 661: if (exp > 9) { ! 662: do { ! 663: *--t = tochar(exp % 10); ! 664: } while ((exp /= 10) > 9); ! 665: *--t = tochar(exp); ! 666: for (; t < expbuf + MAXEXP; *p++ = *t++); ! 667: } ! 668: else { ! 669: *p++ = '0'; ! 670: *p++ = tochar(exp); ! 671: } ! 672: return(p); ! 673: } ! 674: ! 675: #ifdef hp300 ! 676: isspecial(d, bufp, signp) ! 677: double d; ! 678: char *bufp, *signp; ! 679: { ! 680: register struct IEEEdp { ! 681: unsigned sign:1; ! 682: unsigned exp:11; ! 683: unsigned manh:20; ! 684: unsigned manl:32; ! 685: } *ip = (struct IEEEdp *)&d; ! 686: ! 687: if (ip->exp != 0x7ff) ! 688: return(0); ! 689: if (ip->manh || ip->manl) ! 690: (void)strcpy(bufp, "NaN"); ! 691: else ! 692: (void)strcpy(bufp, "Inf"); ! 693: return(3); ! 694: } ! 695: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.