Implement several of the c99 updates to printf(3):

 - New length modifiers: hh, j, t, z.
 - New flag: '.  Note that %'f is not yet implemented.
 - Use "inf"/"nan" for efg formats, "INF"/"NAN" for EFG formats.
 - Implemented %q in terms of %ll; if "quad_t" is not "long long"
   %q will break.

Still to do:
 - %C, %S, %lc, %ls (wide character support)
 - %'f (thousands in integer portion of %f)
 - %a/%A (exact hex representation of floating-point numbers)

Garrett Wollman wrote the first version of the vfprintf.c update;
Mike Barcroft wrote the first version of the printf.3 changes.

2 files changed, 458 insertions, 211 deletions

diff --git a/lib/libc/stdio/printf.3 b/lib/libc/stdio/printf.3
index 784bb77..d9cbd95 100644
--- a/lib/libc/stdio/printf.3
+++ b/lib/libc/stdio/printf.3
@@ -36,7 +36,7 @@
 .\"     @(#)printf.3	8.1 (Berkeley) 6/4/93
 .\" $FreeBSD$
 .\"
-.Dd June 4, 1993
+.Dd November 8, 2001
 .Dt PRINTF 3
 .Os
 .Sh NAME
@@ -191,12 +191,9 @@ If unaccessed arguments in the format string are interspersed with ones that
 are accessed the results will be indeterminate.
 .It
 Zero or more of the following flags:
-.Bl -hyphen
-.It
-A
-.Cm #
-character
-specifying that the value should be converted to an
+.Bl -tag -width ".So \&\ \& Sc (space)" -compact -offset indent
+.It Sq Cm #
+The value should be converted to an
 .Dq alternate form .
 For
 .Cm c , d , i , n , p , s ,
@@ -220,7 +217,7 @@ for
 .Cm X
 conversions) prepended to it.
 For
-.Cm e , E , f , g ,
+.Cm a , A , e , E , f , F , g ,
 and
 .Cm G
 conversions, the result will always contain a decimal point, even if no
@@ -232,11 +229,8 @@ and
 .Cm G
 conversions, trailing zeros are not removed from the result as they
 would otherwise be.
-.It
-A
-.Cm 0
-(zero)
-character specifying zero padding.
+.It So Cm 0 Sc (zero)
+Zero padding.
 For all conversions except
 .Cm n ,
 the converted value is padded on the left with zeros rather than blanks.
@@ -247,10 +241,9 @@ and
 the
 .Cm 0
 flag is ignored.
-.It
-A negative field width flag
-.Cm \-
-indicates the converted value is to be left adjusted on the field boundary.
+.It Sq Cm \&\-
+A negative field width flag;
+the converted value is to be left adjusted on the field boundary.
 Except for
 .Cm n
 conversions, the converted value is padded on the right with blanks,
@@ -260,20 +253,30 @@ A
 overrides a
 .Cm 0
 if both are given.
-.It
-A space, specifying that a blank should be left before a positive number
+.It So \&\ \& Sc (space)
+A blank should be left before a positive number
 produced by a signed conversion
