must be sure to always convert b_bno to disk block (db) units

[unix-history] / usr / src / lib / libc / stdio / vfprintf.c

diff --git a/usr/src/lib/libc/stdio/vfprintf.c b/usr/src/lib/libc/stdio/vfprintf.c
index 9ba53c1..ae33134 100644 (file)
--- a/usr/src/lib/libc/stdio/vfprintf.c
+++ b/usr/src/lib/libc/stdio/vfprintf.c
@@ -11,7 +11,7 @@
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)

-static char sccsid[] = "@(#)vfprintf.c 5.30 (Berkeley) %G%";
+static char sccsid[] = "@(#)vfprintf.c 5.33 (Berkeley) %G%";

 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/types.h>


@@ -24,6 +24,8 @@ static char sccsid[] = "@(#)vfprintf.c        5.30 (Berkeley) %G%";
 /* 128 bit fraction takes up 39 decimal digits; max reasonable precision */
 #define        MAXFRACT        39
 
 /* 128 bit fraction takes up 39 decimal digits; max reasonable precision */
 #define        MAXFRACT        39
 

+#define        DEFPREC         6
+

 #define        BUF             (MAXEXP+MAXFRACT+1)     /* + decimal point */
 
 #define        PUTC(ch)        (void) putc(ch, fp)
 #define        BUF             (MAXEXP+MAXFRACT+1)     /* + decimal point */
 
 #define        PUTC(ch)        (void) putc(ch, fp)


@@ -58,19 +60,19 @@ _doprnt(fmt0, argp, fp)
        register char *t;       /* buffer pointer */
        double _double;         /* double precision arguments %[eEfgG] */
        u_long _ulong;          /* integer arguments %[diouxX] */
        register char *t;       /* buffer pointer */
        double _double;         /* double precision arguments %[eEfgG] */
        u_long _ulong;          /* integer arguments %[diouxX] */

-       int flags;              /* flags as above */
+       int base;               /* base for [diouxX] conversion */

        int dprec;              /* decimal precision in [diouxX] */
        int dprec;              /* decimal precision in [diouxX] */

+       int fieldsz;            /* field size expanded by sign, etc */
+       int flags;              /* flags as above */

        int fpprec;             /* `extra' floating precision in [eEfgG] */
        int fpprec;             /* `extra' floating precision in [eEfgG] */

-       int width;              /* width from format (%8d), or 0 */

        int prec;               /* precision from format (%.3d), or -1 */
        int prec;               /* precision from format (%.3d), or -1 */

-       int size;               /* size of converted field or string */
-       int fieldsz;            /* field size expanded by sign, etc */

        int realsz;             /* field size expanded by decimal precision */
        int realsz;             /* field size expanded by decimal precision */

-       char sign;              /* sign prefix (+ - or \0) */
-       int base;               /* base for [diouxX] conversion */
+       int size;               /* size of converted field or string */
+       int width;              /* width from format (%8d), or 0 */
+       char sign;              /* sign prefix (' ', '+', '-', or \0) */
+       char softsign;          /* temporary negative sign for floats */

        char *digs;             /* digits for [diouxX] conversion */
        char buf[BUF];          /* space for %c, %[diouxX], %[eEfgG] */
        char *digs;             /* digits for [diouxX] conversion */
        char buf[BUF];          /* space for %c, %[diouxX], %[eEfgG] */

