A number of updates from Manuel Novoa III. Things look good...

1 files changed, 398 insertions, 220 deletions

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 <sys/types.h>
 #include <fcntl.h>
 #include <string.h>
 #include <stdlib.h>
 
+#if WANT_GNU_ERRNO
+#include <errno.h>
+#endif
+
 #ifdef __STDC__
 #include <stdarg.h>
 #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[] = "<LONG-LONG>";
+#endif
 
-	return (cnt);
-}
+#if !WANT_DOUBLE && WANT_DOUBLE_ERROR
+static const char dbl_err[] = "<DOUBLE>";
+#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);
 }