handle exponents greater than 2 digits

[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 713b479..4985e70 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.12 (Berkeley) %G%";
+static char sccsid[] = "@(#)vfprintf.c 5.27 (Berkeley) %G%";

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


@@ -19,64 +19,79 @@ static char sccsid[] = "@(#)vfprintf.c      5.12 (Berkeley) %G%";
 #include <stdio.h>
 #include <ctype.h>
 
 #include <stdio.h>
 #include <ctype.h>
 

-#define        MAXBUF  40
+/* 11-bit exponent (VAX G floating point) is 308 decimal digits */
+#define        MAXEXP          308
+/* 128 bit fraction takes up 39 decimal digits; max reasonable precision */
+#define        MAXFRACT        39

 
 

-#define        PUTC(ch)        {++cnt; putc(ch, fp);}
+#define        BUF             (MAXEXP+MAXFRACT+1)     /* + decimal point */

 
 

-#define        LONGINT         0x01
-#define        LONGDBL         0x02
-#define        SHORTINT        0x04
-#define        GETARG(r) \
-       r = argsize&LONGINT ? va_arg(argp, long) : \
-           argsize&SHORTINT ? va_arg(argp, short) : va_arg(argp, int);
+#define        PUTC(ch)        {++cnt; putc((char)ch, fp);}

 
 

-static int alt;
-static char sign;
+#define        ARG() \
+       _ulong = flags&LONGINT ? va_arg(argp, long) : \
+           flags&SHORTINT ? va_arg(argp, short) : va_arg(argp, int);

 
 

-x_doprnt(fmt, argp, fp)
-       register char *fmt;
+#define        todigit(c)      ((c) - '0')
+#define        tochar(n)       ((n) + '0')
+
+/* have to deal with the negative buffer count kludge */
+#define        NEGATIVE_COUNT_KLUDGE
+
+#define        LONGINT         0x01            /* long integer */
+#define        LONGDBL         0x02            /* long double; unimplemented */
+#define        SHORTINT        0x04            /* short integer */
+#define        ALT             0x08            /* alternate form */
+#define        LADJUST         0x10            /* left adjustment */
+
+_doprnt(fmt0, argp, fp)
+       u_char *fmt0;

        va_list argp;
        register FILE *fp;
 {
        va_list argp;
        register FILE *fp;
 {

-       register int cnt, n;
-       register char ch, *t;
+       register u_char *fmt;
+       register int ch, cnt, n;
+       register char *t;

        double _double;
        u_long _ulong;
        double _double;
        u_long _ulong;

-       int base, ladjust, width, prec, size;
-       char argsize, padc, *digs, *_cvt(), buf[MAXBUF];
+       int base, flags, fpprec, prec, size, width;
+       char padc, sign, *digs, buf[BUF], *_cvt();

 
 

+       fmt = fmt0;

        digs = "0123456789abcdef";
        for (cnt = 0;; ++fmt) {
        digs = "0123456789abcdef";
        for (cnt = 0;; ++fmt) {

-               if ((n = fp->_cnt) >= 0) {
-                       for (t = fp->_ptr; (ch = *fmt) != '%' && ch; ++fmt) {
-                               if (--n < 0)
-                                       break;
-                               *t++ = ch;
-                       }
-                       fp->_ptr = t;
-                       cnt += fp->_cnt - n;
-                       fp->_cnt = n;
-                       if (ch != '%' && ch) {
-                               PUTC(ch);
-                               continue;
+               n = fp->_cnt;
+               for (t = fp->_ptr; (ch = *fmt) && ch != '%'; ++cnt, ++fmt)
+                       if (--n < 0
+#ifdef NEGATIVE_COUNT_KLUDGE
+                           && (!(fp->_flag & _IOLBF) || -n >= fp->_bufsiz)
+#endif
+                           || ch == '\n' && fp->_flag&_IOLBF) {
+                               fp->_cnt = n;
+                               fp->_ptr = t;
+                               (void)_flsbuf(ch, fp);
+                               n = fp->_cnt;
+                               t = fp->_ptr;

                        }
                        }

-               }
-               else for (; *fmt && *fmt != '%'; ++fmt)
-                       PUTC(*fmt);
-
-               if (!*fmt)
+                       else
+                               *t++ = ch;
+               fp->_cnt = n;
+               fp->_ptr = t;
+               if (!ch)

                        return(cnt);
 
                        return(cnt);
 

-               alt = ladjust = width = 0;
+               flags = fpprec = width = 0;

                prec = -1;
                padc = ' ';
                prec = -1;
                padc = ' ';

-               argsize = sign = '\0';
-               t = buf;
+               sign = '\0';

 
 

-flags:         switch (*++fmt) {
+rflag:         switch (*++fmt) {
+               case ' ':
+                       sign = ' ';
+                       goto rflag;

                case '#':
                case '#':

-                       alt = 1;
-                       goto flags;
+                       flags |= ALT;
+                       goto rflag;

                case '*':
                        /*
                         * ``A negative field width argument is taken as a
                case '*':
                        /*
                         * ``A negative field width argument is taken as a


@@ -85,148 +100,235 @@ flags:           switch (*++fmt) {
                         * They don't exclude field widths read from args.
                         */
                        if ((width = va_arg(argp, int)) >= 0)
                         * They don't exclude field widths read from args.
                         */
                        if ((width = va_arg(argp, int)) >= 0)

-                               goto flags;
+                               goto rflag;

                        width = -width;
                        /*FALLTHROUGH*/
                case '-':
                        width = -width;
                        /*FALLTHROUGH*/
                case '-':

-                       ladjust = 1;
-                       goto flags;
+                       flags |= LADJUST;
+                       goto rflag;

                case '+':
                        sign = '+';
                case '+':
                        sign = '+';

-                       goto flags;
+                       goto rflag;

                case '.':
                        if (*++fmt == '*')
                case '.':
                        if (*++fmt == '*')

-                               prec = va_arg(argp, int);
-                       else if (isdigit(*fmt)) {
-                               prec = 0;
+                               n = va_arg(argp, int);
+                       else if (isascii(*fmt) && isdigit(*fmt)) {
+                               n = 0;

                                do {
                                do {

-                                       prec = 10 * prec + *fmt - '0';
-                               } while isdigit(*++fmt);
+                                       n = 10 * n + todigit(*fmt);
+                               } while (isascii(*++fmt) && isdigit(*fmt));

                                --fmt;
                        }
                        else {
                                --fmt;
                        }
                        else {

-                               prec = 0;

                                --fmt;
                                --fmt;

-                               goto flags;
+                               prec = 0;
+                               goto rflag;

                        }
                        }

-                       if (prec < 0)
-                               prec = -1;
-                       goto flags;
+                       prec = n < 0 ? -1 : n;
+                       goto rflag;

                case '0':
                        padc = '0';
                        /*FALLTHROUGH*/
                case '1': case '2': case '3': case '4':
                case '5': case '6': case '7': case '8': case '9':
                case '0':
                        padc = '0';
                        /*FALLTHROUGH*/
                case '1': case '2': case '3': case '4':
                case '5': case '6': case '7': case '8': case '9':

+                       n = 0;

                        do {
                        do {

-                               width = 10 * width + *fmt - '0';
-                       } while isdigit(*++fmt);
+                               n = 10 * n + todigit(*fmt);
+                       } while (isascii(*++fmt) && isdigit(*fmt));
+                       width = n;

                        --fmt;
                        --fmt;

+                       goto rflag;

                case 'L':
                case 'L':

-                       argsize |= LONGDBL;
-                       goto flags;
+                       flags |= LONGDBL;
+                       goto rflag;

                case 'h':
                case 'h':

-                       argsize |= SHORTINT;
-                       goto flags;
+                       flags |= SHORTINT;
+                       goto rflag;

                case 'l':
                case 'l':

-                       argsize |= LONGINT;
-                       goto flags;
+                       flags |= LONGINT;
+                       goto rflag;

                case 'c':
                case 'c':

-                       *t = va_arg(argp, int);
+                       buf[0] = va_arg(argp, int);

                        size = 1;
                        size = 1;

+                       t = buf;

                        goto pforw;
                case 'd':
                        goto pforw;
                case 'd':

-               case 'i': {
-                       long reg_long;
-
-                       GETARG(reg_long);
-                       if (reg_long < 0) {
-                               _ulong = -reg_long;
+               case 'i':
+                       ARG();
+                       if ((long)_ulong < 0) {
+                               _ulong = -_ulong;

                                sign = '-';
                        }
                                sign = '-';
                        }

-                       else {
-                               _ulong = reg_long;
-                       }
-                       if (sign)
-                               PUTC(sign);

                        base = 10;
                        base = 10;

-                       goto num;
-               }
+                       goto number;

                case 'e':
                case 'E':
                case 'f':
                case 'g':
                case 'G':
                        _double = va_arg(argp, double);
                case 'e':
                case 'E':
                case 'f':
                case 'g':
                case 'G':
                        _double = va_arg(argp, double);

-                       size = _cvt(_double, prec, buf, buf + sizeof(buf),
-                           *fmt) - buf;
+                       /*
+                        * don't bother to do unrealistic precision; just
+                        * pad it with zeroes later.  This keeps buffer size
+                        * rational.
+                        */
+                       if (prec > MAXFRACT) {
+                               fpprec = prec - MAXFRACT;
+                               prec = MAXFRACT;
+                       }
+                       size = _cvt(_double, prec, flags, *fmt, padc, &sign,
+                           buf, buf + sizeof(buf)) - buf;
+                       t = buf;
+                       /*
+                        * zero-padded sign put out here; blank padded sign
+                        * placed in number in _cvt().
+                        */
+                       if (sign && padc == '0') {
+                               PUTC(sign);
+                               --width;
+                       }

                        goto pforw;
                case 'n':
                        goto pforw;
                case 'n':

-                       *(va_arg(argp, int *)) = cnt;
+                       if (flags&LONGINT)
+                               *va_arg(argp, long *) = cnt;
+                       else if (flags&SHORTINT)
+                               *va_arg(argp, short *) = cnt;
+                       else
+                               *va_arg(argp, int *) = cnt;

                        break;
                case 'o':
                        break;
                case 'o':

-                       GETARG(_ulong);
+                       ARG();

                        base = 8;
                        base = 8;

-                       goto num;
+                       goto nosign;

                case 'p':
                case 'p':

+                       /*
+                        * ``The argument shall be a pointer to void.  The
+                        * value of the pointer is converted to a sequence
+                        * of printable characters, in an implementation-
+                        * defined manner.''
+                        *      -- ANSI X3J11
+                        */
+                       /*NOSTRICT*/
+                       _ulong = (u_long)va_arg(argp, void *);
+                       base = 16;
+                       goto nosign;

                case 's':
                        if (!(t = va_arg(argp, char *)))
                                t = "(null)";
                case 's':
                        if (!(t = va_arg(argp, char *)))
                                t = "(null)";

-                       if ((size = strlen(t)) > prec && prec >= 0)
-                               size = prec;
-pforw:                 if (!ladjust && width)
-                               for (n = size; n++ < width;)
-                                       PUTC(padc);
-                       if (fp->_cnt - (n = size) >= 0) {
-                               cnt += n;
-                               fp->_cnt -= n;
-                               bcopy(t, fp->_ptr, n);
-                               fp->_ptr += n;
+                       if (prec >= 0) {
+                               /*
+                                * can't use strlen; can only look for the
+                                * NUL in the first `prec' characters, and
+                                * strlen() will go further.
+                                */
+                               char *p, *memchr();
+
+                               if (p = memchr(t, 0, prec)) {
+                                       size = p - t;
+                                       if (size > prec)
+                                               size = prec;
+                               }
+                               else
+                                       size = prec;

                        }
                        }

-                       else for (; n--; ++t)
-                               PUTC(*t);
-                       if (ladjust)
-                               while (width-- > size)
-                                       PUTC(padc);
-                       break;
+                       else
+                               size = strlen(t);
+                       goto pforw;

                case 'u':
                case 'u':

-                       GETARG(_ulong);
+                       ARG();

                        base = 10;
                        base = 10;

-                       goto num;
+                       goto nosign;

                case 'X':
                        digs = "0123456789ABCDEF";
                        /*FALLTHROUGH*/
                case 'x':
                case 'X':
                        digs = "0123456789ABCDEF";
                        /*FALLTHROUGH*/
                case 'x':

-                       GETARG(_ulong);
+                       ARG();

                        base = 16;
                        base = 16;

-                       /* alternate form for hex; leading 0x/X */
-                       if (alt && _ulong) {
-                               PUTC('0');
-                               PUTC(*fmt);
+                       /* leading 0x/X only if non-zero */
+                       if (!_ulong)
+                               flags &= ~ALT;
+
+                       /* unsigned conversions */
+nosign:                        sign = NULL;
+                       /*
+                        * ``... diouXx conversions ... if a precision is
+                        * specified, the 0 flag will be ignored.''
+                        *      -- ANSI X3J11
+                        */
+number:                        if (prec >= 0)
+                               padc = ' ';
+                       /*
+                        * ``The result of converting a zero value with an
+                        * explicit precision of zero is no characters.''
+                        *      -- ANSI X3J11
+                        */
+                       if (!_ulong && !prec) {
+                               size = 0;
+                               goto pforw;

                        }
                        }

-num:                   t = buf + sizeof(buf) - 1;
+
+                       t = buf + BUF - 1;

                        do {
                                *t-- = digs[_ulong % base];
                                _ulong /= base;
                        } while(_ulong);
                        do {
                                *t-- = digs[_ulong % base];
                                _ulong /= base;
                        } while(_ulong);

+                       for (size = buf + BUF - 1 - t; size < prec; ++size)
+                               *t-- = '0';

                        digs = "0123456789abcdef";
                        digs = "0123456789abcdef";

-                       size = buf + sizeof(buf) - 1 - t;
-                       if (size >= prec) {
-                               /* alternate form for octal; leading 0 */
-                               if (t[1] != '0' && alt && *fmt == 'o') {
-                                       *t-- = '0';
+
+                       /* alternate mode for hex and octal numbers */
+                       if (flags&ALT)
+                               switch (base) {
+                               case 16:
+                                       /* avoid "00000x35" */
+                                       if (padc == ' ') {
+                                               *t-- = *fmt;
+                                               *t-- = '0';
+                                               size += 2;
+                                       }
+                                       else {
+                                               PUTC('0');
+                                               PUTC(*fmt);
+                                               width -= 2;
+                                       }
+                                       break;
+                               case 8:
+                                       if (t[1] != '0') {
+                                               *t-- = '0';
+                                               ++size;
+                                       }
+                                       break;
+                               }
+
+                       if (sign) {
+                               /* avoid "0000-3" */
+                               if (padc == ' ') {
+                                       *t-- = sign;

                                        ++size;
                                }
                                        ++size;
                                }

+                               else {
+                                       PUTC(sign);
+                                       --width;
+                               }

                        }
                        }

-                       else
-                               for (; size < prec; ++size)
-                                       *t-- = '0';
-                       if (!ladjust)
-                               while (size++ < width)
+                       ++t;
+
+pforw:                 if (!(flags&LADJUST) && width)
+                               for (n = size + fpprec; n++ < width;)

                                        PUTC(padc);
                                        PUTC(padc);

-                       while (++t < buf + sizeof(buf))
+                       if (fp->_cnt - (n = size) >= 0) {
+                               cnt += n;
+                               fp->_cnt -= n;
+                               bcopy(t, fp->_ptr, n);
+                               fp->_ptr += n;
+                       }
+                       else for (; n--; ++t)

                                PUTC(*t);
                                PUTC(*t);

-                       for (; width > size; --width)
-                               PUTC(padc);
+                       while (fpprec--)
+                               PUTC('0');
+                       if (flags&LADJUST)
+                               for (n = size + fpprec; ++n < width;)
+                                       PUTC(' ');

                        break;
                case '\0':              /* "%?" prints ?, unless ? is NULL */
                        return(cnt);
                        break;
                case '\0':              /* "%?" prints ?, unless ? is NULL */
                        return(cnt);


@@ -243,26 +345,30 @@ num:                      t = buf + sizeof(buf) - 1;
 #define        DEFPREC 6
 
 static char *
 #define        DEFPREC 6
 
 static char *

-_cvt(number, prec, startp, endp, fmtch)
+_cvt(number, prec, flags, fmtch, padc, sign, startp, endp)

        double number;
        register int prec;
        double number;
        register int prec;

-       char *startp, *endp, fmtch;
+       int flags;
+       u_char fmtch;
+       char padc, *sign, *startp, *endp;

 {
 {

-       register char *p;
+       register char *p, *t;

        register int expcnt, format;
        double fract, integer, tmp, modf();
        int decpt;
        register int expcnt, format;
        double fract, integer, tmp, modf();
        int decpt;

-       char *savep;
+       char *savep, exponent[MAXEXP];

 
        if (prec == -1)
                prec = DEFPREC;
 
        if (number < 0) {
 
        if (prec == -1)
                prec = DEFPREC;
 
        if (number < 0) {

-               *startp++ = '-';
+               *sign = '-';

                number = -number;
        }
                number = -number;
        }

-       else if (sign)
-               *startp++ = '+';
+
+       /* if blank padded, add sign in as part of the number */
+       if (*sign && padc == ' ')
+               *startp++ = *sign;

 
        switch(fmtch) {
        case 'e':
 
        switch(fmtch) {
        case 'e':


@@ -284,23 +390,21 @@ _cvt(number, prec, startp, endp, fmtch)
         * in which case we require two digits of precision, as it counts
         * precision differently.
         */
         * in which case we require two digits of precision, as it counts
         * precision differently.
         */

-       decpt = alt || prec > 1 || !(format&GFORMAT) && prec;
+       decpt = flags&ALT || prec > (format&GFORMAT ? 1 : 0);

 
        expcnt = 0;
        p = endp - 1;
        fract = modf(number, &integer);
        if (integer) {
 
        expcnt = 0;
        p = endp - 1;
        fract = modf(number, &integer);
        if (integer) {

-               register char *p2;
-

                /* get integer part of number; count decimal places */
                for (; integer; ++expcnt) {
                        tmp = modf(integer / 10, &integer);
                /* get integer part of number; count decimal places */
                for (; integer; ++expcnt) {
                        tmp = modf(integer / 10, &integer);

-                       *p-- = (int)((tmp + .03) * 10) + '0';
+                       *p-- = tochar((int)((tmp + .03) * 10));

                }
 
                /* copy, in reverse order, to start of buffer */
                }
 
                /* copy, in reverse order, to start of buffer */

-               p2 = startp;
-               *p2++ = *++p;
+               t = startp;
+               *t++ = *++p;

 
                /*
                 * if the format is g/G, and the resulting exponent will be
 
                /*
                 * if the format is g/G, and the resulting exponent will be


@@ -317,19 +421,19 @@ _cvt(number, prec, startp, endp, fmtch)
                                        --prec;
                        }
                        if (decpt)
                                        --prec;
                        }
                        if (decpt)

-                               *p2++ = '.';
-                       for (; ++p < endp && prec; --prec, *p2++ = *p);
+                               *t++ = '.';
+                       for (; ++p < endp && prec; --prec, *t++ = *p);

 
 

-                       /* precision ran out; round number */
+                       /* precision ran out, round */

                        if (p < endp) {
                                if (*p > '4') {
                        if (p < endp) {
                                if (*p > '4') {

-                                       for (savep = p2--;; *p2-- = '0') {
-                                               if (*p2 == '.')
-                                                       --p2;
-                                               if (++*p2 <= '9')
+                                       for (savep = t--;; *t-- = '0') {
+                                               if (*t == '.')
+                                                       --t;
+                                               if (++*t <= '9')

                                                        break;
                                        }
                                                        break;
                                        }

-                                       p2 = savep;
+                                       t = savep;

                                }
                                fract = 0;
                        }
                                }
                                fract = 0;
                        }


@@ -339,42 +443,39 @@ _cvt(number, prec, startp, endp, fmtch)
                 * zeroes, note, have to round first.
                 */
                else if (format&GFORMAT) {
                 * zeroes, note, have to round first.
                 */
                else if (format&GFORMAT) {

-                       for (; ++p < endp && prec; --prec, *p2++ = *p);
+                       for (; ++p < endp && prec; --prec, *t++ = *p);

                        /* precision ran out; round and then add zeroes */
                        if (p < endp) {
                                if (*p > '4') {
                        /* precision ran out; round and then add zeroes */
                        if (p < endp) {
                                if (*p > '4') {

-                                       for (savep = p2--; ++*p2 > '9';
-                                           *p2-- = '0');
-                                       p2 = savep;
+                                       for (savep = t--; ++*t > '9';
+                                           *t-- = '0');
+                                       t = savep;

                                }
                                do {
                                }
                                do {

-                                       *p2++ = '0';
+                                       *t++ = '0';

                                } while (++p < endp);
                                fract = 0;
                        }
                        if (decpt)
                                } while (++p < endp);
                                fract = 0;
                        }
                        if (decpt)

-                               *p2++ = '.';
+                               *t++ = '.';

                }
                /* f format */
                else {
                }
                /* f format */
                else {

-                       for (; ++p < endp; *p2++ = *p);
+                       for (; ++p < endp; *t++ = *p);

                        if (decpt)
                        if (decpt)

-                               *p2++ = '.';
+                               *t++ = '.';

                }
                }

-               p = p2;
+               p = t;

        }
        /*
        }
        /*

-        * it's unclear from the ANSI X3J11 spec if the g/G format should
-        * just result in an empty string, because it's supposed to remove
-        * trailing zeroes.  That seems counter-intuitive, so here it does
-        * what f and e/E do; if no fraction, the number was zero, and if
-        * no precision, can't show anything after the decimal point.
+        * 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';
         */
        else if (!fract || !prec) {
                *startp++ = '0';

-               if (decpt)
+               if (decpt && !(format&GFORMAT))

                        *startp++ = '.';
                        *startp++ = '.';

-               *startp++ = '\0';
+               *startp = '\0';

                return(startp);
        }
        /*
                return(startp);
        }
        /*


@@ -390,7 +491,7 @@ _cvt(number, prec, startp, endp, fmtch)
                                        --expcnt;
                                        continue;
                                }
                                        --expcnt;
                                        continue;
                                }

-                               *p++ = (int)tmp + '0';
+                               *p++ = tochar((int)tmp);

                                break;
                        }
                else
                                break;
                        }
                else


@@ -414,14 +515,13 @@ _cvt(number, prec, startp, endp, fmtch)
                *p++ = '.';
        }
 
                *p++ = '.';
        }
 

-       /* finish out requested precision from fractional value */
-       while (prec--)
-               if (fract) {
-                       fract = modf(fract * 10, &tmp);
-                       *p++ = (int)tmp + '0';
-               }
-               else
-                       *p++ = '0';
+       /* finish out requested precision */
+       while (fract && prec-- > 0) {
+               fract = modf(fract * 10, &tmp);
+               *p++ = tochar((int)tmp);
+       }
+       while (prec-- > 0)
+               *p++ = '0';

 
        /*
         * if any fractional value left, "round" it back up to the beginning
 
        /*
         * if any fractional value left, "round" it back up to the beginning


@@ -450,7 +550,7 @@ _cvt(number, prec, startp, endp, fmtch)
         * 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 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 (!alt) {
+       if (!(flags&ALT)) {

                if (format&GFORMAT)
                        for (; p[-1] == '0'; --p);
                if (format&(GFORMAT|EFORMAT) && p[-1] == '.')
                if (format&GFORMAT)
                        for (; p[-1] == '0'; --p);
                if (format&(GFORMAT|EFORMAT) && p[-1] == '.')


@@ -466,8 +566,18 @@ _cvt(number, prec, startp, endp, fmtch)
                }
                else
                        *p++ = '+';
                }
                else
                        *p++ = '+';

-               *p++ = expcnt / 10 + '0';
-               *p++ = expcnt % 10 + '0';
+               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);
+               }

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