Libc-594.9.5.tar.gz

[apple/libc.git] / stdio / FreeBSD / vfprintf.c.patch

--- vfprintf.c.orig	2008-09-07 11:37:54.000000000 -0700
+++ vfprintf.c	2008-09-07 17:33:16.000000000 -0700
@@ -40,6 +40,8 @@ static char sccsid[] = "@(#)vfprintf.c	8
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD: src/lib/libc/stdio/vfprintf.c,v 1.68 2004/08/26 06:25:28 des Exp $");
 
+#include "xlocale_private.h"
+
 /*
  * Actual printf innards.
  *
@@ -58,6 +60,7 @@ __FBSDID("$FreeBSD: src/lib/libc/stdio/v
 #include <stdlib.h>
 #include <string.h>
 #include <wchar.h>
+#include <errno.h>
 
 #include <stdarg.h>
 #include "un-namespace.h"
@@ -66,6 +69,13 @@ __FBSDID("$FreeBSD: src/lib/libc/stdio/v
 #include "local.h"
 #include "fvwrite.h"
 
+#ifdef VECTORS
+typedef __attribute__ ((vector_size(16))) unsigned char VECTORTYPE;
+#ifdef __SSE2__
+#define V64TYPE
+#endif /* __SSE2__ */
+#endif /* VECTORS */
+
 union arg {
 	int	intarg;
 	u_int	uintarg;
@@ -93,6 +103,21 @@ union arg {
 #endif
 	wint_t	wintarg;
 	wchar_t	*pwchararg;
+#ifdef VECTORS
+	VECTORTYPE		vectorarg;
+	unsigned char		vuchararg[16];
+	signed char		vchararg[16];
+	unsigned short		vushortarg[8];
+	signed short		vshortarg[8];
+	unsigned int		vuintarg[4];
+	signed int		vintarg[4];
+	float			vfloatarg[4];
+#ifdef V64TYPE
+	double			vdoublearg[2];
+	unsigned long long	vulonglongarg[2];
+	long long		vlonglongarg[2];
+#endif /* V64TYPE */
+#endif /* VECTORS */
 };
 
 /*
@@ -103,16 +128,20 @@ enum typeid {
 	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,
+#ifdef VECTORS
+	T_DOUBLE, T_LONG_DOUBLE, T_WINT, TP_WCHAR, T_VECTOR
+#else /* ! VECTORS */
 	T_DOUBLE, T_LONG_DOUBLE, T_WINT, TP_WCHAR
+#endif /* VECTORS */
 };
 
 static int	__sprint(FILE *, struct __suio *);
-static int	__sbprintf(FILE *, const char *, va_list) __printflike(2, 0);
+static int	__sbprintf(FILE *, locale_t, const char *, va_list) __printflike(3, 0);
 static char	*__ujtoa(uintmax_t, char *, int, int, const char *, int, char,
 		    const char *);
 static char	*__ultoa(u_long, char *, int, int, const char *, int, char,
 		    const char *);
-static char	*__wcsconv(wchar_t *, int);
+static char	*__wcsconv(wchar_t *, int, locale_t);
 static void	__find_arguments(const char *, va_list, union arg **);
 static void	__grow_type_table(int, enum typeid **, int *);
 
@@ -141,7 +170,7 @@ __sprint(FILE *fp, struct __suio *uio)
  * worries about ungetc buffers and so forth.
  */
 static int
-__sbprintf(FILE *fp, const char *fmt, va_list ap)
+__sbprintf(FILE *fp, locale_t loc, const char *fmt, va_list ap)
 {
 	int ret;
 	FILE fake;
@@ -160,7 +189,7 @@ __sbprintf(FILE *fp, const char *fmt, va
 	fake._lbfsize = 0;	/* not actually used, but Just In Case */
 
 	/* do the work, then copy any error status */
-	ret = __vfprintf(&fake, fmt, ap);
+	ret = __vfprintf(&fake, loc, fmt, ap);
 	if (ret >= 0 && __fflush(&fake))
 		ret = EOF;
 	if (fake._flags & __SERR)
@@ -252,7 +281,7 @@ __ultoa(u_long val, char *endp, int base
 		break;
 
 	default:			/* oops */
-		abort();
+		LIBC_ABORT("base = %d", base);
 	}
 	return (cp);
 }
@@ -324,7 +353,7 @@ __ujtoa(uintmax_t val, char *endp, int b
 		break;
 
 	default:
-		abort();
+		LIBC_ABORT("base = %d", base);
 	}
 	return (cp);
 }