-.Cm ( d , e , E , f , g , G ,
+.Cm ( a , A , d , e , E , f , F , g , G ,
 or
 .Cm i ) .
-.It
-A
-.Cm +
-character specifying that a sign always be placed before a
+.It Sq Cm +
+A sign must always be placed before a
 number produced by a signed conversion.
 A
 .Cm +
 overrides a space if both are used.
+.It Sq Cm '
+Decimal conversions
+.Cm ( d , u ,
+or
+.Cm i )
+or the integral portion of a floating point conversion
+.Cm ( f
+or
+.Cm F )
+should be grouped and separated by thousands using
+the non-monetary seperator returned by
+.Xr localeconv 3 .
 .El
 .It
 An optional decimal digit string specifying a minimum field width.
@@ -292,9 +295,9 @@ This gives the minimum number of digits to appear for
 and
 .Cm X
 conversions, the number of digits to appear after the decimal-point for
-.Cm e , E ,
+.Cm a , A , e , E , f ,
 and
-.Cm f
+.Cm F
 conversions, the maximum number of significant digits for
 .Cm g
 and
@@ -304,79 +307,69 @@ string for
 .Cm s
 conversions.
 .It
-The optional character
-.Cm h ,
-specifying that a following
-.Cm d , i , o , u , x ,
+An optional length modifier, that specifies the size of the argument.
+The following length modifiers are valid for the
+.Cm d , i , n , o , u , x ,
 or
 .Cm X
-conversion corresponds to a
-.Vt short int
-or
-.Vt unsigned short int
-argument, or that a following
-.Cm n
-conversion corresponds to a pointer to a
-.Vt short int
-argument.
-.It
-The optional character
-.Cm l
-(ell) specifying that a following
-.Cm d , i , o , u , x ,
-or
-.Cm X
-conversion applies to a pointer to a
-.Vt long int
-or
-.Vt unsigned long int
-argument, or that a following
-.Cm n
-conversion corresponds to a pointer to a
-.Vt long int
-argument.
-.It
-The optional characters
-.Cm ll
-(ell ell) specifying that a following
-.Cm d , i , o , u , x ,
-or
-.Cm X
-conversion applies to a pointer to a
-.Vt long long int
-or
-.Vt unsigned long long int
-argument, or that a following
-.Cm n
-conversion corresponds to a pointer to a
-.Vt long long int
-argument.
-.It
-The optional character
-.Cm q ,
-specifying that a following
-.Cm d , i , o , u , x ,
+conversion:
+.Bl -column ".Cm q Em (deprecated)" ".Vt signed char" ".Vt unsigned long long" ".Vt unsigned long long *"
+.It Sy Modifier Ta Cm d , i Ta Cm o , u , x , X Ta Cm n
+.It Cm hh Ta Vt signed char Ta Vt unsigned char Ta Vt signed char *
+.It Cm h Ta Vt short Ta Vt unsigned short Ta Vt short *
+.It Cm l No (ell) Ta Vt long Ta Vt unsigned long Ta Vt long *
+.It Cm ll No (ell ell) Ta Vt long long Ta Vt unsigned long long Ta Vt long long *
+.It Cm j Ta Vt intmax_t Ta Vt uintmax_t Ta Vt intmax_t *
+.It Cm t Ta Vt ptrdiff_t Ta Sy * Ta Vt ptrdiff_t *
+.It Cm z Ta Sy * Ta Vt size_t Ta Sy *
+.It Cm q Em (deprecated) Ta Vt quad_t Ta Vt u_quad_t Ta Vt quad_t *
+.El
+.Pp
+.Bl -tag -width ".Cm * No -"
+.It Cm * No -
+The
+.Cm t
+modifier, when applied to a
+.Cm o , u , x ,
 or
 .Cm X
-conversion corresponds to a
-.Vt quad int
-or
-.Vt unsigned quad int
-argument, or that a following
+conversion, indicates that the argument is of an unsigned type
+equivalent in size to a
+.Vt ptrdiff_t .
+The
+.Cm z
+modifier, when applied to a
+.Cm d or
+.Cm i
+conversion, indicates that the argument is of a signed type equivalent in
+size to a
+.Vt size_t .
+Similarly, when applied to an
 .Cm n
-conversion corresponds to a pointer to a
-.Vt quad int
-argument.
-.It
-The character
-.Cm L
-specifying that a following
-.Cm e , E , f , g ,
+conversion, it indicates that the argument is a pointer to a signed type
+equivalent in size to a
+.Vt size_t .
+.El
+.Pp
+The following length modifier is valid for the
+.Cm a , A , e , E , f , F , g ,
 or
 .Cm G
-conversion corresponds to a
-.Vt long double
-argument.
+conversion:
+.Bl -column ".Sy Modifier" ".Cm a , A , e , E , f , F , g , G"
+.It Sy Modifier Ta Cm a , A , e , E , f , F , g , G
+.It Cm L Ta Vt long double
+.El
+.Pp
+The following length modifier is valid for the
+.Cm c
+or
+.Cm s
+conversion:
+.Bl -column ".Sy Modifier" ".Vt wint_t" ".Vt wchar_t *"
+.It Sy Modifier Ta Cm c Ta Cm s
+.It Cm l No (ell) Ta Vt wint_t Ta Vt wchar_t *
+.El
 .It
 A character that specifies the type of conversion to be applied.
 .El
@@ -457,7 +450,26 @@ conversion uses the letter
 to introduce the exponent.
 The exponent always contains at least two digits; if the value is zero,
 the exponent is 00.
-.It Cm f
+.Pp
+For
+.Cm a , A , e , E , f , F , g ,
+and
+.Cm G
+conversions, positive and negative infinity are represented as
+.Li inf
+and
+.Li -inf
+respectively when using the lowercase conversion character, and
+.Li INF
+and 
+.Li -INF
+respectively when using the uppercase conversion character.
+Similarly, NaN is represented as
+.Li nan
+when using the lowercase conversion, and
+.Li NAN
+when using the uppercase conversion.
+.It Cm fF
 The
 .Vt double
 argument is rounded and converted to decimal notation in the style
@@ -475,6 +487,8 @@ argument is converted in style
 or
 .Cm e
 (or
+.Cm F
+or
 .Cm E
 for
 .Cm G
@@ -488,12 +502,74 @@ is used if the exponent from its conversion is less than -4 or greater than
 or equal to the precision.
 Trailing zeros are removed from the fractional part of the result; a
 decimal point appears only if it is followed by at least one digit.
+.It Cm aA
+The
+.Vt double
+argument is converted to hexadecimal notation in the style
+.Oo \- Oc Ns 0xh Ns Cm \&. Ns hhhp Ns Oo +- Oc Ns d ,
+where the number of digits after the hexadecimal-point character
+is equal to the precision specification.
+If the precision is missing, it is taken as enough to exactly
+represent the floating-point number; if the precision is
+explicitly zero, no hexadecimal-point character appears.
+This is an exact coversion of the mantissa+exponent internal
+floating point representation; the
+.Oo \- Oc Ns 0xh Ns Cm \&. Ns hhh
+portion represents exactly the mantissa; only denormalized
+mantissas have a zero value to the left of the hexadecimal
+point.
+The
+.Cm p
+is a literal character
+.Qq p ;
+the exponent is preceded by a positive or negative sign
+and is represented in decimal, using only enough characters
+to represent the exponent.
+The
+.Cm A
+conversion uses the prefix
+.Cm 0X
+(rather than
+.Cm 0x ) ,
+the letters
+.Cm ABCDEF
+(rather than
+.Cm abcdef )
+to represent the hex digits, and the letter
+.Cm P
+(rather than
+.Cm p )
+to seperate the mantissa and exponent.
+
+.It Cm C
+Treated as
+.Cm c
+with the
+.Cm l
+(ell) modifier.
 .It Cm c
 The
 .Vt int
 argument is converted to an
 .Vt unsigned char ,
 and the resulting character is written.
+.Pp
+If the
+.Cm l
+(ell) modifier is used, the
+.Vt wint_t
+argument shall be converted to a
+.Vt wchar_t ,
+and the (potentially multi-byte) sequence representing the
+single wide character is written, including any shift sequences.
+If a shift sequence is used, the shift state is also restored
+to the original state after the character.
+.It Cm S
+Treated as
+.Cm s
+with the
+.Cm l
+(ell) modifier.
 .It Cm s
 The
 .Vt char *
@@ -510,6 +586,30 @@ need be present; if the precision is not specified, or is greater than
 the size of the array, the array must contain a terminating
 .Dv NUL
 character.
+.Pp
+If the
+.Cm l
+(ell) modifier is used, the
+.Vt wchar_t *
+argument is expected to be a pointer to an array of wide characters
+(pointer to a wide string).
+For each wide character in the string, the (potentially multi-byte)
+sequence representing the
+wide character is written, including any shift sequences.
+If any shift sequence is used, the shift state is also restored
+to the original state after the string.
+Wide characters from the array are written up to (but not including)
+a terminating wide
+.Dv NUL
+character;
+if a precision is specified, no more than the number of bytes specified are
+written (including shift sequences).  Partial characters are never written.
+If a precision is given, no null character
+need be present; if the precision is not specified, or is greater than
+the number of bytes required to render the multibyte representation of
+the string, the array must contain a terminating wide
+.Dv NUL
+character.
 .It Cm p
 The
 .Vt void *
@@ -538,7 +638,8 @@ character is defined in the program's locale (category
 .Dv LC_NUMERIC ) .
 .Pp
 In no case does a non-existent or small field width cause truncation of
-a field; if the result of a conversion is wider than the field width, the
+a numeric field; if the result of a conversion is wider than the field
+width, the
 field is expanded to contain the conversion result.
 .Sh EXAMPLES
 To print a date and time in the form
@@ -581,7 +682,8 @@ char *newfmt(const char *fmt, ...)
 .Ed
 .Sh SEE ALSO
 .Xr printf 1 ,
-.Xr scanf 3
+.Xr scanf 3 ,
+.Xr setlocale 3
 .Sh STANDARDS
 The
 .Fn fprintf ,
@@ -675,4 +777,31 @@ for later interpolation by
 .Pp
 Always use the proper secure idiom:
 .Pp
-.Dl snprintf(buffer, sizeof(buffer), "%s", string);
+.Dl snprintf(buffer, sizeof(buffer), \*q%s\*q, string);
+.Pp
+The
+.Nm
+family of functions currently lack the ability to use the
+.Qq '
+flag in conjunction with the
+.Qq f
+conversion specifier.  The
+.Qq a
+and
+.Qq A
+conversion specifiers have not yet been implemented.
+The
+.Qq l
+(ell) modifier for the
+.Qq c
+and
+.Qq s
+conversion specifiers, for wide characters and strings, have not yet
+been implemented.
+The
+.Qq L
+modifier for floating point formats simply round the
+.Vt long double
+argument to
+.Vt double ,
+providing no additional precision.
diff --git a/lib/libc/stdio/vfprintf.c b/lib/libc/stdio/vfprintf.c
index bc0e06e..904fcb0 100644
--- a/lib/libc/stdio/vfprintf.c
+++ b/lib/libc/stdio/vfprintf.c
@@ -51,7 +51,10 @@ static const char rcsid[] =
 #include "namespace.h"
 #include <sys/types.h>
 
+#include <ctype.h>
 #include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -75,26 +78,45 @@ union arg {
 	u_int	uintarg;
 	long	longarg;
 	u_long	ulongarg;
-	quad_t	quadarg;
-	u_quad_t uquadarg;
+	long long longlongarg;
+	unsigned long long ulonglongarg;
+	ptrdiff_t ptrdiffarg;
+	size_t	sizearg;
+	intmax_t intmaxarg;
+	uintmax_t uintmaxarg;
 	void	*pvoidarg;
 	char	*pchararg;
+	signed char *pschararg;
 	short	*pshortarg;
 	int	*pintarg;
 	long	*plongarg;
-	quad_t	*pquadarg;
+	long long *plonglongarg;
+	ptrdiff_t *pptrdiffarg;
+	size_t	*psizearg;
+	intmax_t *pintmaxarg;
 #ifdef FLOATING_POINT
 	double	doublearg;
 	long double longdoublearg;
 #endif
 };
 