-       char *_cvt();           /* handles [eEfgG] formats */

 
        if (fp->_flag & _IORW) {
                fp->_flag |= _IOWRT;
 
        if (fp->_flag & _IORW) {
                fp->_flag |= _IOWRT;


@@ -108,7 +110,13 @@ _doprnt(fmt0, argp, fp)
 
 rflag:         switch (*++fmt) {
                case ' ':
 
 rflag:         switch (*++fmt) {
                case ' ':

-                       sign = ' ';
+                       /*
+                        * ``If the space and + flags both appear, the space
+                        * flag will be ignored.''
+                        *      -- ANSI X3J11
+                        */
+                       if (!sign)
+                               sign = ' ';

                        goto rflag;
                case '#':
                        flags |= ALT;
                        goto rflag;
                case '#':
                        flags |= ALT;


@@ -172,6 +180,9 @@ rflag:              switch (*++fmt) {
                        size = 1;
                        sign = '\0';
                        goto pforw;
                        size = 1;
                        sign = '\0';
                        goto pforw;

+               case 'D':
+                       flags |= LONGINT;
+                       /*FALLTHROUGH*/

                case 'd':
                case 'i':
                        ARG();
                case 'd':
                case 'i':
                        ARG();


@@ -188,18 +199,37 @@ rflag:            switch (*++fmt) {
                case 'G':
                        _double = va_arg(argp, double);
                        /*
                case 'G':
                        _double = va_arg(argp, double);
                        /*

-                        * don't bother to do unrealistic precision; just
-                        * pad it with zeroes later.  This keeps buffer size
-                        * rational.
+                        * don't do unrealistic precision; just pad it with
+                        * zeroes later, so buffer size stays rational.

                         */
                        if (prec > MAXFRACT) {
                                if (*fmt != 'g' && *fmt != 'G' || (flags&ALT))
                                        fpprec = prec - MAXFRACT;
                                prec = MAXFRACT;
                        }
                         */
                        if (prec > MAXFRACT) {
                                if (*fmt != 'g' && *fmt != 'G' || (flags&ALT))
                                        fpprec = prec - MAXFRACT;
                                prec = MAXFRACT;
                        }

-                       t = buf;
-                       size = _cvt(_double, prec, flags, *fmt, &sign,
-                                   t, t + sizeof(buf)) - t;
+                       else if (prec == -1)
+                               prec = DEFPREC;
+                       /*
+                        * softsign avoids negative 0 if _double is < 0 and
+                        * no significant digits will be shown
+                        */
+                       if (_double < 0) {
+                               softsign = '-';
+                               _double = -_double;
+                       }
+                       else
+                               softsign = 0;
+                       /*
+                        * cvt may have to round up past the "start" of the
+                        * buffer, i.e. ``intf("%.2f", (double)9.999);'';
+                        * if the first char isn't NULL, it did.
+                        */
+                       *buf = NULL;
+                       size = cvt(_double, prec, flags, &softsign, *fmt, buf,
+                           buf + sizeof(buf));
+                       if (softsign)
+                               sign = '-';
+                       t = *buf ? buf : buf + 1;

                        goto pforw;
                case 'n':
                        if (flags & LONGINT)
                        goto pforw;
                case 'n':
                        if (flags & LONGINT)


@@ -209,6 +239,9 @@ rflag:              switch (*++fmt) {
                        else
                                *va_arg(argp, int *) = cnt;
                        break;
                        else
                                *va_arg(argp, int *) = cnt;
                        break;

+               case 'O':
+                       flags |= LONGINT;
+                       /*FALLTHROUGH*/

                case 'o':
                        ARG();
                        base = 8;
                case 'o':
                        ARG();
                        base = 8;


@@ -246,6 +279,9 @@ rflag:              switch (*++fmt) {
                                size = strlen(t);
                        sign = '\0';
                        goto pforw;
                                size = strlen(t);
                        sign = '\0';
                        goto pforw;

+               case 'U':
+                       flags |= LONGINT;
+                       /*FALLTHROUGH*/

                case 'u':
                        ARG();
                        base = 10;
                case 'u':
                        ARG();
                        base = 10;


@@ -289,22 +325,23 @@ number:                   if ((dprec = prec) >= 0)
 
 pforw:
                        /*
 
 pforw:
                        /*

-                        * All reasonable formats wind up here.  At this
-                        * point, `t' points to a string which (if not
-                        * flags&LADJUST) should be padded out to `width'
-                        * places.  If flags&ZEROPAD, it should first be
-                        * prefixed by any sign or other prefix; otherwise,
-                        * it should be blank padded before the prefix is
-                        * emitted.  After any left-hand padding and
-                        * prefixing, emit zeroes required by a decimal
-                        * [diouxX] precision, then print the string proper,
-                        * then emit zeroes required by any leftover floating
-                        * precision; finally, if LADJUST, pad with blanks.
+                        * All reasonable formats wind up here.  At this point,
+                        * `t' points to a string which (if not flags&LADJUST)
+                        * should be padded out to `width' places.  If
+                        * flags&ZEROPAD, it should first be prefixed by any
+                        * sign or other prefix; otherwise, it should be blank
+                        * padded before the prefix is emitted.  After any
+                        * left-hand padding and prefixing, emit zeroes
+                        * required by a decimal [diouxX] precision, then print
+                        * the string proper, then emit zeroes required by any
+                        * leftover floating precision; finally, if LADJUST,
+                        * pad with blanks.

                         */
 
                         */
 

-                       /* compute actual size, so we know how much to pad */
-                       /* this code is not terribly satisfactory */
-                       /* fieldsz excludes decimal prec; realsz includes it */
+                       /*
+                        * compute actual size, so we know how much to pad
+                        * fieldsz excludes decimal prec; realsz includes it
+                        */

                        fieldsz = size + fpprec;
                        if (sign)
                                fieldsz++;
                        fieldsz = size + fpprec;
                        if (sign)
                                fieldsz++;


@@ -347,7 +384,6 @@ pforw:
                        if (flags & LADJUST)
                                for (n = realsz; n < width; n++)
                                        PUTC(' ');
                        if (flags & LADJUST)
                                for (n = realsz; n < width; n++)
                                        PUTC(' ');

-

                        /* finally, adjust cnt */
                        cnt += width > realsz ? width : realsz;
                        break;
                        /* finally, adjust cnt */
                        cnt += width > realsz ? width : realsz;
                        break;


@@ -361,241 +397,263 @@ pforw:
        /* NOTREACHED */
 }
 
        /* NOTREACHED */
 }
 

-#define        EFORMAT 0x01
-#define        FFORMAT 0x02
-#define        GFORMAT 0x04
-#define        DEFPREC 6
-
-static char *
-_cvt(number, prec, flags, fmtch, sign, startp, endp)
+static
+cvt(number, prec, flags, signp, fmtch, startp, endp)

        double number;
        register int prec;
        int flags;
        u_char fmtch;
        double number;
        register int prec;
        int flags;
        u_char fmtch;

-       char *sign, *startp, *endp;
+       char *signp, *startp, *endp;

 {
        register char *p, *t;
 {
        register char *p, *t;

-       register int expcnt, format;

        double fract, integer, tmp, modf();
        double fract, integer, tmp, modf();

-       int decpt;
-       char *savep, exponent[MAXEXP];
+       int dotrim, expcnt, gformat;
+       char *exponent(), *round();

 
 

-       if (prec == -1)
-               prec = DEFPREC;
+       dotrim = expcnt = gformat = 0;
+       fract = modf(number, &integer);

 
 

-       if (number < 0) {
-               *sign = '-';
-               number = -number;
-       }
-
-       switch(fmtch) {
-       case 'e':
-       case 'E':
-               format = EFORMAT;
-               break;
-       case 'f':
-               format = FFORMAT;
-               break;
-       case 'g':
-       case 'G':
-               format = GFORMAT;
-               fmtch -= 2;
-       }
+       /* get an extra slot for rounding. */
+       t = ++startp;

 
        /*
 
        /*

-        * if the alternate flag is set, or, at least one digit of precision
-        * was requested, add a decimal point, unless it's the g/G format
-        * in which case we require two digits of precision, as it counts
-        * precision differently.
+        * get integer portion of number; put into the end of the buffer; the
+        * .01 is added for modf(356.0 / 10, &integer) returning .59999999...

         */
         */

-       decpt = flags&ALT || prec > (format&GFORMAT ? 1 : 0);
-
-       expcnt = 0;
-       p = endp - 1;
-       fract = modf(number, &integer);
-       if (integer) {
-               /* get integer part of number; count decimal places */
-               for (; integer; ++expcnt) {
-                       tmp = modf(integer / 10, &integer);
-                       *p-- = tochar((int)((tmp + .03) * 10));
-               }
-
-               /* copy, in reverse order, to start of buffer */
-               t = startp;
-               *t++ = *++p;
-
+       for (p = endp - 1; integer; ++expcnt) {
+               tmp = modf(integer / 10, &integer);
+               *p-- = tochar((int)((tmp + .01) * 10));
+       }
+       switch(fmtch) {
+       case 'f':
+               /* reverse integer into beginning of buffer */
+               if (expcnt)
+                       for (; ++p < endp; *t++ = *p);
+               else
+                       *t++ = '0';

                /*
                /*

-                * if the format is g/G, and the resulting exponent will be
-                * greater than the precision, use e/E format.  If e/E format,
-                * put in a decimal point as needed, and decrement precision
-                * count for each digit after the decimal point.
+                * if precision required or alternate flag set, add in a
+                * decimal point.

                 */
                 */

-               if (format&GFORMAT && expcnt - 1 > prec || format&EFORMAT) {
-                       if (format&GFORMAT) {
-                               format |= EFORMAT;
-
-                               /* first digit is precision for g/G format */
-                               if (prec)
-                                       --prec;
-                       }
-                       if (decpt)
+               if (prec || flags&ALT)
+                       *t++ = '.';
+               /* if requires more precision and some fraction left */
+               if (fract) {
+                       if (prec)
+                               do {
+                                       fract = modf(fract * 10, &tmp);
+                                       *t++ = tochar((int)tmp);
+                               } while (--prec && fract);
+                       if (fract)
+                               startp = round(fract, (int *)NULL, startp,
+                                   t - 1, (char)0, signp);
+               }
+               for (; prec--; *t++ = '0');
+               break;
+       case 'e':
+       case 'E':
+eformat:       if (expcnt) {
+                       *t++ = *++p;
+                       if (prec || flags&ALT)

                                *t++ = '.';
                                *t++ = '.';

-                       for (; ++p < endp && prec; --prec, *t++ = *p);
-
-                       /* precision ran out, round */
-                       if (p < endp) {
-                               if (*p > '4') {
-                                       for (savep = t--;; *t-- = '0') {
-                                               if (*t == '.')
-                                                       --t;
-                                               if (++*t <= '9')
-                                                       break;
-                                       }
-                                       t = savep;
-                               }
+                       /* if requires more precision and some integer left */
+                       for (; prec && ++p < endp; --prec)
+                               *t++ = *p;
+                       /*
+                        * if done precision and more of the integer component,
+                        * round using it; adjust fract so we don't re-round
+                        * later.
+                        */
+                       if (!prec && ++p < endp) {

                                fract = 0;
                                fract = 0;

+                               startp = round((double)0, &expcnt, startp,
+                                   t - 1, *p, signp);

                        }
                        }

+                       /* adjust expcnt for digit in front of decimal */
+                       --expcnt;

                }
                }

-               /*
-                * g/G in f format; if out of precision, replace digits with
-                * zeroes, note, have to round first.
-                */
-               else if (format&GFORMAT) {
-                       for (; ++p < endp && prec; --prec, *t++ = *p);
-                       /* precision ran out; round and then add zeroes */
-                       if (p < endp) {
-                               if (*p > '4') {
-                                       for (savep = t--; ++*t > '9';
-                                           *t-- = '0');
-                                       t = savep;
-                               }
-                               do {
-                                       *t++ = '0';
-                               } while (++p < endp);
-                               fract = 0;
+               /* until first fractional digit, decrement exponent */
+               else if (fract) {
+                       /* adjust expcnt for digit in front of decimal */
+                       for (expcnt = -1;; --expcnt) {
+                               fract = modf(fract * 10, &tmp);
+                               if (tmp)
+                                       break;

                        }
                        }

-                       if (decpt)
+                       *t++ = tochar((int)tmp);
+                       if (prec || flags&ALT)

                                *t++ = '.';
                }
                                *t++ = '.';
                }

-               /* f format */

                else {
                else {

-                       for (; ++p < endp; *t++ = *p);
-                       if (decpt)
+                       *t++ = '0';
+                       if (prec || flags&ALT)

                                *t++ = '.';
                }
                                *t++ = '.';
                }

-               p = t;
-       }
-       /*
-        * if no fraction, the number was zero, and if no precision, can't
-        * show anything after the decimal point.
-        */
-       else if (!fract || !prec) {
-               *startp++ = '0';
-               if (decpt && !(format&GFORMAT))
-                       *startp++ = '.';
-               *startp = '\0';
-               return(startp);
-       }
-       /*
-        * if the format is g/G, and the resulting exponent will be less than
-        * -4 use e/E format.  If e/E format, compute exponent value.
-        */
-       else if (format&GFORMAT && fract < .0001 || format&EFORMAT) {
-               format |= EFORMAT;
-               if (fract)
-                       for (p = startp; fract;) {
-                               fract = modf(fract * 10, &tmp);
-                               if (!tmp) {
-                                       --expcnt;
-                                       continue;
+               /* if requires more precision and some fraction left */
+               if (fract) {
+                       if (prec)
+                               do {
+                                       fract = modf(fract * 10, &tmp);
+                                       *t++ = tochar((int)tmp);
+                               } while (--prec && fract);
+                       if (fract)
+                               startp = round(fract, &expcnt, startp,
+                                   t - 1, (char)0, signp);
+               }
+               /* if requires more precision */
+               for (; prec--; *t++ = '0');
+
+               /* unless alternate flag, trim any g/G format trailing 0's */
+               if (gformat && !(flags&ALT)) {
+                       while (t > startp && *--t == '0');
+                       if (*t == '.')
+                               --t;
+                       ++t;
+               }
+               t = exponent(t, expcnt, fmtch);
+               break;
+       case 'g':
+       case 'G':
+               /* a precision of 0 is treated as a precision of 1. */
+               if (!prec)
+                       ++prec;
+               /*
+                * ``The style used depends on the value converted; style e
+                * will be used only if the exponent resulting from the
+                * conversion is less than -4 or greater than the precision.''
+                *      -- ANSI X3J11
+                */
+               if (expcnt > prec || !expcnt && fract && fract < .0001) {
+                       /*
+                        * g/G format counts "significant digits, not digits of
+                        * precision; for the e/E format, this just causes an
+                        * off-by-one problem, i.e. g/G considers the digit
+                        * before the decimal point significant and e/E doesn't
+                        * count it as precision.
+                        */
+                       --prec;
+                       fmtch -= 2;             /* G->E, g->e */
+                       gformat = 1;
+                       goto eformat;
+               }
+               /*
+                * reverse integer into beginning of buffer,
+                * note, decrement precision
+                */
+               if (expcnt)
+                       for (; ++p < endp; *t++ = *p, --prec);
+               else
+                       *t++ = '0';
+               /*
+                * if precision required or alternate flag set, add in a
+                * decimal point.  If no digits yet, add in leading 0.
+                */
+               if (prec || flags&ALT) {
+                       dotrim = 1;
+                       *t++ = '.';
+               }
+               else
+                       dotrim = 0;
+               /* if requires more precision and some fraction left */
+               if (fract) {
+                       if (prec) {
+                               do {
+                                       fract = modf(fract * 10, &tmp);
+                                       *t++ = tochar((int)tmp);
+                               } while(!tmp);
+                               while (--prec && fract) {
+                                       fract = modf(fract * 10, &tmp);
+                                       *t++ = tochar((int)tmp);

                                }
                                }

-                               *p++ = tochar((int)tmp);
-                               break;

                        }
                        }

-               else
-                       *p++ = '0';
-
-               /* g/G format, decrement precision for first digit */
-               if (format&GFORMAT && prec)
-                       --prec;
-
-               /* add decimal after first non-zero digit */
-               if (decpt)
-                       *p++ = '.';
-       }
-       /*
-        * f format or g/G printed as f format; don't worry about decimal
-        * point, if g/G format doesn't need it, will get stripped later.
-        */
-       else {
-               p = startp;
-               *p++ = '0';
-               *p++ = '.';
+                       if (fract)
+                               startp = round(fract, (int *)NULL, startp,
+                                   t - 1, (char)0, signp);
+               }
+               /* alternate format, adds 0's for precision, else trim 0's */
+               if (flags&ALT)
+                       for (; prec--; *t++ = '0');
+               else if (dotrim) {
+                       while (t > startp && *--t == '0');
+                       if (*t != '.')
+                               ++t;
+               }

        }
        }

+       return(t - startp);
+}

 
 

-       /* finish out requested precision */
-       while (fract && prec-- > 0) {
-               fract = modf(fract * 10, &tmp);
-               *p++ = tochar((int)tmp);
-       }
-       while (prec-- > 0)
-               *p++ = '0';
+static char *
+round(fract, exp, start, end, ch, signp)
+       double fract;
+       int *exp;
+       register char *start, *end;
+       char ch, *signp;
+{
+       double tmp;

 
 

-       /*
-        * if any fractional value left, "round" it back up to the beginning
-        * of the number, fixing the exponent as necessary, and avoiding the
-        * decimal point.
-        */
-       if (fract) {
+       if (fract)

                (void)modf(fract * 10, &tmp);
                (void)modf(fract * 10, &tmp);

-               if (tmp > 4) {
-                       for (savep = p--;; *p-- = '0') {
-                               if (*p == '.')
-                                       --p;
-                               if (p == startp) {
-                                       *p = '1';
-                                       ++expcnt;
-                                       break;
+       else
+               tmp = todigit(ch);
+       if (tmp > 4)
+               for (;; --end) {
+                       if (*end == '.')
+                               --end;
+                       if (++*end <= '9')
+                               break;
+                       *end = '0';
+                       if (end == start) {
+                               if (exp) {      /* e/E; increment exponent */
+                                       *end = '1';
+                                       ++*exp;

                                }
                                }

-                               if (++*p <= '9')
-                                       break;
+                               else {          /* f; add extra digit */
+                                       *--end = '1';
+                                       --start;
+                               }
+                               break;

                        }
                        }

-                       p = savep;

                }
                }

-       }
+       /* ``"%.3f", (double)-0.0004'' gives you a negative 0. */
+       else if (*signp == '-')
+               for (;; --end) {
+                       if (*end == '.')
+                               --end;
+                       if (*end != '0')
+                               break;
+                       if (end == start)
+                               *signp = 0;
+               }
+       return(start);
+}

 
 

-       /*
-        * if a g/G format and not alternate flag, lose trailing zeroes,
-        * if e/E or g/G format, and last char is decimal point, lose it.
-        */
-       if (!(flags&ALT)) {
-               if (format&GFORMAT)
-                       for (; p[-1] == '0'; --p);
-               if (format&(GFORMAT|EFORMAT) && p[-1] == '.')
-                       --p;
-       }
+static char *
+exponent(p, exp, fmtch)
+       register char *p;
+       register int exp;
+       u_char fmtch;
+{
+       register char *t;
+       char expbuf[MAXEXP];

 
 

-       /* if an e/E format, add exponent */
-       if (format&EFORMAT) {
-               *p++ = fmtch;
-               if (--expcnt < 0) {
-                       expcnt = -expcnt;
-                       *p++ = '-';
-               }
-               else
-                       *p++ = '+';
-               t = exponent + MAXEXP;
-               if (expcnt > 9) {
-                       do {
-                               *--t = tochar(expcnt % 10);
-                       } while ((expcnt /= 10) > 9);
-                       *--t = tochar(expcnt);
-                       for (; t < exponent + MAXEXP; *p++ = *t++);
-               }
-               else {
-                       *p++ = '0';
-                       *p++ = tochar(expcnt);
-               }
+       *p++ = fmtch;
+       if (exp < 0) {
+               exp = -exp;
+               *p++ = '-';
+       }
+       else
+               *p++ = '+';
+       t = expbuf + MAXEXP;
+       if (exp > 9) {
+               do {
+                       *--t = tochar(exp % 10);
+               } while ((exp /= 10) > 9);
+               *--t = tochar(exp);
+               for (; t < expbuf + MAXEXP; *p++ = *t++);
+       }
+       else {
+               *p++ = '0';
+               *p++ = tochar(exp);

        }
        return(p);
 }
        }
        return(p);
 }