From c6218dbae579de0cd20f5a7f1e9877673e28225d Mon Sep 17 00:00:00 2001 From: Eric Andersen Date: Wed, 20 Dec 2000 22:52:58 +0000 Subject: A number of updates from Manuel Novoa III. Things look good... --- libc/stdio/printf.c | 618 +++++++++++++++++++++++++++++++++------------------- 1 file changed, 398 insertions(+), 220 deletions(-) (limited to 'libc/stdio/printf.c') diff --git a/libc/stdio/printf.c b/libc/stdio/printf.c index d987966f6..634885e67 100644 --- a/libc/stdio/printf.c +++ b/libc/stdio/printf.c @@ -17,11 +17,92 @@ * -RDB */ +/* + * Manuel Novoa III Dec 2000 + * + * The previous vfprintf routine was almost completely rewritten with the + * goal of fixing some shortcomings and reducing object size. + * + * The summary of changes: + * + * Converted print conversion specification parsing from one big switch + * to a method using string tables. This new method verifies that the + * conversion flags, field width, precision, qualifier, and specifier + * appear in the correct order. Many questionable specifications were + * accepted by the previous code. This new method also resulted in a + * substantial reduction in object size of about 330 bytes (20%) from + * the old version (1627 bytes) on i386, even with the following + * improvements. + * + * Implemented %n specifier as required by the standards. + * Implemented proper handling of precision for int types. + * Implemented # for hex and pointer, fixed error for octal rep of 0. + * Implemented return of -1 on stream error. + * + * Added optional support for the GNU extension %m which prints the string + * corresponding the errno. + * + * Added optional support for long long ints and unsigned long long ints + * using the conversion qualifiers "ll", "L", or "q" (like glibc). + * + * Added optional support for doubles in a very limited form. None of + * the formating options are obeyed. The string returned by __dtostr + * is printed directly. + * + * Converted to use my (un)signed long (long) to string routines, which are + * smaller than the previous functions and don't require static buffers. + * + */ + +/*****************************************************************************/ +/* OPTIONS */ +/*****************************************************************************/ +/* The optional support for long longs and doubles comes in two forms. + * + * 1) Normal (or partial for doubles) output support. Set to 1 to turn on. + * Adds about 54 byes and about 217 bytes for long longss to the base size + * of 1298. (Bizarre: both turned on is smaller than WANT_LONG_LONG only.) + */ + +#define WANT_LONG_LONG 0 +#define WANT_DOUBLE 0 + +/* 2) An error message is inserted into the stream, an arg of the + * appropriate size is removed from the arglist, and processing + * continues. This is adds less code and may be useful in some + * cases. Set to 1 to turn on. Adds about 31 bytes for doubles + * and about 54 bytes for long longs to the base size of 1298. + */ + +#define WANT_LONG_LONG_ERROR 0 +#define WANT_DOUBLE_ERROR 0 + +/* + * Set to support GNU extension of %m to print string corresponding to errno. + * + * Warning: This adds about 50 bytes (i386) to the code but it also pulls in + * strerror and the corresponding string table which together are about 3.8k. + */ + +#define WANT_GNU_ERRNO 0 + +/* + * Use fputc instead of macro putc. Slower but saves about 36 bytes. + */ + +#define WANT_FPUTC 0 + +/**************************************************************************/ + #include #include #include #include +#if WANT_GNU_ERRNO +#include +#endif + #ifdef __STDC__ #include #define va_strt va_start @@ -32,14 +113,16 @@ #include "stdio.h" +#if WANT_FPUTC +#undef putc +#define putc(c,s) fputc(c,s) +#endif extern int vfnprintf(FILE * op, size_t max_size, register __const char *fmt, register va_list ap); - - #ifdef L_printf int printf(const char *fmt, ...) { @@ -150,93 +233,64 @@ int vsnprintf(char *sp, size_t size, __const char *fmt, va_list ap) #ifdef L_vfprintf -#if FLOATS -int _vfprintf_fp_ref = 1; +extern char *__ultostr(char *buf, unsigned long uval, int base, int uppercase); +extern char *__ltostr(char *buf, long val, int base, int uppercase); +extern char *__ulltostr(char *buf, unsigned long long uval, int base, int uppercase); +extern char *__lltostr(char *buf, long long val, int base, int uppercase); +extern char *__dtostr(char *buf, double x); + +enum { + FLAG_PLUS = 0, + FLAG_MINUS_LJUSTIFY, + FLAG_HASH, + FLAG_0_PAD, + FLAG_SPACE, +}; + +/* layout 01234 */ +static const char spec[] = "+-#0 "; + +#if WANT_LONG_LONG || WANT_LONG_LONG_ERROR +static const char qual[] = "hlLq"; #else -int _vfprintf_fp_ref = 0; +static const char qual[] = "hl"; #endif -static int -printfield(op, buf, ljustf, sign, pad, width, preci, buffer_mode, max_size, - current_size) -register FILE *op; -register unsigned char *buf; -int ljustf; -register char sign; -char pad; -register int width; -int preci; -int buffer_mode; -size_t max_size; -size_t current_size; - -/* - * Output the given field in the manner specified by the arguments. Return - * the number of characters output. - */ -{ - register int cnt = 0, len; - register unsigned char ch; - - len = strlen(buf); - - if (*buf == '-') - sign = *buf++; - else if (sign) - len++; - - if ((preci != -1) && (len > preci)) /* limit max data width */ - len = preci; - - if (width < len) /* flexible field width or width overflow */ - width = len; - - /* - * at this point: width = total field width len = actual data width - * (including possible sign character) - */ - cnt = width; - width -= len; - - while (width || len) { - if (!ljustf && width) { /* left padding */ - if (len && sign && (pad == '0')) - goto showsign; - ch = pad; - --width; - } else if (len) { - if (sign) { - showsign:ch = sign; - /* sign */ - sign = '\0'; - } else - ch = *buf++; /* main field */ - --len; - } else { - ch = pad; /* right padding */ - --width; - } - current_size++; - if (max_size > 0 && current_size < max_size) - putc(ch, op); - if (ch == '\n' && buffer_mode == _IOLBF) - fflush(op); - } +#if !WANT_LONG_LONG && WANT_LONG_LONG_ERROR +static const char ll_err[] = ""; +#endif - return (cnt); -} +#if !WANT_DOUBLE && WANT_DOUBLE_ERROR +static const char dbl_err[] = ""; +#endif +#if WANT_DOUBLE || WANT_DOUBLE_ERROR +/* layout 012345678901234567 */ +static const char u_spec[] = "%nbopxXudicsfgGeEaA"; +#else +/* layout 0123456789012 */ +static const char u_spec[] = "%nbopxXudics0"; +#endif +/* WARNING: u_spec and u_radix need to stay in agreement!!! */ +/* u_radix[i] <-> u_spec[i+2] for unsigned entries only */ +static const char u_radix[] = "\x02\x08\x10\x10\x10\x0a"; -int vfnprintf(FILE * op, size_t max_size, register __const char *fmt, - register va_list ap) +int vfnprintf(FILE * op, size_t max_size, const char *fmt, va_list ap) { - register int i, cnt = 0, ljustf, lval; - int preci, dpoint, width; - char pad, sign, radix, hash; - register char *ptmp; - char tmp[64], *ltostr(), *ultostr(); + int i, cnt = 0, lval; + char *p; + const char *fmt0; int buffer_mode; + int preci, width; +#define upcase i + int radix, dpoint /*, upcase*/; +#if WANT_LONG_LONG + char tmp[65]; +#else + char tmp[33]; +#endif + char flag[sizeof(spec)]; /* This speeds things up a bit for unbuffered */ buffer_mode = (op->mode & __MODE_BUF); @@ -244,172 +298,296 @@ int vfnprintf(FILE * op, size_t max_size, register __const char *fmt, while (*fmt) { if (*fmt == '%') { - if (buffer_mode == _IONBF) + fmt0 = fmt; /* save our position in case of bad format */ + ++fmt; + if (buffer_mode == _IONBF) { fflush(op); - ljustf = 0; /* left justify flag */ - sign = '\0'; /* sign char & status */ - pad = ' '; /* justification padding char */ + } width = -1; /* min field width */ - dpoint = 0; /* found decimal point */ - preci = -1; /* max data width */ + preci = -5; /* max string width or mininum digits */ radix = 10; /* number base */ - ptmp = tmp; /* pointer to area to print */ - hash = 0; + dpoint = 0; /* found decimal point */ lval = (sizeof(int) == sizeof(long)); /* long value flaged */ - fmtnxt: - i = 0; - for (;;) { - ++fmt; - if (*fmt < '0' || *fmt > '9') - break; - i = (i * 10) + (*fmt - '0'); - if (dpoint) - preci = i; - else if (!i && (pad == ' ')) { - pad = '0'; - goto fmtnxt; - } else - width = i; - } - - switch (*fmt) { - case '\0': /* early EOS */ - --fmt; - goto charout; + tmp[1] = 0; /* set things up for %c -- better done here */ - case '-': /* left justification */ - ljustf = 1; - goto fmtnxt; + /* init flags */ + for (p =(char *) spec ; *p ; p++) { + flag[p-spec] = '\0'; + } + flag[FLAG_0_PAD] = ' '; - case ' ': - case '+': /* leading sign flag */ - sign = *fmt; - goto fmtnxt; + /* process optional flags */ + for (p = (char *)spec ; *p ; p++) { + if (*fmt == *p) { + flag[p-spec] = *fmt++; + p = (char *)spec; /* restart scan */ + } + } + + if (!flag[FLAG_PLUS]) { + flag[FLAG_PLUS] = flag[FLAG_SPACE]; + } - case '*': /* parameter width value */ - i = va_arg(ap, int); + /* process optional width and precision */ + do { + if (*fmt == '.') { + ++fmt; + dpoint = 1; + } + if (*fmt == '*') { /* parameter width value */ + ++fmt; + i = va_arg(ap, int); + } else { + for ( i = 0 ; (*fmt >= '0') && (*fmt <= '9') ; ++fmt ) { + i = (i * 10) + (*fmt - '0'); + } + } - if (dpoint) + if (dpoint) { preci = i; - else + if (i<0) { + preci = 0; + } + } else { width = i; - goto fmtnxt; - - case '.': /* secondary width field */ - dpoint = 1; - goto fmtnxt; - - case 'l': /* long data */ - lval = 1; - goto fmtnxt; + if (i<0) { + width = -i; + flag[FLAG_MINUS_LJUSTIFY] = 1; + } + } + } while ((*fmt == '.') && !dpoint ); + + /* process optional qualifier */ + for (p = (char *) qual ; *p ; p++) { + if (*p == *fmt) { + lval = p - qual; + ++fmt; +#if WANT_LONG_LONG || WANT_LONG_LONG_ERROR + if ((*p == 'l') && (*fmt == *p)) { + ++lval; + ++fmt; + } +#endif /* WANT_LONG_LONG || WANT_LONG_LONG_ERROR */ + } + } - case 'h': /* short data */ - lval = 0; - goto fmtnxt; +#if WANT_GNU_ERRNO + if (*fmt == 'm') { + flag[FLAG_PLUS] = '\0'; + flag[FLAG_0_PAD] = ' '; + p = strerror(errno); + goto print; + } +#endif - case 'd': /* Signed decimal */ - case 'i': - ptmp = ltostr((long) ((lval) + /* process format specifier */ + for (p = (char *) u_spec ; *p ; p++) { + if (*fmt != *p) continue; + if (p-u_spec < 1) { /* print a % */ + goto charout; + } + if (p-u_spec < 2) { /* store output count in int ptr */ + *(va_arg(ap, int *)) = cnt; + goto nextfmt; + } + if (p-u_spec < 8) { /* unsigned conversion */ + radix = u_radix[p-u_spec-2]; + upcase = ((int)'x') - *p; + if (*p == 'p') { + lval = (sizeof(char *) == sizeof(long)); + upcase = 0; + } +#if WANT_LONG_LONG || WANT_LONG_LONG_ERROR + if (lval >= 2) { +#if WANT_LONG_LONG + p = __ulltostr(tmp + sizeof(tmp) - 1, + va_arg(ap, unsigned long long), + radix, upcase); +#else + (void) va_arg(ap, unsigned long long); /* cary on */ + p = (char *) ll_err; +#endif /* WANT_LONG_LONG */ + } else { +#endif /* WANT_LONG_LONG || WANT_LONG_LONG_ERROR */ + p = __ultostr(tmp + sizeof(tmp) - 1, (unsigned long) + ((lval) + ? va_arg(ap, unsigned long) + : va_arg(ap, unsigned short)), + radix, upcase); +#if WANT_LONG_LONG || WANT_LONG_LONG_ERROR + } +#endif /* WANT_LONG_LONG || WANT_LONG_LONG_ERROR */ + flag[FLAG_PLUS] = '\0'; /* meaningless for unsigned */ + if (flag[FLAG_HASH]) { + switch (radix) { + case 16: + flag[FLAG_PLUS] = '0'; + *--p = 'x'; + if (*fmt == 'X') { + *p = 'X'; + } + break; + case 8: + if (*p != '0') { /* if not zero */ + *--p = '0'; /* add leadding zero */ + } + } + } + } else if (p-u_spec < 10) { /* signed conversion */ +#if WANT_LONG_LONG || WANT_LONG_LONG_ERROR + if (lval >= 2) { +#if WANT_LONG_LONG + p = __lltostr(tmp + sizeof(tmp) - 1, + va_arg(ap, long long), 10, 0); +#else + (void) va_arg(ap, long long); /* carry on */ + p = (char *) ll_err; +#endif /* WANT_LONG_LONG */ + } else { +#endif /* WANT_LONG_LONG || WANT_LONG_LONG_ERROR */ + p = __ltostr(tmp + sizeof(tmp) - 1, (long) + ((lval) ? va_arg(ap, long) : va_arg(ap, short)), 10, 0); +#if WANT_LONG_LONG || WANT_LONG_LONG_ERROR + } +#endif /* WANT_LONG_LONG || WANT_LONG_LONG_ERROR */ + } else if (p-u_spec < 12) { /* character or string */ + flag[FLAG_PLUS] = '\0'; + flag[FLAG_0_PAD] = ' '; + if (*p == 'c') { /* character */ + p = tmp; + *p = va_arg(ap, int); + } else { /* string */ + p = va_arg(ap, char *); + } +#if WANT_DOUBLE || WANT_DOUBLE_ERROR + } else if (p-u_spec < 27) { /* floating point */ +#endif /* WANT_DOUBLE || WANT_DOUBLE_ERROR */ +#if WANT_DOUBLE + p = __dtostr(tmp + sizeof(tmp) - 1, va_arg(ap, double)); +#elif WANT_DOUBLE_ERROR + (void) va_arg(ap,double); /* carry on */ + p = (char *) dbl_err; +#endif /* WANT_DOUBLE */ + } - goto printit; - - case 'b': /* Unsigned binary */ - radix = 2; - goto usproc; - - case 'o': /* Unsigned octal */ - radix = 8; - goto usproc; - - case 'p': /* Pointer */ - lval = (sizeof(char *) == sizeof(long)); - - pad = '0'; - width = 6; - preci = 8; - /* fall thru */ - - case 'x': /* Unsigned hexadecimal */ - case 'X': - radix = 16; - /* fall thru */ +#if WANT_GNU_ERRNO + print: +#endif + { /* this used to be printfield */ + int len; - case 'u': /* Unsigned decimal */ - usproc: - ptmp = ultostr((unsigned long) ((lval) - ? va_arg(ap, unsigned long) - : va_arg(ap, - unsigned short)), - radix, (*fmt == 'X') ? 1 : 0); + /* cheaper than strlen call */ + for ( len = 0 ; p[len] ; len++ ) { } - if (hash && radix == 8) { - width = strlen(ptmp) + 1; - pad = '0'; - } - goto printit; - - case '#': - hash = 1; - goto fmtnxt; - - case 'c': /* Character */ - ptmp[0] = va_arg(ap, int); - - ptmp[1] = '\0'; - goto nopad; - - case 's': /* String */ - ptmp = va_arg(ap, char *); - - nopad: - sign = '\0'; - pad = ' '; - printit: - cnt += printfield(op, ptmp, ljustf, sign, pad, width, - preci, buffer_mode, max_size, cnt); - break; - -#if FLOATS - case 'e': /* float */ - case 'f': - case 'g': - case 'E': - case 'G': - fprintf(stderr, "LIBM:PRINTF"); - gcvt(va_arg(ap, double), preci, ptmp); - - preci = -1; - goto printit; -#else - case 'e': /* float */ - case 'f': - case 'g': - case 'E': - case 'G': - fprintf(stderr, "LIBC:PRINTF"); - exit(-1); + if ((*p == '-') +#if WANT_GNU_ERRNO + && (*fmt != 'm') #endif - - default: /* unknown character */ - goto charout; + && (*fmt != 's')) { + flag[FLAG_PLUS] = *p++; + --len; + } + if (flag[FLAG_PLUS]) { + ++len; + ++preci; + if (flag[FLAG_PLUS] == '0') { /* base 16 */ + ++preci; /* account for x or X */ + } + } + + if (preci >= 0) { + if ((*fmt == 's') +#if WANT_GNU_ERRNO + || (*fmt == 'm') +#endif + ) { + len = preci; + } + preci -= len; + if (preci < 0) { + preci = 0; + } + width -= preci; + } + + width -= len; + if (width < 0) { + width = 0; + } + + if (preci < 0) { + preci = 0; + if (flag[FLAG_PLUS] + && !flag[FLAG_MINUS_LJUSTIFY] + && (flag[FLAG_0_PAD] == '0')) { + preci = width; + width = 0; + } + } + + while (width + len + preci) { + unsigned char ch; + /* right padding || left padding */ + if ((!len && !preci) + || (width && !flag[FLAG_MINUS_LJUSTIFY])) { + ch = ' '; + --width; + } else if (flag[FLAG_PLUS]) { + ch = flag[FLAG_PLUS]; /* sign */ + if (flag[FLAG_PLUS]=='0') { /* base 16 case */ + flag[FLAG_PLUS] = *p++; /* get the x|X */ + } else { + flag[FLAG_PLUS] = '\0'; + } + --len; + } else if (preci) { + ch = '0'; + --preci; + } else { + ch = *p++; /* main field */ + --len; + } + + if (++cnt < max_size) { + putc(ch, op); + } + if ((ch == '\n') && (buffer_mode == _IOLBF)) { + fflush(op); + } + } + } + goto nextfmt; } - } else { - charout: - if (max_size > 0 && ++cnt < max_size) - putc(*fmt, op); /* normal char out */ - if (*fmt == '\n' && buffer_mode == _IOLBF) - fflush(op); + + fmt = fmt0; /* this was an illegal format */ + } + + charout: + if (++cnt < max_size) { + putc(*fmt, op); /* normal char out */ + } + if ((*fmt == '\n') && (buffer_mode == _IOLBF)) { + fflush(op); } + + nextfmt: ++fmt; } + op->mode |= buffer_mode; - if (buffer_mode == _IONBF) + if (buffer_mode == _IONBF) { fflush(op); - if (buffer_mode == _IOLBF) + } + if (buffer_mode == _IOLBF) { op->bufwrite = op->bufstart; + } + + if (ferror(op)) { + cnt = -1; + } return (cnt); } -- cgit v1.2.3