+/*
+ * Type ids for argument type table.
+ */
+enum typeid {
+	T_UNUSED, TP_SHORT, T_INT, T_U_INT, TP_INT,
+	T_LONG, T_U_LONG, TP_LONG, T_LLONG, T_U_LLONG, TP_LLONG,
+	T_PTRDIFFT, TP_PTRDIFFT, T_SIZET, TP_SIZET,
+	T_INTMAXT, T_UINTMAXT, TP_INTMAXT, TP_VOID, TP_CHAR, TP_SCHAR,
+	T_DOUBLE, T_LONG_DOUBLE
+};
+
 static int	__sprint __P((FILE *, struct __suio *));
 static int	__sbprintf __P((FILE *, const char *, va_list)) __printflike(2, 0);
-static char *	__ultoa __P((u_long, char *, int, int, char *));
-static char *	__uqtoa __P((u_quad_t, char *, int, int, char *));
+static char *	__ujtoa __P((uintmax_t, char *, int, int, char *, const char *));
+static char *	__ultoa __P((u_long, char *, int, int, char *, const char *));
 static void	__find_arguments __P((const char *, va_list, union arg **));
-static void	__grow_type_table __P((int, unsigned char **, int *));
+static void	__grow_type_table __P((int, enum typeid **, int *));
 
 /*
  * Flush out all the vectors defined by the given uio,
@@ -161,10 +183,12 @@ __sbprintf(FILE *fp, const char *fmt, va_list ap)
  * use the given digits.
  */
 static char *
