![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iovfprintf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / libg++ / libio|
Return to iovfprintf.c CVS log | Up to [Apple XNU] / GNUtools / libg++ / libio |
1.1 root 1: /*
2: Copyright (C) 1993 Free Software Foundation
3:
4: This file is part of the GNU IO Library. This library is free
5: software; you can redistribute it and/or modify it under the
6: terms of the GNU General Public License as published by the
7: Free Software Foundation; either version 2, or (at your option)
8: any later version.
9:
10: This library is distributed in the hope that it will be useful,
11: but WITHOUT ANY WARRANTY; without even the implied warranty of
12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: GNU General Public License for more details.
14:
15: You should have received a copy of the GNU General Public License
16: along with GNU CC; see the file COPYING. If not, write to
17: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
18:
19: As a special exception, if you link this library with files
20: compiled with a GNU compiler to produce an executable, this does not cause
21: the resulting executable to be covered by the GNU General Public License.
22: This exception does not however invalidate any other reasons why
23: the executable file might be covered by the GNU General Public License. */
24:
25: /*
26: * Copyright (c) 1990 Regents of the University of California.
27: * All rights reserved.
28: *
29: * Redistribution and use in source and binary forms are permitted
30: * provided that the above copyright notice and this paragraph are
31: * duplicated in all such forms and that any documentation,
32: * advertising materials, and other materials related to such
33: * distribution and use acknowledge that the software was developed
34: * by the University of California, Berkeley. The name of the
35: * University may not be used to endorse or promote products derived
36: * from this software without specific prior written permission.
37: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
38: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
39: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
40: */
41:
42:
43: #if defined(LIBC_SCCS) && !defined(lint)
44: static char sccsid[] = "%W% (Berkeley) %G%";
45: #endif /* LIBC_SCCS and not lint */
46:
47: /*
48: * Actual printf innards.
49: *
50: * This code is large and complicated...
51: */
52:
53: #include <sys/types.h>
54: #include "libioP.h"
55: #include <string.h>
56: #ifdef __STDC__
57: #include <stdarg.h>
58: #else
59: #include <varargs.h>
60: #endif
61:
62: /*
63: * Define FLOATING_POINT to get floating point.
64: */
65: #ifndef NO_FLOATING_POINT
66: #define FLOATING_POINT
67: #endif
68:
69: /* end of configuration stuff */
70:
71:
72: /*
73: * Helper "class" for `fprintf to unbuffered': creates a
74: * temporary buffer. */
75:
76: struct helper_file
77: {
78: struct _IO_FILE_plus _f;
79: _IO_FILE *_put_stream;
80: };
81:
82: static int
83: _IO_helper_overflow (fp, c)
84: _IO_FILE *fp;
85: int c;
86: {
87: _IO_FILE *target = ((struct helper_file*)fp)->_put_stream;
88: int used = fp->_IO_write_ptr - fp->_IO_write_base;
89: if (used)
90: {
91: _IO_sputn(target, fp->_IO_write_base, used);
92: fp->_IO_write_ptr -= used;
93: }
94: return _IO_putc (c, fp);
95: }
96:
97: static struct _IO_jump_t _IO_helper_jumps = {
98: _IO_helper_overflow,
99: _IO_default_underflow,
100: _IO_default_xsputn,
101: _IO_default_xsgetn,
102: _IO_default_read,
103: _IO_default_write,
104: _IO_default_doallocate,
105: _IO_default_pbackfail,
106: _IO_default_setbuf,
107: _IO_default_sync,
108: _IO_default_finish,
109: _IO_default_close,
110: _IO_default_stat,
111: _IO_default_seek,
112: _IO_default_seekoff,
113: _IO_default_seekpos,
114: };
115:
116: static int
117: helper_vfprintf(fp, fmt0, ap)
118: register _IO_FILE* fp;
119: char const *fmt0;
120: _IO_va_list ap;
121: {
122: char buf[_IO_BUFSIZ];
123: struct helper_file helper;
124: register _IO_FILE *hp = (_IO_FILE*)&helper;
125: int result, to_flush;
126:
127: /* initialize helper */
128: helper._put_stream = fp;
129: hp->_IO_write_base = buf;
130: hp->_IO_write_ptr = buf;
131: hp->_IO_write_end = buf+_IO_BUFSIZ;
132: hp->_jumps = &_IO_helper_jumps;
133:
134: /* Now print to helper instead. */
135: result = _IO_vfprintf(hp, fmt0, ap);
136:
137: /* Now flush anything from the helper to the fp. */
138: if ((to_flush = hp->_IO_write_ptr - hp->_IO_write_base) > 0)
139: {
140: if (_IO_sputn(fp, hp->_IO_write_base, to_flush) != to_flush)
141: return EOF;
142: }
143: return result;
144: }
145:
146: #ifdef FLOATING_POINT
147:
148: #include "floatio.h"
149: #define BUF (MAXEXP+MAXFRACT+1) /* + decimal point */
150: #define DEFPREC 6
151: extern double modf _PARAMS((double, double*));
152:
153: #else /* no FLOATING_POINT */
154:
155: #define BUF 40
156:
157: #endif /* FLOATING_POINT */
158:
159:
160: /*
161: * Macros for converting digits to letters and vice versa
162: */
163: #define to_digit(c) ((c) - '0')
164: #define is_digit(c) ((unsigned)to_digit(c) <= 9)
165: #define to_char(n) ((n) + '0')
166:
167: /*
168: * Flags used during conversion.
169: */
170: #define LONGINT 0x01 /* long integer */
171: #define LONGDBL 0x02 /* long double; unimplemented */
172: #define SHORTINT 0x04 /* short integer */
173: #define ALT 0x08 /* alternate form */
174: #define LADJUST 0x10 /* left adjustment */
175: #define ZEROPAD 0x20 /* zero (as opposed to blank) pad */
176: #define HEXPREFIX 0x40 /* add 0x or 0X prefix */
177:
178: int
179: _IO_vfprintf(fp, fmt0, ap)
180: register _IO_FILE* fp;
181: char const *fmt0;
182: _IO_va_list ap;
183: {
184: register const char *fmt; /* format string */
185: register int ch; /* character from fmt */
186: register int n; /* handy integer (short term usage) */
187: register char *cp; /* handy char pointer (short term usage) */
188: const char *fmark; /* for remembering a place in fmt */
189: register int flags; /* flags as above */
190: int ret; /* return value accumulator */
191: int width; /* width from format (%8d), or 0 */
192: int prec; /* precision from format (%.3d), or -1 */
193: char sign; /* sign prefix (' ', '+', '-', or \0) */
194: #ifdef FLOATING_POINT
195: int softsign; /* temporary negative sign for floats */
196: double _double; /* double precision arguments %[eEfgG] */
197: #ifndef USE_DTOA
198: int fpprec; /* `extra' floating precision in [eEfgG] */
199: #endif
200: #endif
201: unsigned long _ulong; /* integer arguments %[diouxX] */
202: enum { OCT, DEC, HEX } base;/* base for [diouxX] conversion */
203: int dprec; /* a copy of prec if [diouxX], 0 otherwise */
204: int dpad; /* extra 0 padding needed for integers */
205: int fieldsz; /* field size expanded by sign, dpad etc */
206: /* The initialization of 'size' is to suppress a warning that
207: 'size' might be used unitialized. It seems gcc can't
208: quite grok this spaghetti code ... */
209: int size = 0; /* size of converted field or string */
210: char buf[BUF]; /* space for %c, %[diouxX], %[eEfgG] */
211: char ox[2]; /* space for 0x hex-prefix */
212:
213: /*
214: * BEWARE, these `goto error' on error, and PAD uses `n'.
215: */
216: #define PRINT(ptr, len) \
217: do { if (_IO_sputn(fp,ptr, len) != len) goto error; } while (0)
218: #define PAD_SP(howmany) if (_IO_padn(fp, ' ', howmany) < (howmany)) goto error;
219: #define PAD_0(howmany) if (_IO_padn(fp, '0', howmany) < (howmany)) goto error;
220:
221: /*
222: * To extend shorts properly, we need both signed and unsigned
223: * argument extraction methods.
224: */
225: #define SARG() \
226: (flags&LONGINT ? va_arg(ap, long) : \
227: flags&SHORTINT ? (long)(short)va_arg(ap, int) : \
228: (long)va_arg(ap, int))
229: #define UARG() \
230: (flags&LONGINT ? va_arg(ap, unsigned long) : \
231: flags&SHORTINT ? (unsigned long)(unsigned short)va_arg(ap, int) : \
232: (unsigned long)va_arg(ap, unsigned int))
233:
234: /* optimise stderr (and other unbuffered Unix files) */
235: if (fp->_IO_file_flags & _IO_UNBUFFERED)
236: return helper_vfprintf(fp, fmt0, ap);
237:
238: fmt = fmt0;
239: ret = 0;
240:
241: /*
242: * Scan the format for conversions (`%' character).
243: */
244: for (;;) {
245: for (fmark = fmt; (ch = *fmt) != '\0' && ch != '%'; fmt++)
246: /* void */;
247: if ((n = fmt - fmark) != 0) {
248: PRINT(fmark, n);
249: ret += n;
250: }
251: if (ch == '\0')
252: goto done;
253: fmt++; /* skip over '%' */
254:
255: flags = 0;
256: dprec = 0;
257: #if defined(FLOATING_POINT) && !defined (USE_DTOA)
258: fpprec = 0;
259: #endif
260: width = 0;
261: prec = -1;
262: sign = '\0';
263:
264: rflag: ch = *fmt++;
265: reswitch: switch (ch) {
266: case ' ':
267: /*
268: * ``If the space and + flags both appear, the space
269: * flag will be ignored.''
270: * -- ANSI X3J11
271: */
272: if (!sign)
273: sign = ' ';
274: goto rflag;
275: case '#':
276: flags |= ALT;
277: goto rflag;
278: case '*':
279: /*
280: * ``A negative field width argument is taken as a
281: * - flag followed by a positive field width.''
282: * -- ANSI X3J11
283: * They don't exclude field widths read from args.
284: */
285: if ((width = va_arg(ap, int)) >= 0)
286: goto rflag;
287: width = -width;
288: /* FALLTHROUGH */
289: case '-':
290: flags |= LADJUST;
291: flags &= ~ZEROPAD; /* '-' disables '0' */
292: goto rflag;
293: case '+':
294: sign = '+';
295: goto rflag;
296: case '.':
297: if ((ch = *fmt++) == '*') {
298: n = va_arg(ap, int);
299: prec = n < 0 ? -1 : n;
300: goto rflag;
301: }
302: n = 0;
303: while (is_digit(ch)) {
304: n = 10 * n + to_digit(ch);
305: ch = *fmt++;
306: }
307: prec = n < 0 ? -1 : n;
308: goto reswitch;
309: case '0':
310: /*
311: * ``Note that 0 is taken as a flag, not as the
312: * beginning of a field width.''
313: * -- ANSI X3J11
314: */
315: if (!(flags & LADJUST))
316: flags |= ZEROPAD; /* '-' disables '0' */
317: goto rflag;
318: case '1': case '2': case '3': case '4':
319: case '5': case '6': case '7': case '8': case '9':
320: n = 0;
321: do {
322: n = 10 * n + to_digit(ch);
323: ch = *fmt++;
324: } while (is_digit(ch));
325: width = n;
326: goto reswitch;
327: #ifdef FLOATING_POINT
328: case 'L':
329: flags |= LONGDBL;
330: goto rflag;
331: #endif
332: case 'h':
333: flags |= SHORTINT;
334: goto rflag;
335: case 'l':
336: flags |= LONGINT;
337: goto rflag;
338: case 'c':
339: *(cp = buf) = va_arg(ap, int);
340: size = 1;
341: sign = '\0';
342: break;
343: case 'D':
344: flags |= LONGINT;
345: /*FALLTHROUGH*/
346: case 'd':
347: case 'i':
348: _ulong = SARG();
349: if ((long)_ulong < 0) {
350: _ulong = -_ulong;
351: sign = '-';
352: }
353: base = DEC;
354: goto number;
355: #ifdef FLOATING_POINT
356: case 'e':
357: case 'E':
358: case 'f':
359: case 'F':
360: case 'g':
361: case 'G':
362: _double = va_arg(ap, double);
363: #ifdef USE_DTOA
364: {
365: int fmt_flags = 0;
366: int fill = ' ';
367: if (flags & ALT)
368: fmt_flags |= _IO_SHOWPOINT;
369: if (flags & LADJUST)
370: fmt_flags |= _IO_LEFT;
371: else if (flags & ZEROPAD)
372: fmt_flags |= _IO_INTERNAL, fill = '0';
373: n = _IO_outfloat(_double, fp, ch, width,
374: prec < 0 ? DEFPREC : prec,
375: fmt_flags, sign, fill);
376: if (n < 0)
377: goto error;
378: ret += n;
379: }
380: /* CHECK ERROR! */
381: continue;
382: #else
383: /*
384: * don't do unrealistic precision; just pad it with
385: * zeroes later, so buffer size stays rational.
386: */
387: if (prec > MAXFRACT) {
388: if ((ch != 'g' && ch != 'G') || (flags&ALT))
389: fpprec = prec - MAXFRACT;
390: prec = MAXFRACT;
391: } else if (prec == -1)
392: prec = DEFPREC;
393: /* __cvt_double may have to round up before the
394: "start" of its buffer, i.e.
395: ``intf("%.2f", (double)9.999);'';
396: if the first character is still NUL, it did.
397: softsign avoids negative 0 if _double < 0 but
398: no significant digits will be shown. */
399: cp = buf;
400: *cp = '\0';
401: size = __cvt_double(_double, prec, flags, &softsign,
402: ch, cp, buf + sizeof(buf));
403: if (softsign)
404: sign = '-';
405: if (*cp == '\0')
406: cp++;
407: break;
408: #endif
409: #endif /* FLOATING_POINT */
410: case 'n':
411: if (flags & LONGINT)
412: *va_arg(ap, long *) = ret;
413: else if (flags & SHORTINT)
414: *va_arg(ap, short *) = ret;
415: else
416: *va_arg(ap, int *) = ret;
417: continue; /* no output */
418: case 'O':
419: flags |= LONGINT;
420: /*FALLTHROUGH*/
421: case 'o':
422: _ulong = UARG();
423: base = OCT;
424: goto nosign;
425: case 'p':
426: /*
427: * ``The argument shall be a pointer to void. The
428: * value of the pointer is converted to a sequence
429: * of printable characters, in an implementation-
430: * defined manner.''
431: * -- ANSI X3J11
432: */
433: /* NOSTRICT */
434: _ulong = (unsigned long)va_arg(ap, void *);
435: base = HEX;
436: flags |= HEXPREFIX;
437: ch = 'x';
438: goto nosign;
439: case 's':
440: if ((cp = va_arg(ap, char *)) == NULL)
441: cp = "(null)";
442: if (prec >= 0) {
443: /*
444: * can't use strlen; can only look for the
445: * NUL in the first `prec' characters, and
446: * strlen() will go further.
447: */
448: char *p = (char*)memchr(cp, 0, prec);
449:
450: if (p != NULL) {
451: size = p - cp;
452: if (size > prec)
453: size = prec;
454: } else
455: size = prec;
456: } else
457: size = strlen(cp);
458: sign = '\0';
459: break;
460: case 'U':
461: flags |= LONGINT;
462: /*FALLTHROUGH*/
463: case 'u':
464: _ulong = UARG();
465: base = DEC;
466: goto nosign;
467: case 'X':
468: case 'x':
469: _ulong = UARG();
470: base = HEX;
471: /* leading 0x/X only if non-zero */
472: if (flags & ALT && _ulong != 0)
473: flags |= HEXPREFIX;
474:
475: /* unsigned conversions */
476: nosign: sign = '\0';
477: /*
478: * ``... diouXx conversions ... if a precision is
479: * specified, the 0 flag will be ignored.''
480: * -- ANSI X3J11
481: */
482: number: if ((dprec = prec) >= 0)
483: flags &= ~ZEROPAD;
484:
485: /*
486: * ``The result of converting a zero value with an
487: * explicit precision of zero is no characters.''
488: * -- ANSI X3J11
489: */
490: cp = buf + BUF;
491: if (_ulong != 0 || prec != 0) {
492: char *xdigs; /* digits for [xX] conversion */
493: /*
494: * unsigned mod is hard, and unsigned mod
495: * by a constant is easier than that by
496: * a variable; hence this switch.
497: */
498: switch (base) {
499: case OCT:
500: do {
501: *--cp = to_char(_ulong & 7);
502: _ulong >>= 3;
503: } while (_ulong);
504: /* handle octal leading 0 */
505: if (flags & ALT && *cp != '0')
506: *--cp = '0';
507: break;
508:
509: case DEC:
510: /* many numbers are 1 digit */
511: while (_ulong >= 10) {
512: *--cp = to_char(_ulong % 10);
513: _ulong /= 10;
514: }
515: *--cp = to_char(_ulong);
516: break;
517:
518: case HEX:
519: if (ch == 'X')
520: xdigs = "0123456789ABCDEF";
521: else /* ch == 'x' || ch == 'p' */
522: xdigs = "0123456789abcdef";
523: do {
524: *--cp = xdigs[_ulong & 15];
525: _ulong >>= 4;
526: } while (_ulong);
527: break;
528:
529: default:
530: cp = "bug in vform: bad base";
531: goto skipsize;
532: }
533: }
534: size = buf + BUF - cp;
535: skipsize:
536: break;
537: default: /* "%?" prints ?, unless ? is NUL */
538: if (ch == '\0')
539: goto done;
540: /* pretend it was %c with argument ch */
541: cp = buf;
542: *cp = ch;
543: size = 1;
544: sign = '\0';
545: break;
546: }
547:
548: /*
549: * All reasonable formats wind up here. At this point,
550: * `cp' points to a string which (if not flags&LADJUST)
551: * should be padded out to `width' places. If
552: * flags&ZEROPAD, it should first be prefixed by any
553: * sign or other prefix; otherwise, it should be blank
554: * padded before the prefix is emitted. After any
555: * left-hand padding and prefixing, emit zeroes
556: * required by a decimal [diouxX] precision, then print
557: * the string proper, then emit zeroes required by any
558: * leftover floating precision; finally, if LADJUST,
559: * pad with blanks.
560: */
561:
562: /*
563: * compute actual size, so we know how much to pad.
564: */
565: #if defined(FLOATING_POINT) && !defined (USE_DTOA)
566: fieldsz = size + fpprec;
567: #else
568: fieldsz = size;
569: #endif
570: dpad = dprec - size;
571: if (dpad < 0)
572: dpad = 0;
573:
574: if (sign)
575: fieldsz++;
576: else if (flags & HEXPREFIX)
577: fieldsz += 2;
578: fieldsz += dpad;
579:
580: /* right-adjusting blank padding */
581: if ((flags & (LADJUST|ZEROPAD)) == 0)
582: PAD_SP(width - fieldsz);
583:
584: /* prefix */
585: if (sign) {
586: PRINT(&sign, 1);
587: } else if (flags & HEXPREFIX) {
588: ox[0] = '0';
589: ox[1] = ch;
590: PRINT(ox, 2);
591: }
592:
593: /* right-adjusting zero padding */
594: if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
595: PAD_0(width - fieldsz);
596:
597: /* leading zeroes from decimal precision */
598: PAD_0(dpad);
599:
600: /* the string or number proper */
601: PRINT(cp, size);
602:
603: #if defined(FLOATING_POINT) && !defined (USE_DTOA)
604: /* trailing f.p. zeroes */
605: PAD_0(fpprec);
606: #endif
607:
608: /* left-adjusting padding (always blank) */
609: if (flags & LADJUST)
610: PAD_SP(width - fieldsz);
611:
612: /* finally, adjust ret */
613: ret += width > fieldsz ? width : fieldsz;
614:
615: }
616: done:
617: return ret;
618: error:
619: return EOF;
620: /* NOTREACHED */
621: }
622:
623: #if defined(FLOATING_POINT) && !defined(USE_DTOA)
624:
625: static char *exponent(register char *p, register int exp, int fmtch)
626: {
627: register char *t;
628: char expbuf[MAXEXP];
629:
630: *p++ = fmtch;
631: if (exp < 0) {
632: exp = -exp;
633: *p++ = '-';
634: }
635: else
636: *p++ = '+';
637: t = expbuf + MAXEXP;
638: if (exp > 9) {
639: do {
640: *--t = to_char(exp % 10);
641: } while ((exp /= 10) > 9);
642: *--t = to_char(exp);
643: for (; t < expbuf + MAXEXP; *p++ = *t++);
644: }
645: else {
646: *p++ = '0';
647: *p++ = to_char(exp);
648: }
649: return (p);
650: }
651:
652: static char * round(double fract, int *exp,
653: register char *start, register char *end,
654: char ch, int *signp)
655: {
656: double tmp;
657:
658: if (fract)
659: (void)modf(fract * 10, &tmp);
660: else
661: tmp = to_digit(ch);
662: if (tmp > 4)
663: for (;; --end) {
664: if (*end == '.')
665: --end;
666: if (++*end <= '9')
667: break;
668: *end = '0';
669: if (end == start) {
670: if (exp) { /* e/E; increment exponent */
671: *end = '1';
672: ++*exp;
673: }
674: else { /* f; add extra digit */
675: *--end = '1';
676: --start;
677: }
678: break;
679: }
680: }
681: /* ``"%.3f", (double)-0.0004'' gives you a negative 0. */
682: else if (*signp == '-')
683: for (;; --end) {
684: if (*end == '.')
685: --end;
686: if (*end != '0')
687: break;
688: if (end == start)
689: *signp = 0;
690: }
691: return (start);
692: }
693:
694: int __cvt_double(double number, register int prec, int flags, int *signp,
695: int fmtch, char *startp, char *endp)
696: {
697: register char *p, *t;
698: register double fract;
699: int dotrim = 0, expcnt, gformat = 0;
700: double integer, tmp;
701:
702: expcnt = 0;
703: if (number < 0) {
704: number = -number;
705: *signp = '-';
706: } else
707: *signp = 0;
708:
709: fract = modf(number, &integer);
710:
711: /* get an extra slot for rounding. */
712: t = ++startp;
713:
714: /*
715: * get integer portion of number; put into the end of the buffer; the
716: * .01 is added for modf(356.0 / 10, &integer) returning .59999999...
717: */
718: for (p = endp - 1; integer; ++expcnt) {
719: tmp = modf(integer / 10, &integer);
720: *p-- = to_char((int)((tmp + .01) * 10));
721: }
722: switch (fmtch) {
723: case 'f':
724: case 'F':
725: /* reverse integer into beginning of buffer */
726: if (expcnt)
727: for (; ++p < endp; *t++ = *p);
728: else
729: *t++ = '0';
730: /*
731: * if precision required or alternate flag set, add in a
732: * decimal point.
733: */
734: if (prec || flags&ALT)
735: *t++ = '.';
736: /* if requires more precision and some fraction left */
737: if (fract) {
738: if (prec)
739: do {
740: fract = modf(fract * 10, &tmp);
741: *t++ = to_char((int)tmp);
742: } while (--prec && fract);
743: if (fract)
744: startp = round(fract, (int *)NULL, startp,
745: t - 1, (char)0, signp);
746: }
747: for (; prec--; *t++ = '0');
748: break;
749: case 'e':
750: case 'E':
751: eformat: if (expcnt) {
752: *t++ = *++p;
753: if (prec || flags&ALT)
754: *t++ = '.';
755: /* if requires more precision and some integer left */
756: for (; prec && ++p < endp; --prec)
757: *t++ = *p;
758: /*
759: * if done precision and more of the integer component,
760: * round using it; adjust fract so we don't re-round
761: * later.
762: */
763: if (!prec && ++p < endp) {
764: fract = 0;
765: startp = round((double)0, &expcnt, startp,
766: t - 1, *p, signp);
767: }
768: /* adjust expcnt for digit in front of decimal */
769: --expcnt;
770: }
771: /* until first fractional digit, decrement exponent */
772: else if (fract) {
773: /* adjust expcnt for digit in front of decimal */
774: for (expcnt = -1;; --expcnt) {
775: fract = modf(fract * 10, &tmp);
776: if (tmp)
777: break;
778: }
779: *t++ = to_char((int)tmp);
780: if (prec || flags&ALT)
781: *t++ = '.';
782: }
783: else {
784: *t++ = '0';
785: if (prec || flags&ALT)
786: *t++ = '.';
787: }
788: /* if requires more precision and some fraction left */
789: if (fract) {
790: if (prec)
791: do {
792: fract = modf(fract * 10, &tmp);
793: *t++ = to_char((int)tmp);
794: } while (--prec && fract);
795: if (fract)
796: startp = round(fract, &expcnt, startp,
797: t - 1, (char)0, signp);
798: }
799: /* if requires more precision */
800: for (; prec--; *t++ = '0');
801:
802: /* unless alternate flag, trim any g/G format trailing 0's */
803: if (gformat && !(flags&ALT)) {
804: while (t > startp && *--t == '0');
805: if (*t == '.')
806: --t;
807: ++t;
808: }
809: t = exponent(t, expcnt, fmtch);
810: break;
811: case 'g':
812: case 'G':
813: /* a precision of 0 is treated as a precision of 1. */
814: if (!prec)
815: ++prec;
816: /*
817: * ``The style used depends on the value converted; style e
818: * will be used only if the exponent resulting from the
819: * conversion is less than -4 or greater than the precision.''
820: * -- ANSI X3J11
821: */
822: if (expcnt > prec || (!expcnt && fract && fract < .0001)) {
823: /*
824: * g/G format counts "significant digits, not digits of
825: * precision; for the e/E format, this just causes an
826: * off-by-one problem, i.e. g/G considers the digit
827: * before the decimal point significant and e/E doesn't
828: * count it as precision.
829: */
830: --prec;
831: fmtch -= 2; /* G->E, g->e */
832: gformat = 1;
833: goto eformat;
834: }
835: /*
836: * reverse integer into beginning of buffer,
837: * note, decrement precision
838: */
839: if (expcnt)
840: for (; ++p < endp; *t++ = *p, --prec);
841: else
842: *t++ = '0';
843: /*
844: * if precision required or alternate flag set, add in a
845: * decimal point. If no digits yet, add in leading 0.
846: */
847: if (prec || flags&ALT) {
848: dotrim = 1;
849: *t++ = '.';
850: }
851: else
852: dotrim = 0;
853: /* if requires more precision and some fraction left */
854: if (fract) {
855: if (prec) {
856: /* If no integer part, don't count initial
857: * zeros as significant digits. */
858: do {
859: fract = modf(fract * 10, &tmp);
860: *t++ = to_char((int)tmp);
861: } while(!tmp && !expcnt);
862: while (--prec && fract) {
863: fract = modf(fract * 10, &tmp);
864: *t++ = to_char((int)tmp);
865: }
866: }
867: if (fract)
868: startp = round(fract, (int *)NULL, startp,
869: t - 1, (char)0, signp);
870: }
871: /* alternate format, adds 0's for precision, else trim 0's */
872: if (flags&ALT)
873: for (; prec--; *t++ = '0');
874: else if (dotrim) {
875: while (t > startp && *--t == '0');
876: if (*t != '.')
877: ++t;
878: }
879: }
880: return (t - startp);
881: }
882:
883: #endif /* defined(FLOATING_POINT) && !defined(USE_DTOA) */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.