@@ -336,14 +365,14 @@ __ujtoa(uintmax_t val, char *endp, int b
  * that the wide char. string ends in a null character.
  */
 static char *
-__wcsconv(wchar_t *wcsarg, int prec)
+__wcsconv(wchar_t *wcsarg, int prec, locale_t loc)
 {
 	static const mbstate_t initial;
 	mbstate_t mbs;
 	char buf[MB_LEN_MAX];
 	wchar_t *p;
 	char *convbuf, *mbp;
-	size_t clen, nbytes;
+	size_t clen = 0, nbytes;
 
 	/*
 	 * Determine the number of bytes to output and allocate space for
@@ -354,7 +383,7 @@ __wcsconv(wchar_t *wcsarg, int prec)
 		p = wcsarg;
 		mbs = initial;
 		for (;;) {
-			clen = wcrtomb(buf, *p++, &mbs);
+			clen = wcrtomb_l(buf, *p++, &mbs, loc);
 			if (clen == 0 || clen == (size_t)-1 ||
 			    nbytes + clen > prec)
 				break;
@@ -363,7 +392,7 @@ __wcsconv(wchar_t *wcsarg, int prec)
 	} else {
 		p = wcsarg;
 		mbs = initial;
-		nbytes = wcsrtombs(NULL, (const wchar_t **)&p, 0, &mbs);
+		nbytes = wcsrtombs_l(NULL, (const wchar_t **)&p, 0, &mbs, loc);
 		if (nbytes == (size_t)-1)
 			return (NULL);
 	}
@@ -378,7 +407,7 @@ __wcsconv(wchar_t *wcsarg, int prec)
 	p = wcsarg;
 	mbs = initial;
 	while (mbp - convbuf < nbytes) {
-		clen = wcrtomb(mbp, *p++, &mbs);
+		clen = wcrtomb_l(mbp, *p++, &mbs, loc);
 		if (clen == 0 || clen == (size_t)-1)
 			break;
 		mbp += clen;
@@ -395,6 +424,8 @@ __wcsconv(wchar_t *wcsarg, int prec)
 /*
  * MT-safe version
  */
+__private_extern__ const char *__fix_nogrouping(const char *);
+
 int
 vfprintf(FILE * __restrict fp, const char * __restrict fmt0, va_list ap)
 
@@ -402,7 +433,21 @@ vfprintf(FILE * __restrict fp, const cha
 	int ret;
 
 	FLOCKFILE(fp);
-	ret = __vfprintf(fp, fmt0, ap);
+	ret = __vfprintf(fp, __current_locale(), fmt0, ap);
+	FUNLOCKFILE(fp);
+	return (ret);
+}
+
+int
+vfprintf_l(FILE * __restrict fp, locale_t loc, const char * __restrict fmt0,
+    va_list ap)
+
+{
+	int ret;
+
+	NORMALIZE_LOCALE(loc);
+	FLOCKFILE(fp);
+	ret = __vfprintf(fp, loc, fmt0, ap);
 	FUNLOCKFILE(fp);
 	return (ret);
 }
@@ -451,12 +496,15 @@ static int exponent(char *, int, int);
 #define	PTRDIFFT	0x800		/* ptrdiff_t */
 #define	INTMAXT		0x1000		/* intmax_t */
 #define	CHARINT		0x2000		/* print char using int format */
+#ifdef VECTORS
+#define	VECTOR		0x4000		/* Altivec or SSE vector */
+#endif /* VECTORS */
 
 /*
  * Non-MT-safe version
  */
-int
-__vfprintf(FILE *fp, const char *fmt0, va_list ap)
+__private_extern__ int
+__vfprintf(FILE *fp, locale_t loc, const char *fmt0, va_list ap)
 {
 	char *fmt;		/* format string */
 	int ch;			/* character from fmt */
@@ -502,6 +550,11 @@ __vfprintf(FILE *fp, const char *fmt0, v
 	int nseps;		/* number of group separators with ' */
 	int nrepeats;		/* number of repeats of the last group */
 #endif
+#ifdef VECTORS
+	union arg vval;		/* Vector argument. */
+	char *pct;		/* Pointer to '%' at beginning of specifier. */
+	char vsep;		/* Vector separator character. */
+#endif
 	u_long	ulval;		/* integer arguments %[diouxX] */
 	uintmax_t ujval;	/* %j, %ll, %q, %t, %z integers */
 	int base;		/* base for [diouxX] conversion */
@@ -599,13 +652,13 @@ __vfprintf(FILE *fp, const char *fmt0, v
 #define	INTMAX_SIZE	(INTMAXT|SIZET|PTRDIFFT|LLONGINT)
 #define SJARG() \
 	(flags&INTMAXT ? GETARG(intmax_t) : \
-	    flags&SIZET ? (intmax_t)GETARG(size_t) : \
+	    flags&SIZET ? (intmax_t)GETARG(ssize_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) : \
+	    flags&PTRDIFFT ? (uintmax_t)(unsigned)GETARG(ptrdiff_t) : \
 	    (uintmax_t)GETARG(unsigned long long))
 
 	/*
@@ -633,22 +686,24 @@ __vfprintf(FILE *fp, const char *fmt0, v
 		val = GETARG (int); \
 	}
 
-
 	thousands_sep = '\0';
 	grouping = NULL;
 	convbuf = NULL;
 #ifndef NO_FLOATING_POINT
 	dtoaresult = NULL;
-	decimal_point = localeconv()->decimal_point;
+	decimal_point = localeconv_l(loc)->decimal_point;
 #endif
 	/* sorry, fprintf(read_only_file, "") returns EOF, not 0 */
-	if (prepwrite(fp) != 0)
+	if (prepwrite(fp) != 0) {
+		errno = EBADF;
 		return (EOF);
+	}
+	ORIENT(fp, -1);
 
 	/* optimise fprintf(stderr) (and other unbuffered Unix files) */
 	if ((fp->_flags & (__SNBF|__SWR|__SRW)) == (__SNBF|__SWR) &&
 	    fp->_file >= 0)
-		return (__sbprintf(fp, fmt0, ap));
+		return (__sbprintf(fp, loc, fmt0, ap));
 
 	fmt = (char *)fmt0;
 	argtable = NULL;
@@ -675,6 +730,9 @@ __vfprintf(FILE *fp, const char *fmt0, v
 		}
 		if (ch == '\0')
 			goto done;
+#ifdef VECTORS
+		pct = fmt;
+#endif /* VECTORS */
 		fmt++;		/* skip over '%' */
 
 		flags = 0;
@@ -683,6 +741,9 @@ __vfprintf(FILE *fp, const char *fmt0, v
 		prec = -1;
 		sign = '\0';
 		ox[1] = '\0';
+#ifdef VECTORS
+		vsep = 'X'; /* Illegal value, changed to defaults later. */
+#endif /* VECTORS */
 
 rflag:		ch = *fmt++;
 reswitch:	switch (ch) {
@@ -698,6 +759,11 @@ reswitch:	switch (ch) {
 		case '#':
 			flags |= ALT;
 			goto rflag;
+#ifdef VECTORS
+		case ',': case ';': case ':': case '_':
+			vsep = ch;
+			goto rflag;
+#endif /* VECTORS */
 		case '*':
 			/*-
 			 * ``A negative field width argument is taken as a
@@ -718,8 +784,8 @@ reswitch:	switch (ch) {
 			goto rflag;
 		case '\'':
 			flags |= GROUPING;
-			thousands_sep = *(localeconv()->thousands_sep);
-			grouping = localeconv()->grouping;
+			thousands_sep = *(localeconv_l(loc)->thousands_sep);
+			grouping = __fix_nogrouping(localeconv_l(loc)->grouping);
 			goto rflag;
 		case '.':
 			if ((ch = *fmt++) == '*') {
@@ -793,14 +859,18 @@ reswitch:	switch (ch) {
 			flags |= LONGINT;
 			/*FALLTHROUGH*/
 		case 'c':
+#ifdef VECTORS
+			if (flags & VECTOR)
+				break;
+#endif /* VECTORS */
 			if (flags & LONGINT) {
 				static const mbstate_t initial;
 				mbstate_t mbs;
 				size_t mbseqlen;
 
 				mbs = initial;
-				mbseqlen = wcrtomb(cp = buf,
-				    (wchar_t)GETARG(wint_t), &mbs);
+				mbseqlen = wcrtomb_l(cp = buf,
+				    (wchar_t)GETARG(wint_t), &mbs, loc);
 				if (mbseqlen == (size_t)-1) {
 					fp->_flags |= __SERR;
 					goto error;
@@ -817,6 +887,10 @@ reswitch:	switch (ch) {
 			/*FALLTHROUGH*/
 		case 'd':
 		case 'i':
+#ifdef VECTORS
+			if (flags & VECTOR)
+				break;
+#endif /* VECTORS */
 			if (flags & INTMAX_SIZE) {
 				ujval = SJARG();
 				if ((intmax_t)ujval < 0) {
@@ -835,6 +909,12 @@ reswitch:	switch (ch) {
 #ifndef NO_FLOATING_POINT
 		case 'a':
 		case 'A':
+#ifdef VECTORS
+			if (flags & VECTOR) {
+				flags |= FPT;
+				break;
+			}
+#endif /* VECTORS */
 			if (ch == 'a') {
 				ox[1] = 'x';
 				xdigs = xdigs_lower;
@@ -848,6 +928,12 @@ reswitch:	switch (ch) {
 				prec++;
 			if (dtoaresult != NULL)
 				freedtoa(dtoaresult);
+#ifdef LDBL_COMPAT
+			fparg.dbl = GETARG(double);
+			dtoaresult = cp =
+			    __hdtoa(fparg.dbl, xdigs, prec,
+			    &expt, &signflag, &dtoaend);
+#else /* !LDBL_COMPAT */
 			if (flags & LONGDBL) {
 				fparg.ldbl = GETARG(long double);
 				dtoaresult = cp =
@@ -859,6 +945,7 @@ reswitch:	switch (ch) {
 				    __hdtoa(fparg.dbl, xdigs, prec,
 				    &expt, &signflag, &dtoaend);
 			}
+#endif /* LDBL_COMPAT */
 			if (prec < 0)
 				prec = dtoaend - cp;
 			if (expt == INT_MAX)
@@ -866,6 +953,12 @@ reswitch:	switch (ch) {
 			goto fp_common;
 		case 'e':
 		case 'E':
+#ifdef VECTORS
+			if (flags & VECTOR) {
+				flags |= FPT;
+				break;
+			}
+#endif /* VECTORS */
 			expchar = ch;
 			if (prec < 0)	/* account for digit before decpt */
 				prec = DEFPREC + 1;
@@ -874,10 +967,22 @@ reswitch:	switch (ch) {
 			goto fp_begin;
 		case 'f':
 		case 'F':
+#ifdef VECTORS
+			if (flags & VECTOR) {
+				flags |= FPT;
+				break;
+			}
+#endif /* VECTORS */
 			expchar = '\0';
 			goto fp_begin;
 		case 'g':
 		case 'G':
+#ifdef VECTORS
+			if (flags & VECTOR) {
+				flags |= FPT;
+				break;
+			}
+#endif /* VECTORS */
 			expchar = ch - ('g' - 'e');
 			if (prec == 0)
 				prec = 1;
@@ -886,6 +991,14 @@ fp_begin:
 				prec = DEFPREC;
 			if (dtoaresult != NULL)
 				freedtoa(dtoaresult);
+#ifdef LDBL_COMPAT
+			fparg.dbl = GETARG(double);
+			dtoaresult = cp =
+			    dtoa(fparg.dbl, expchar ? 2 : 3, prec,
+			    &expt, &signflag, &dtoaend);
+			if (expt == 9999)
+				expt = INT_MAX;
+#else /* !LDBL_COMPAT */
 			if (flags & LONGDBL) {
 				fparg.ldbl = GETARG(long double);
 				dtoaresult = cp =
@@ -899,6 +1012,7 @@ fp_begin:
 				if (expt == 9999)
 					expt = INT_MAX;
 			}
+#endif /* LDBL_COMPAT */
 fp_common:
 			if (signflag)
 				sign = '-';
@@ -993,6 +1107,10 @@ fp_common:
 			flags |= LONGINT;
 			/*FALLTHROUGH*/
 		case 'o':
+#ifdef VECTORS
+			if (flags & VECTOR)
+				break;
+#endif /* VECTORS */
 			if (flags & INTMAX_SIZE)
 				ujval = UJARG();
 			else
@@ -1007,6 +1125,10 @@ fp_common:
 			 * defined manner.''
 			 *	-- ANSI X3J11
 			 */
+#ifdef VECTORS
+			if (flags & VECTOR)
+				break;
+#endif /* VECTORS */
 			ujval = (uintmax_t)(uintptr_t)GETARG(void *);
 			base = 16;
 			xdigs = xdigs_lower;
@@ -1025,7 +1147,7 @@ fp_common:
 				if ((wcp = GETARG(wchar_t *)) == NULL)
 					cp = "(null)";
 				else {
-					convbuf = __wcsconv(wcp, prec);
+					convbuf = __wcsconv(wcp, prec, loc);
 					if (convbuf == NULL) {
 						fp->_flags |= __SERR;
 						goto error;
@@ -1056,6 +1178,10 @@ fp_common:
 			flags |= LONGINT;
 			/*FALLTHROUGH*/
 		case 'u':
+#ifdef VECTORS
+			if (flags & VECTOR)
+				break;
+#endif /* VECTORS */
 			if (flags & INTMAX_SIZE)
 				ujval = UJARG();
 			else
@@ -1068,6 +1194,10 @@ fp_common:
 		case 'x':
 			xdigs = xdigs_lower;
 hex:
+#ifdef VECTORS
+			if (flags & VECTOR)
+				break;
+#endif /* VECTORS */
 			if (flags & INTMAX_SIZE)
 				ujval = UJARG();
 			else
@@ -1093,6 +1223,7 @@ number:			if ((dprec = prec) >= 0)
 			 * ``The result of converting a zero value with an
 			 * explicit precision of zero is no characters.''
 			 *	-- ANSI X3J11
+			 * except for %#.0o and zero value
 			 */
 			cp = buf + BUF;
 			if (flags & INTMAX_SIZE) {
@@ -1102,7 +1233,7 @@ number:			if ((dprec = prec) >= 0)
 					    flags & GROUPING, thousands_sep,
 					    grouping);
 			} else {
-				if (ulval != 0 || prec != 0)
+				if (ulval != 0 || prec != 0 || (flags & ALT))
 					cp = __ultoa(ulval, cp, base,
 					    flags & ALT, xdigs,
 					    flags & GROUPING, thousands_sep,
@@ -1110,8 +1241,13 @@ number:			if ((dprec = prec) >= 0)
 			}
 			size = buf + BUF - cp;
 			if (size > BUF)	/* should never happen */
-				abort();
+				LIBC_ABORT("size %d > BUF %d", size, BUF);
 			break;
+#ifdef VECTORS
+		case 'v':
+			flags |= VECTOR;
+			goto rflag;
+#endif /* VECTORS */
 		default:	/* "%?" prints ?, unless ? is NUL */
 			if (ch == '\0')
 				goto done;
@@ -1123,6 +1259,290 @@ number:			if ((dprec = prec) >= 0)
 			break;
 		}
 
+#ifdef VECTORS
+		if (flags & VECTOR) {
+			/*
+			 * Do the minimum amount of work necessary to construct
+			 * a format specifier that can be used to recursively
+			 * call vfprintf() for each element in the vector.
+			 */
+			int i, j;	/* Counter. */
+			int vcnt;	/* Number of elements in vector. */
+			char *vfmt;	/* Pointer to format specifier. */
+#define EXTRAHH 2
+			char vfmt_buf[32 + EXTRAHH]; /* Static buffer for format spec. */
+			int vwidth = 0;	/* Width specified via '*'. */
+			int vprec = 0;	/* Precision specified via '*'. */
+			char *vstr;	/* Used for asprintf(). */
+			int vlen;	/* Length returned by asprintf(). */
+			enum {
+			    V_CHAR, V_SHORT, V_INT,
+			    V_PCHAR, V_PSHORT, V_PINT,
+			    V_FLOAT,
+#ifdef V64TYPE
+			    V_LONGLONG, V_PLONGLONG,
+			    V_DOUBLE,
+#endif /* V64TYPE */
+			} vtype;
+
+			vval.vectorarg = GETARG(VECTORTYPE);
+			/*
+			 * Set vfmt.  If vfmt_buf may not be big enough,
+			 * malloc() space, taking care to free it later.
+			 * (EXTRAHH is for possible extra "hh")
+			 */
+			if (&fmt[-1] - pct + EXTRAHH < sizeof(vfmt_buf))
+				vfmt = vfmt_buf;
+			else
+				vfmt = (char *)malloc(&fmt[-1] - pct + EXTRAHH + 1);
+
+			/* Set the separator character, if not specified. */
+			if (vsep == 'X') {
+				if (ch == 'c')
+					vsep = '\0';
+				else
+					vsep = ' ';
+			}
+
+			/* Create the format specifier. */
+			for (i = j = 0; i < &fmt[-1] - pct; i++) {
+				switch (pct[i]) {
+				case ',': case ';': case ':': case '_':
+				case 'v': case 'h': case 'l':
+					/* Ignore. */
+					break;
+				case '*':
+					if (pct[i - 1] != '.')
+						vwidth = 1;
+					else
+						vprec = 1;
+					/* FALLTHROUGH */
+				default:
+					vfmt[j++] = pct[i];
+				}
+			}
+		
+			/*
+			 * Determine the number of elements in the vector and
+			 * finish up the format specifier.
+			 */
+			if (flags & SHORTINT) {
+				switch (ch) {
+				case 'c':
+					vtype = V_SHORT;
+					break;
+				case 'p':
+					vtype = V_PSHORT;
+					break;
+				default:
+					vfmt[j++] = 'h';
+					vtype = V_SHORT;
+					break;
+				}
+				vcnt = 8;
+			} else if (flags & LONGINT) {
+				vcnt = 4;
+				vtype = (ch == 'p') ? V_PINT : V_INT;
+#ifdef V64TYPE
+			} else if (flags & LLONGINT) {
+				switch (ch) {
+				case 'a':
+				case 'A':
+				case 'e':
+				case 'E':
+				case 'f':
+				case 'g':
+				case 'G':
+					vcnt = 2;
+					vtype = V_DOUBLE;
+					break;
+				case 'd':
+				case 'i':
+				case 'u':
+				case 'o':
+				case 'p':
+				case 'x':
+				case 'X':
+					vfmt[j++] = 'l';
+					vfmt[j++] = 'l';
+					vcnt = 2;
+					vtype = (ch == 'p') ? V_PLONGLONG : V_LONGLONG;
+					break;
+				default:
+					/*
+					 * The default case should never
+					 * happen.
+					 */
+				case 'c':
+					vcnt = 16;
+					vtype = V_CHAR;
+				}
+#endif /* V64TYPE */
+			} else {
+				switch (ch) {
+				case 'a':
+				case 'A':
+				case 'e':
+				case 'E':
+				case 'f':
+				case 'g':
+				case 'G':
+					vcnt = 4;
+					vtype = V_FLOAT;
+					break;
+				default:
+					/*
+					 * The default case should never
+					 * happen.
+					 */
+				case 'd':
+				case 'i':
+				case 'u':
+				case 'o':
+				case 'x':
+				case 'X':
+					vfmt[j++] = 'h';
+					vfmt[j++] = 'h';
+					/* drop through */
+				case 'p':
+				case 'c':
+					vcnt = 16;
+					vtype = (ch == 'p') ? V_PCHAR : V_CHAR;
+				}
+			}
+			vfmt[j++] = ch;
+			vfmt[j++] = '\0';
+
+/* Get a vector element. */
+#ifdef V64TYPE
+#define VPRINT(type, ind, args...) do {					\
+	switch (type) {							\
+	case V_CHAR:							\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, vval.vuchararg[ind]); \
+		break;							\
+	case V_PCHAR:							\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, (void *)(long)vval.vuchararg[ind]); \
+		break;							\
+	case V_SHORT:							\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, vval.vushortarg[ind]); \
+		break;							\
+	case V_PSHORT:							\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, (void *)(long)vval.vushortarg[ind]); \
+		break;							\
+	case V_INT:							\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, vval.vuintarg[ind]); \
+		break;							\
+	case V_PINT:							\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, (void *)(long)vval.vuintarg[ind]); \
+		break;							\
+	case V_LONGLONG:						\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, vval.vulonglongarg[ind]); \
+		break;							\
+	case V_PLONGLONG:						\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, (void *)(long)vval.vulonglongarg[ind]); \
+		break;							\
+	case V_FLOAT:							\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, vval.vfloatarg[ind]); \
+		break;							\
+	case V_DOUBLE:							\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, vval.vdoublearg[ind]); \
+		break;							\
+	}								\
+	ret += vlen;							\
+	PRINT(vstr, vlen);						\
+	FLUSH();							\
+	free(vstr);							\
+} while (0)
+#else /* !V64TYPE */
+#define VPRINT(type, ind, args...) do {					\
+	switch (type) {							\
+	case V_CHAR:							\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, vval.vuchararg[ind]); \
+		break;							\
+	case V_PCHAR:							\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, (void *)(long)vval.vuchararg[ind]); \
+		break;							\
+	case V_SHORT:							\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, vval.vushortarg[ind]); \
+		break;							\
+	case V_PSHORT:							\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, (void *)(long)vval.vushortarg[ind]); \
+		break;							\
+	case V_INT:							\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, vval.vuintarg[ind]); \
+		break;							\
+	case V_PINT:							\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, (void *)(long)vval.vuintarg[ind]); \
+		break;							\
+	case V_FLOAT:							\
+		vlen = asprintf_l(&vstr, loc, vfmt , ## args, vval.vfloatarg[ind]); \
+		break;							\
+	}								\
+	ret += vlen;							\
+	PRINT(vstr, vlen);						\
+	FLUSH();							\
+	free(vstr);							\
+} while (0)
+#endif /* V64TYPE */
+
+			/* Actually print. */
+			if (vwidth == 0) {
+				if (vprec == 0) {
+					/* First element. */
+					VPRINT(vtype, 0);
+					for (i = 1; i < vcnt; i++) {
+						/* Separator. */
+						if(vsep)
+							PRINT(&vsep, 1);
+
+						/* Element. */
+						VPRINT(vtype, i);
+					}
+				} else {
+					/* First element. */
+					VPRINT(vtype, 0, prec);
+					for (i = 1; i < vcnt; i++) {
+						/* Separator. */
+						if(vsep)
+							PRINT(&vsep, 1);
+
+						/* Element. */
+						VPRINT(vtype, i, prec);
+					}
+				}
+			} else {
+				if (vprec == 0) {
+					/* First element. */
+					VPRINT(vtype, 0, width);
+					for (i = 1; i < vcnt; i++) {
+						/* Separator. */
+						if(vsep)
+							PRINT(&vsep, 1);
+
+						/* Element. */
+						VPRINT(vtype, i, width);
+					}
+				} else {
+					/* First element. */
+					VPRINT(vtype, 0, width, prec);
+					for (i = 1; i < vcnt; i++) {
+						/* Separator. */
+						if(vsep)
+							PRINT(&vsep, 1);
+
+						/* Element. */
+						VPRINT(vtype, i, width, prec);
+					}
+				}
+			}
+#undef VPRINT
+
+			if (vfmt != vfmt_buf)
+				free(vfmt);
+
+			continue;
+		}
+#endif /* VECTORS */
 		/*
 		 * All reasonable formats wind up here.  At this point, `cp'
 		 * points to a string which (if not flags&LADJUST) should be
@@ -1178,7 +1598,7 @@ number:			if ((dprec = prec) >= 0)
 				if (expt <= 0) {
 					PRINT(zeroes, 1);
 					if (prec || flags & ALT)
-						PRINT(decimal_point, 1);
+						PRINT(decimal_point, strlen(decimal_point));
 					PAD(-expt, zeroes);
 					/* already handled initial 0's */
 					prec += expt;
@@ -1203,14 +1623,14 @@ number:			if ((dprec = prec) >= 0)
 							cp = dtoaend;
 					}
 					if (prec || flags & ALT)
-						PRINT(decimal_point,1);
+						PRINT(decimal_point, strlen(decimal_point));
 				}
 				PRINTANDPAD(cp, dtoaend, prec, zeroes);
 			} else {	/* %[eE] or sufficiently long %[gG] */
 				if (prec > 1 || flags & ALT) {
 					buf[0] = *cp++;
-					buf[1] = *decimal_point;
-					PRINT(buf, 2);
+					PRINT(buf, 1);
+					PRINT(decimal_point, strlen(decimal_point));
 					PRINT(cp, ndig-1);
 					PAD(prec - ndig, zeroes);
 				} else	/* XeYYY */
@@ -1406,6 +1826,11 @@ reswitch:	switch (ch) {
 			if (flags & LONGINT)
 				ADDTYPE(T_WINT);
 			else
+#ifdef VECTORS
+			if (flags & VECTOR)
+				ADDTYPE(T_VECTOR);
+			else
+#endif /* VECTORS */
 				ADDTYPE(T_INT);
 			break;
 		case 'D':
@@ -1413,6 +1838,11 @@ reswitch:	switch (ch) {
 			/*FALLTHROUGH*/
 		case 'd':
 		case 'i':
+#ifdef VECTORS
+			if (flags & VECTOR)
+				ADDTYPE(T_VECTOR);
+			else
+#endif
 			ADDSARG();
 			break;
 #ifndef NO_FLOATING_POINT
@@ -1421,8 +1851,14 @@ reswitch:	switch (ch) {
 		case 'e':
 		case 'E':
 		case 'f':
+		case 'F':
 		case 'g':
 		case 'G':
+#ifdef VECTORS
+			if (flags & VECTOR)
+				ADDTYPE(T_VECTOR);
+			else
+#endif /* VECTORS */
 			if (flags & LONGDBL)
 				ADDTYPE(T_LONG_DOUBLE);
 			else
@@ -1451,9 +1887,19 @@ reswitch:	switch (ch) {
 			flags |= LONGINT;
 			/*FALLTHROUGH*/
 		case 'o':
+#ifdef VECTORS
+			if (flags & VECTOR)
+				ADDTYPE(T_VECTOR);
+			else
+#endif /* VECTORS */
 			ADDUARG();
 			break;
 		case 'p':
+#ifdef VECTORS
+			if (flags & VECTOR)
+				ADDTYPE(T_VECTOR);
+			else
+#endif /* VECTORS */
 			ADDTYPE(TP_VOID);
 			break;
 		case 'S':
@@ -1471,6 +1917,11 @@ reswitch:	switch (ch) {
 		case 'u':
 		case 'X':
 		case 'x':
+#ifdef VECTORS
+			if (flags & VECTOR)
+				ADDTYPE(T_VECTOR);
+			else
+#endif /* VECTORS */
 			ADDUARG();
 			break;
 		default:	/* "%?" prints ?, unless ? is NUL */
@@ -1537,7 +1988,7 @@ done:
 			(*argtable) [n].sizearg = va_arg (ap, size_t);
 			break;
 		    case TP_SIZET:
-			(*argtable) [n].psizearg = va_arg (ap, ssize_t *);
+			(*argtable) [n].psizearg = va_arg (ap, size_t *);
 			break;
 		    case T_INTMAXT:
 			(*argtable) [n].intmaxarg = va_arg (ap, intmax_t);
@@ -1556,6 +2007,11 @@ done:
 			(*argtable) [n].longdoublearg = va_arg (ap, long double);
 			break;
 #endif
+#ifdef VECTORS
+		    case T_VECTOR:
+			(*argtable) [n].vectorarg = va_arg (ap, VECTORTYPE);
+			break;
+#endif /* VECTORS */
 		    case TP_CHAR:
 			(*argtable) [n].pchararg = va_arg (ap, char *);
 			break;
@@ -1590,12 +2046,12 @@ __grow_type_table (int nextarg, enum typ
 		newsize = nextarg + 1;
 	if (oldsize == STATIC_ARG_TBL_SIZE) {
 		if ((newtable = malloc(newsize * sizeof(enum typeid))) == NULL)
-			abort();			/* XXX handle better */
+			LIBC_ABORT("malloc: %s", strerror(errno));			/* XXX handle better */
 		bcopy(oldtable, newtable, oldsize * sizeof(enum typeid));
 	} else {
 		newtable = reallocf(oldtable, newsize * sizeof(enum typeid));
 		if (newtable == NULL)
-			abort();			/* XXX handle better */
+			LIBC_ABORT("reallocf: %s", strerror(errno));			/* XXX handle better */
 	}
 	for (n = oldsize; n < newsize; n++)
 		newtable[n] = T_UNUSED;