-__ultoa(u_long val, char *endp, int base, int octzero, char *xdigs)
+__ultoa(u_long val, char *endp, int base, int octzero, char *xdigs,
+	const char *thousep)
 {
 	register char *cp = endp;
 	register long sval;
+	int ndig;
 
 	/*
 	 * Handle the three cases separately, in the hope of getting
@@ -176,6 +200,7 @@ __ultoa(u_long val, char *endp, int base, int octzero, char *xdigs)
 			*--cp = to_char(val);
 			return (cp);
 		}
+		ndig = 0;
 		/*
 		 * On many machines, unsigned arithmetic is harder than
 		 * signed arithmetic, so we do at most one unsigned mod and
@@ -184,11 +209,16 @@ __ultoa(u_long val, char *endp, int base, int octzero, char *xdigs)
 		 */
 		if (val > LONG_MAX) {
 			*--cp = to_char(val % 10);
+			ndig++;
 			sval = val / 10;
 		} else
 			sval = val;
 		do {
 			*--cp = to_char(sval % 10);
+			if (++ndig == 3 && thousep && *thousep != '\0') {
+				*--cp = *thousep;
+				ndig = 0;
+			}
 			sval /= 10;
 		} while (sval != 0);
 		break;
@@ -215,30 +245,39 @@ __ultoa(u_long val, char *endp, int base, int octzero, char *xdigs)
 	return (cp);
 }
 
-/* Identical to __ultoa, but for quads. */
+/* Identical to __ultoa, but for intmax_t. */
 static char *
-__uqtoa(u_quad_t val, char *endp, int base, int octzero, char *xdigs)
+__ujtoa(uintmax_t val, char *endp, int base, int octzero, char *xdigs, 
+	const char *thousep)
 {
 	char *cp = endp;
-	quad_t sval;
+	intmax_t sval;
+	int ndig;
 
 	/* quick test for small values; __ultoa is typically much faster */
 	/* (perhaps instead we should run until small, then call __ultoa?) */
 	if (val <= ULONG_MAX)
-		return (__ultoa((u_long)val, endp, base, octzero, xdigs));
+		return (__ultoa((u_long)val, endp, base, octzero, xdigs,
+		    thousep));
 	switch (base) {
 	case 10:
 		if (val < 10) {
 			*--cp = to_char(val % 10);
 			return (cp);
 		}
-		if (val > QUAD_MAX) {
+		ndig = 0;
+		if (val > INTMAX_MAX) {
 			*--cp = to_char(val % 10);
+			ndig++;
 			sval = val / 10;
 		} else
 			sval = val;
 		do {
 			*--cp = to_char(sval % 10);
+			if (++ndig == 3 && thousep && *thousep != '\0') {
+				*--cp = *thousep;
+				ndig = 0;
+			}
 			sval /= 10;
 		} while (sval != 0);
 		break;
@@ -284,7 +323,7 @@ vfprintf(FILE *fp, const char *fmt0, va_list ap)
 #include <math.h>
 #include "floatio.h"
 
-#define	BUF		(MAXEXP+MAXFRACT+1)	/* + decimal point */
+#define	BUF		((MAXEXP*4/3)+MAXFRACT+1)	/* + decimal point */
 #define	DEFPREC		6
 
 static char *cvt __P((double, int, int, char *, int *, int, int *, char **));
@@ -292,7 +331,7 @@ static int exponent __P((char *, int, int));
 
 #else /* no FLOATING_POINT */
 
-#define	BUF		68
+#define	BUF		90
 
 #endif /* FLOATING_POINT */
 
@@ -306,10 +345,16 @@ static int exponent __P((char *, int, int));
 #define	LADJUST		0x004		/* left adjustment */
 #define	LONGDBL		0x008		/* long double */
 #define	LONGINT		0x010		/* long integer */
-#define	QUADINT		0x020		/* quad integer */
+#define	LLONGINT	0x020		/* long long integer */
 #define	SHORTINT	0x040		/* short integer */
 #define	ZEROPAD		0x080		/* zero (as opposed to blank) pad */
 #define FPT		0x100		/* Floating point number */
+					/* C99 additional size modifiers: */
+#define	SIZET		0x200		/* size_t */
+#define	PTRDIFFT	0x400		/* ptrdiff_t */
+#define	INTMAXT		0x800		/* intmax_t */
+#define	CHARINT		0x1000		/* print char using int format */
+
 /*
  * Non-MT-safe version
  */
@@ -326,8 +371,9 @@ __vfprintf(FILE *fp, const char *fmt0, va_list ap)
 	int width;		/* width from format (%8d), or 0 */
 	int prec;		/* precision from format (%.3d), or -1 */
 	char sign;		/* sign prefix (' ', '+', '-', or \0) */
+	const char *thousands_sep;
 #ifdef FLOATING_POINT
-	char *decimal_point = localeconv()->decimal_point;
+	char *decimal_point;
 	char softsign;		/* temporary negative sign for floats */
 	double _double;		/* double precision arguments %[eEfgG] */
 	int expt;		/* integer value of exponent */
@@ -337,7 +383,7 @@ __vfprintf(FILE *fp, const char *fmt0, va_list ap)
 	char *dtoaresult;	/* buffer allocated by dtoa */
 #endif
 	u_long	ulval;		/* integer arguments %[diouxX] */
-	u_quad_t uqval;		/* %q integers */
+	uintmax_t ujval;	/* %j, %ll, %q, %t, %z integers */
 	int base;		/* base for [diouxX] conversion */
 	int dprec;		/* a copy of prec if [diouxX], 0 otherwise */
 	int realsz;		/* field size expanded by dprec, sign, etc */
@@ -347,9 +393,9 @@ __vfprintf(FILE *fp, const char *fmt0, va_list ap)
 #define NIOV 8
 	struct __suio uio;	/* output information: summary */
 	struct __siov iov[NIOV];/* ... and individual io vectors */
-	char buf[BUF];		/* space for %c, %[diouxX], %[eEfgG] */
+	char buf[BUF];		/* space for %c, %[diouxX], %[eEfFgG] */
 	char ox[2];		/* space for 0x hex-prefix */
-        union arg *argtable;        /* args, built due to positional arg */
+        union arg *argtable;    /* args, built due to positional arg */
         union arg statargtable [STATIC_ARG_TBL_SIZE];
         int nextarg;            /* 1-based argument index */
         va_list orgap;          /* original argument pointer */
@@ -411,11 +457,24 @@ __vfprintf(FILE *fp, const char *fmt0, va_list ap)
 #define	SARG() \
 	(flags&LONGINT ? GETARG(long) : \
 	    flags&SHORTINT ? (long)(short)GETARG(int) : \
+	    flags&CHARINT ? (long)(signed char)GETARG(int) : \
 	    (long)GETARG(int))
 #define	UARG() \
 	(flags&LONGINT ? GETARG(u_long) : \
 	    flags&SHORTINT ? (u_long)(u_short)GETARG(int) : \
+	    flags&CHARINT ? (u_long)(u_char)GETARG(int) : \
 	    (u_long)GETARG(u_int))
+#define	INTMAX_SIZE	(INTMAXT|SIZET|PTRDIFFT|LLONGINT)
+#define SJARG() \
+	(flags&INTMAXT ? GETARG(intmax_t) : \
+	    flags&SIZET ? (intmax_t)GETARG(size_t) : \
+	    flags&PTRDIFFT ? (intmax_t)GETARG(ptrdiff_t) : \
+	    (intmax_t)GETARG(long long))
+#define	UJARG() \
+	(flags&INTMAXT ? GETARG(uintmax_t) : \
+	    flags&SIZET ? (uintmax_t)GETARG(size_t) : \
+	    flags&PTRDIFFT ? (uintmax_t)GETARG(ptrdiff_t) : \
+	    (uintmax_t)GETARG(unsigned long long))
 
         /*
          * Get * arguments, including the form *nn$.  Preserve the nextarg
@@ -443,8 +502,10 @@ __vfprintf(FILE *fp, const char *fmt0, va_list ap)
         }
         
 
+	thousands_sep = NULL;
 #ifdef FLOATING_POINT
 	dtoaresult = NULL;
+	decimal_point = localeconv()->decimal_point;
 #endif
 	/* sorry, fprintf(read_only_file, "") returns EOF, not 0 */
 	if (cantwrite(fp))
@@ -520,6 +581,9 @@ reswitch:	switch (ch) {
 		case '+':
 			sign = '+';
 			goto rflag;
+		case '\'':
+			thousands_sep = localeconv()->thousands_sep;
+			goto rflag;
 		case '.':
 			if ((ch = *fmt++) == '*') {
 				GETASTER (n);
@@ -565,16 +629,30 @@ reswitch:	switch (ch) {
 			goto rflag;
 #endif
 		case 'h':
-			flags |= SHORTINT;
+			if (flags & SHORTINT) {
+				flags &= ~SHORTINT;
+				flags |= CHARINT;
+			} else
+				flags |= SHORTINT;
+			goto rflag;
+		case 'j':
+			flags |= INTMAXT;
 			goto rflag;
 		case 'l':
-			if (flags & LONGINT)
-				flags |= QUADINT;
-			else
+			if (flags & LONGINT) {
+				flags &= ~LONGINT;
+				flags |= LLONGINT;
+			} else
 				flags |= LONGINT;
 			goto rflag;
 		case 'q':
-			flags |= QUADINT;
+			flags |= LLONGINT;	/* not necessarily */
+			goto rflag;
+		case 't':
+			flags |= PTRDIFFT;
+			goto rflag;
+		case 'z':
+			flags |= SIZET;
 			goto rflag;
 		case 'c':
 			*(cp = buf) = GETARG(int);
@@ -586,10 +664,10 @@ reswitch:	switch (ch) {
 			/*FALLTHROUGH*/
 		case 'd':
 		case 'i':
-			if (flags & QUADINT) {
-				uqval = GETARG(quad_t);
-				if ((quad_t)uqval < 0) {
-					uqval = -uqval;
+			if (flags & INTMAX_SIZE) {
+				ujval = SJARG();
+				if ((intmax_t)ujval < 0) {
+					ujval = -ujval;
 					sign = '-';
 				}
 			} else {
@@ -602,9 +680,14 @@ reswitch:	switch (ch) {
 			base = 10;
 			goto number;
 #ifdef FLOATING_POINT
+#ifdef HEXFLOAT
+		case 'a':
+		case 'A':
+#endif
 		case 'e':
 		case 'E':
 		case 'f':
+		case 'F':
 			goto fp_begin;
 		case 'g':
 		case 'G':
@@ -621,12 +704,18 @@ fp_begin:		if (prec == -1)
 			if (isinf(_double)) {
 				if (_double < 0)
 					sign = '-';
-				cp = "Inf";
+				if (isupper(ch))
+					cp = "INF";
+				else
+					cp = "inf";
 				size = 3;
 				break;
 			}
 			if (isnan(_double)) {
-				cp = "NaN";
+				if (isupper(ch))
+					cp = "NAN";
+				else
+					cp = "nan";
 				size = 3;
 				break;
 			}
@@ -643,13 +732,13 @@ fp_begin:		if (prec == -1)
 				else
 					ch = 'g';
 			}
-			if (ch <= 'e') {	/* 'e' or 'E' fmt */
+			if (ch == 'e' || ch == 'E') {
 				--expt;
 				expsize = exponent(expstr, expt, ch);
 				size = expsize + ndig;
 				if (ndig > 1 || flags & ALT)
 					++size;
-			} else if (ch == 'f') {		/* f fmt */
+			} else if (ch == 'f' || ch == 'F') {
 				if (expt > 0) {
 					size = expt;
 					if (prec || flags & ALT)
@@ -669,12 +758,25 @@ fp_begin:		if (prec == -1)
 			break;
 #endif /* FLOATING_POINT */
 		case 'n':
-			if (flags & QUADINT)
-				*GETARG(quad_t *) = ret;
+			/*
+			 * Assignment-like behavior is specified if the
+			 * value overflows or is otherwise unrepresentable.
+			 * C99 says to use `signed char' for %hhn conversions.
+			 */
+			if (flags & LLONGINT)
+				*GETARG(long long *) = ret;
+			else if (flags & SIZET)
+				*GETARG(ssize_t *) = (ssize_t)ret;
+			else if (flags & PTRDIFFT)
+				*GETARG(ptrdiff_t *) = ret;
+			else if (flags & INTMAXT)
+				*GETARG(intmax_t *) = ret;
 			else if (flags & LONGINT)
 				*GETARG(long *) = ret;
 			else if (flags & SHORTINT)
 				*GETARG(short *) = ret;
+			else if (flags & CHARINT)
+				*GETARG(signed char *) = ret;
 			else
 				*GETARG(int *) = ret;
 			continue;	/* no output */
@@ -682,8 +784,8 @@ fp_begin:		if (prec == -1)
 			flags |= LONGINT;
 			/*FALLTHROUGH*/
 		case 'o':
-			if (flags & QUADINT)
-				uqval = GETARG(u_quad_t);
+			if (flags & INTMAX_SIZE)
+				ujval = UJARG();
 			else
 				ulval = UARG();
 			base = 8;
@@ -696,10 +798,10 @@ fp_begin:		if (prec == -1)
 			 * defined manner.''
 			 *	-- ANSI X3J11
 			 */
-			ulval = (u_long)GETARG(void *);
+			ujval = (uintmax_t)(uintptr_t)GETARG(void *);
 			base = 16;
 			xdigs = "0123456789abcdef";
-			flags = (flags & ~QUADINT) | HEXPREFIX;
+			flags = flags | INTMAXT | HEXPREFIX;
 			ch = 'x';
 			goto nosign;
 		case 's':
@@ -727,8 +829,8 @@ fp_begin:		if (prec == -1)
 			flags |= LONGINT;
 			/*FALLTHROUGH*/
 		case 'u':
-			if (flags & QUADINT)
-				uqval = GETARG(u_quad_t);
+			if (flags & INTMAX_SIZE)
+				ujval = UJARG();
 			else
 				ulval = UARG();
 			base = 10;
@@ -738,14 +840,15 @@ fp_begin:		if (prec == -1)
 			goto hex;
 		case 'x':
 			xdigs = "0123456789abcdef";
-hex:			if (flags & QUADINT)
-				uqval = GETARG(u_quad_t);
+hex:
+			if (flags & INTMAX_SIZE)
+				ujval = UJARG();
 			else
 				ulval = UARG();
 			base = 16;
 			/* leading 0x/X only if non-zero */
 			if (flags & ALT &&
-			    (flags & QUADINT ? uqval != 0 : ulval != 0))
+			    (flags & INTMAX_SIZE ? ujval != 0 : ulval != 0))
 				flags |= HEXPREFIX;
 
 			/* unsigned conversions */
@@ -764,14 +867,14 @@ number:			if ((dprec = prec) >= 0)
 			 *	-- ANSI X3J11
 			 */
 			cp = buf + BUF;
-			if (flags & QUADINT) {
-				if (uqval != 0 || prec != 0)
-					cp = __uqtoa(uqval, cp, base,
-					    flags & ALT, xdigs);
+			if (flags & INTMAX_SIZE) {
+				if (ujval != 0 || prec != 0)
+					cp = __ujtoa(ujval, cp, base,
+					    flags & ALT, xdigs, thousands_sep);
 			} else {
 				if (ulval != 0 || prec != 0)
 					cp = __ultoa(ulval, cp, base,
-					    flags & ALT, xdigs);
+					    flags & ALT, xdigs, thousands_sep);
 			}
 			size = buf + BUF - cp;
 			break;
@@ -904,27 +1007,6 @@ error:
 }
 
 /*
- * Type ids for argument type table.
- */
-#define T_UNUSED	0
-#define T_SHORT		1
-#define T_U_SHORT	2
-#define TP_SHORT	3
-#define T_INT		4
-#define T_U_INT		5
-#define TP_INT		6
-#define T_LONG		7
-#define T_U_LONG	8
-#define TP_LONG		9
-#define T_QUAD		10
-#define T_U_QUAD	11
-#define TP_QUAD		12
-#define T_DOUBLE	13
-#define T_LONG_DOUBLE	14
-#define TP_CHAR		15
-#define TP_VOID		16
-
-/*
  * Find all arguments when a positional parameter is encountered.  Returns a
  * table, indexed by argument number, of pointers to each arguments.  The
  * initial argument table should be an array of STATIC_ARG_TBL_SIZE entries.
@@ -939,8 +1021,8 @@ __find_arguments (const char *fmt0, va_list ap, union arg **argtable)
 	char *cp;		/* handy char pointer (short term usage) */
 	int flags;		/* flags as above */
 	int width;		/* width from format (%8d), or 0 */
-	unsigned char *typetable; /* table of types */
-	unsigned char stattypetable [STATIC_ARG_TBL_SIZE];
+	enum typeid *typetable; /* table of types */
+	enum typeid stattypetable [STATIC_ARG_TBL_SIZE];
 	int tablesize;		/* current size of type table */
 	int tablemax;		/* largest used index in table */
 	int nextarg;		/* 1-based argument index */
@@ -955,12 +1037,18 @@ __find_arguments (const char *fmt0, va_list ap, union arg **argtable)
 	typetable[nextarg++] = type)
 
 #define	ADDSARG() \
-	((flags&LONGINT) ? ADDTYPE(T_LONG) : \
-		((flags&SHORTINT) ? ADDTYPE(T_SHORT) : ADDTYPE(T_INT)))
+	((flags&INTMAXT) ? ADDTYPE(T_INTMAXT) : \
+		((flags&SIZET) ? ADDTYPE(T_SIZET) : \
+		((flags&PTRDIFFT) ? ADDTYPE(T_PTRDIFFT) : \
+		((flags&LLONGINT) ? ADDTYPE(T_LLONG) : \
+		((flags&LONGINT) ? ADDTYPE(T_LONG) : ADDTYPE(T_INT))))))
 
 #define	ADDUARG() \
-	((flags&LONGINT) ? ADDTYPE(T_U_LONG) : \
-		((flags&SHORTINT) ? ADDTYPE(T_U_SHORT) : ADDTYPE(T_U_INT)))
+	((flags&INTMAXT) ? ADDTYPE(T_UINTMAXT) : \
+		((flags&SIZET) ? ADDTYPE(T_SIZET) : \
+		((flags&PTRDIFFT) ? ADDTYPE(T_PTRDIFFT) : \
+		((flags&LLONGINT) ? ADDTYPE(T_U_LLONG) : \
+		((flags&LONGINT) ? ADDTYPE(T_U_LONG) : ADDTYPE(T_U_INT))))))
 
 	/*
 	 * Add * arguments to the type array.
@@ -1011,6 +1099,7 @@ reswitch:	switch (ch) {
 			goto rflag;
 		case '-':
 		case '+':
+		case '\'':
 			goto rflag;
 		case '.':
 			if ((ch = *fmt++) == '*') {
@@ -1042,16 +1131,30 @@ reswitch:	switch (ch) {
 			goto rflag;
 #endif
 		case 'h':
-			flags |= SHORTINT;
+			if (flags & SHORTINT) {
+				flags &= ~SHORTINT;
+				flags |= CHARINT;
+			} else
+				flags |= SHORTINT;
+			goto rflag;
+		case 'j':
+			flags |= INTMAXT;
 			goto rflag;
 		case 'l':
-			if (flags & LONGINT)
-				flags |= QUADINT;
-			else
+			if (flags & LONGINT) {
+				flags &= ~LONGINT;
+				flags |= LLONGINT;
+			} else
 				flags |= LONGINT;
 			goto rflag;
 		case 'q':
-			flags |= QUADINT;
+			flags |= LLONGINT;	/* not necessarily */
+			goto rflag;
+		case 't':
+			flags |= PTRDIFFT;
+			goto rflag;
+		case 'z':
+			flags |= SIZET;
 			goto rflag;
 		case 'c':
 			ADDTYPE(T_INT);
@@ -1061,13 +1164,13 @@ reswitch:	switch (ch) {
 			/*FALLTHROUGH*/
 		case 'd':
 		case 'i':
-			if (flags & QUADINT) {
-				ADDTYPE(T_QUAD);
-			} else {
-				ADDSARG();
-			}
+			ADDSARG();
 			break;
 #ifdef FLOATING_POINT
+#ifdef HEXFLOAT
+		case 'a':
+		case 'A':
+#endif
 		case 'e':
 		case 'E':
 		case 'f':
@@ -1080,12 +1183,20 @@ reswitch:	switch (ch) {
 			break;
 #endif /* FLOATING_POINT */
 		case 'n':
-			if (flags & QUADINT)
-				ADDTYPE(TP_QUAD);
+			if (flags & INTMAXT)
+				ADDTYPE(TP_INTMAXT);
+			else if (flags & PTRDIFFT)
+				ADDTYPE(TP_PTRDIFFT);
+			else if (flags & SIZET)
+				ADDTYPE(TP_SIZET);
+			else if (flags & LLONGINT)
+				ADDTYPE(TP_LLONG);
 			else if (flags & LONGINT)
 				ADDTYPE(TP_LONG);
 			else if (flags & SHORTINT)
 				ADDTYPE(TP_SHORT);
+			else if (flags & CHARINT)
+				ADDTYPE(TP_SCHAR);
 			else
 				ADDTYPE(TP_INT);
 			continue;	/* no output */
@@ -1093,10 +1204,7 @@ reswitch:	switch (ch) {
 			flags |= LONGINT;
 			/*FALLTHROUGH*/
 		case 'o':
-			if (flags & QUADINT)
-				ADDTYPE(T_U_QUAD);
-			else
-				ADDUARG();
+			ADDUARG();
 			break;
 		case 'p':
 			ADDTYPE(TP_VOID);
@@ -1108,17 +1216,9 @@ reswitch:	switch (ch) {
 			flags |= LONGINT;
 			/*FALLTHROUGH*/
 		case 'u':
-			if (flags & QUADINT)
-				ADDTYPE(T_U_QUAD);
-			else
-				ADDUARG();
-			break;
 		case 'X':
 		case 'x':
-			if (flags & QUADINT)
-				ADDTYPE(T_U_QUAD);
-			else
-				ADDUARG();
+			ADDUARG();
 			break;
 		default:	/* "%?" prints ?, unless ? is NUL */
 			if (ch == '\0')
@@ -1138,14 +1238,11 @@ done:
 	(*argtable) [0].intarg = 0;
 	for (n = 1; n <= tablemax; n++) {
 		switch (typetable [n]) {
-		    case T_UNUSED:
-			(*argtable) [n].intarg = va_arg (ap, int);
-			break;
-		    case T_SHORT:
+		    case T_UNUSED: /* whoops! */
 			(*argtable) [n].intarg = va_arg (ap, int);
 			break;
-		    case T_U_SHORT:
-			(*argtable) [n].intarg = va_arg (ap, int);
+		    case TP_SCHAR:
+			(*argtable) [n].pschararg = va_arg (ap, signed char *);
 			break;
 		    case TP_SHORT:
 			(*argtable) [n].pshortarg = va_arg (ap, short *);
@@ -1168,14 +1265,35 @@ done:
 		    case TP_LONG:
 			(*argtable) [n].plongarg = va_arg (ap, long *);
 			break;
-		    case T_QUAD:
-			(*argtable) [n].quadarg = va_arg (ap, quad_t);
+		    case T_LLONG:
+			(*argtable) [n].longlongarg = va_arg (ap, long long);
+			break;
+		    case T_U_LLONG:
+			(*argtable) [n].ulonglongarg = va_arg (ap, unsigned long long);
+			break;
+		    case TP_LLONG:
+			(*argtable) [n].plonglongarg = va_arg (ap, long long *);
+			break;
+		    case T_PTRDIFFT:
+			(*argtable) [n].ptrdiffarg = va_arg (ap, ptrdiff_t);
+			break;
+		    case TP_PTRDIFFT:
+			(*argtable) [n].pptrdiffarg = va_arg (ap, ptrdiff_t *);
+			break;
+		    case T_SIZET:
+			(*argtable) [n].sizearg = va_arg (ap, size_t);
+			break;
+		    case TP_SIZET:
+			(*argtable) [n].psizearg = va_arg (ap, ssize_t *);
+			break;
+		    case T_INTMAXT:
+			(*argtable) [n].intmaxarg = va_arg (ap, intmax_t);
 			break;
-		    case T_U_QUAD:
-			(*argtable) [n].uquadarg = va_arg (ap, u_quad_t);
+		    case T_UINTMAXT:
+			(*argtable) [n].uintmaxarg = va_arg (ap, uintmax_t);
 			break;
-		    case TP_QUAD:
-			(*argtable) [n].pquadarg = va_arg (ap, quad_t *);
+		    case TP_INTMAXT:
+			(*argtable) [n].pintmaxarg = va_arg (ap, intmax_t *);
 			break;
 #ifdef FLOATING_POINT
 		    case T_DOUBLE:
@@ -1202,11 +1320,11 @@ done:
  * Increase the size of the type table.
  */
 static void
-__grow_type_table (int nextarg, unsigned char **typetable, int *tablesize)
+__grow_type_table (int nextarg, enum typeid **typetable, int *tablesize)
 {
-	unsigned char *const oldtable = *typetable;
+	enum typeid *const oldtable = *typetable;
 	const int oldsize = *tablesize;
-	unsigned char *newtable;
+	enum typeid *newtable;
 	int newsize = oldsize * 2;
 
 	if (newsize < nextarg + 1)