diff options
| -rw-r--r-- | libc/stdio/vfprintf.c | 2682 | ||||
| -rw-r--r-- | libc/stdio/vfscanf.c | 1555 | ||||
| -rw-r--r-- | libc/stdio/vfwprintf.c | 2618 | ||||
| -rw-r--r-- | libc/stdio/vfwscanf.c | 1228 |
4 files changed, 3950 insertions, 4133 deletions
diff --git a/libc/stdio/vfprintf.c b/libc/stdio/vfprintf.c index da7473564d..5713b44067 100644 --- a/libc/stdio/vfprintf.c +++ b/libc/stdio/vfprintf.c @@ -37,73 +37,70 @@ * This code is large and complicated... */ -#include <sys/types.h> #include <sys/mman.h> +#include <sys/types.h> #include <errno.h> #include <langinfo.h> #include <limits.h> #include <stdarg.h> #include <stddef.h> -#include <stdio.h> #include <stdint.h> +#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <wchar.h> -#include "local.h" #include "fvwrite.h" +#include "local.h" union arg { - int intarg; - unsigned int uintarg; - long longarg; - unsigned long ulongarg; - long long longlongarg; - unsigned long long ulonglongarg; - ptrdiff_t ptrdiffarg; - size_t sizearg; - ssize_t ssizearg; - intmax_t intmaxarg; - uintmax_t uintmaxarg; - void *pvoidarg; - char *pchararg; - signed char *pschararg; - short *pshortarg; - int *pintarg; - long *plongarg; - long long *plonglongarg; - ptrdiff_t *pptrdiffarg; - ssize_t *pssizearg; - intmax_t *pintmaxarg; - double doublearg; - long double longdoublearg; - wint_t wintarg; - wchar_t *pwchararg; + int intarg; + unsigned int uintarg; + long longarg; + unsigned long ulongarg; + long long longlongarg; + unsigned long long ulonglongarg; + ptrdiff_t ptrdiffarg; + size_t sizearg; + ssize_t ssizearg; + intmax_t intmaxarg; + uintmax_t uintmaxarg; + void* pvoidarg; + char* pchararg; + signed char* pschararg; + short* pshortarg; + int* pintarg; + long* plongarg; + long long* plonglongarg; + ptrdiff_t* pptrdiffarg; + ssize_t* pssizearg; + intmax_t* pintmaxarg; + double doublearg; + long double longdoublearg; + wint_t wintarg; + wchar_t* pwchararg; }; -static int __find_arguments(const char *fmt0, va_list ap, union arg **argtable, - size_t *argtablesiz); -static int __grow_type_table(unsigned char **typetable, int *tablesize); +static int __find_arguments(const char* fmt0, va_list ap, union arg** argtable, size_t* argtablesiz); +static int __grow_type_table(unsigned char** typetable, int* tablesize); /* * Flush out all the vectors defined by the given uio, * then reset it so that it can be reused. */ -static int -__sprint(FILE *fp, struct __suio *uio) -{ - int err; - - if (uio->uio_resid == 0) { - uio->uio_iovcnt = 0; - return (0); - } - err = __sfvwrite(fp, uio); - uio->uio_resid = 0; - uio->uio_iovcnt = 0; - return (err); +static int __sprint(FILE* fp, struct __suio* uio) { + int err; + + if (uio->uio_resid == 0) { + uio->uio_iovcnt = 0; + return (0); + } + err = __sfvwrite(fp, uio); + uio->uio_resid = 0; + uio->uio_iovcnt = 0; + return (err); } /* @@ -111,33 +108,29 @@ __sprint(FILE *fp, struct __suio *uio) * temporary buffer. We only work on write-only files; this avoids * worries about ungetc buffers and so forth. */ -static int -__sbprintf(FILE *fp, const char *fmt, va_list ap) -{ - int ret; - FILE fake; - struct __sfileext fakeext; - unsigned char buf[BUFSIZ]; - - _FILEEXT_SETUP(&fake, &fakeext); - /* copy the important variables */ - fake._flags = fp->_flags & ~__SNBF; - fake._file = fp->_file; - fake._cookie = fp->_cookie; - fake._write = fp->_write; - - /* set up the buffer */ - fake._bf._base = fake._p = buf; - fake._bf._size = fake._w = sizeof(buf); - fake._lbfsize = 0; /* not actually used, but Just In Case */ - - /* do the work, then copy any error status */ - ret = __vfprintf(&fake, fmt, ap); - if (ret >= 0 && __sflush(&fake)) - ret = EOF; - if (fake._flags & __SERR) - fp->_flags |= __SERR; - return (ret); +static int __sbprintf(FILE* fp, const char* fmt, va_list ap) { + int ret; + FILE fake; + struct __sfileext fakeext; + unsigned char buf[BUFSIZ]; + + _FILEEXT_SETUP(&fake, &fakeext); + /* copy the important variables */ + fake._flags = fp->_flags & ~__SNBF; + fake._file = fp->_file; + fake._cookie = fp->_cookie; + fake._write = fp->_write; + + /* set up the buffer */ + fake._bf._base = fake._p = buf; + fake._bf._size = fake._w = sizeof(buf); + fake._lbfsize = 0; /* not actually used, but Just In Case */ + + /* do the work, then copy any error status */ + ret = __vfprintf(&fake, fmt, ap); + if (ret >= 0 && __sflush(&fake)) ret = EOF; + if (fake._flags & __SERR) fp->_flags |= __SERR; + return (ret); } /* @@ -146,58 +139,50 @@ __sbprintf(FILE *fp, const char *fmt, va_list ap) * bytes to output, and also means that we can't assume that the wide char * string is null-terminated. */ -static char * -__wcsconv(wchar_t *wcsarg, int prec) -{ - mbstate_t mbs; - char buf[MB_LEN_MAX]; - wchar_t *p; - char *convbuf; - size_t clen, nbytes; - - /* Allocate space for the maximum number of bytes we could output. */ - if (prec < 0) { - memset(&mbs, 0, sizeof(mbs)); - p = wcsarg; - nbytes = wcsrtombs(NULL, (const wchar_t **)&p, 0, &mbs); - if (nbytes == (size_t)-1) - return (NULL); - } else { - /* - * Optimisation: if the output precision is small enough, - * just allocate enough memory for the maximum instead of - * scanning the string. - */ - if (prec < 128) - nbytes = prec; - else { - nbytes = 0; - p = wcsarg; - memset(&mbs, 0, sizeof(mbs)); - for (;;) { - clen = wcrtomb(buf, *p++, &mbs); - if (clen == 0 || clen == (size_t)-1 || - nbytes + clen > (size_t)prec) - break; - nbytes += clen; - } - if (clen == (size_t)-1) - return (NULL); - } - } - if ((convbuf = malloc(nbytes + 1)) == NULL) - return (NULL); - - /* Fill the output buffer. */ - p = wcsarg; - memset(&mbs, 0, sizeof(mbs)); - if ((nbytes = wcsrtombs(convbuf, (const wchar_t **)&p, - nbytes, &mbs)) == (size_t)-1) { - free(convbuf); - return (NULL); - } - convbuf[nbytes] = '\0'; - return (convbuf); +static char* __wcsconv(wchar_t* wcsarg, int prec) { + mbstate_t mbs; + char buf[MB_LEN_MAX]; + wchar_t* p; + char* convbuf; + size_t clen, nbytes; + + /* Allocate space for the maximum number of bytes we could output. */ + if (prec < 0) { + memset(&mbs, 0, sizeof(mbs)); + p = wcsarg; + nbytes = wcsrtombs(NULL, (const wchar_t**)&p, 0, &mbs); + if (nbytes == (size_t)-1) return (NULL); + } else { + /* + * Optimisation: if the output precision is small enough, + * just allocate enough memory for the maximum instead of + * scanning the string. + */ + if (prec < 128) + nbytes = prec; + else { + nbytes = 0; + p = wcsarg; + memset(&mbs, 0, sizeof(mbs)); + for (;;) { + clen = wcrtomb(buf, *p++, &mbs); + if (clen == 0 || clen == (size_t)-1 || nbytes + clen > (size_t)prec) break; + nbytes += clen; + } + if (clen == (size_t)-1) return (NULL); + } + } + if ((convbuf = malloc(nbytes + 1)) == NULL) return (NULL); + + /* Fill the output buffer. */ + p = wcsarg; + memset(&mbs, 0, sizeof(mbs)); + if ((nbytes = wcsrtombs(convbuf, (const wchar_t**)&p, nbytes, &mbs)) == (size_t)-1) { + free(convbuf); + return (NULL); + } + convbuf[nbytes] = '\0'; + return (convbuf); } #include <float.h> @@ -206,9 +191,9 @@ __wcsconv(wchar_t *wcsarg, int prec) #include "floatio.h" #include "gdtoa.h" -#define DEFPREC 6 +#define DEFPREC 6 -static int exponent(char *, int, int); +static int exponent(char*, int, int); /* * The size of the buffer we use as scratch space for integer @@ -217,883 +202,849 @@ static int exponent(char *, int, int); * characters between each pair of digits. 100 bytes is a * conservative overestimate even for a 128-bit uintmax_t. */ -#define BUF 100 - -#define STATIC_ARG_TBL_SIZE 8 /* Size of static argument table. */ +#define BUF 100 +#define STATIC_ARG_TBL_SIZE 8 /* Size of static argument table. */ /* * Macros for converting digits to letters and vice versa */ -#define to_digit(c) ((c) - '0') -#define is_digit(c) ((unsigned)to_digit(c) <= 9) -#define to_char(n) ((n) + '0') +#define to_digit(c) ((c) - '0') +#define is_digit(c) ((unsigned)to_digit(c) <= 9) +#define to_char(n) ((n) + '0') /* * Flags used during conversion. */ -#define ALT 0x0001 /* alternate form */ -#define LADJUST 0x0004 /* left adjustment */ -#define LONGDBL 0x0008 /* long double */ -#define LONGINT 0x0010 /* long integer */ -#define LLONGINT 0x0020 /* long long integer */ -#define SHORTINT 0x0040 /* short integer */ -#define ZEROPAD 0x0080 /* zero (as opposed to blank) pad */ -#define FPT 0x0100 /* Floating point number */ -#define PTRINT 0x0200 /* (unsigned) ptrdiff_t */ -#define SIZEINT 0x0400 /* (signed) size_t */ -#define CHARINT 0x0800 /* 8 bit integer */ -#define MAXINT 0x1000 /* largest integer size (intmax_t) */ - -int -vfprintf(FILE *fp, const char *fmt0, __va_list ap) -{ - int ret; - - FLOCKFILE(fp); - ret = __vfprintf(fp, fmt0, ap); - FUNLOCKFILE(fp); - return (ret); +#define ALT 0x0001 /* alternate form */ +#define LADJUST 0x0004 /* left adjustment */ +#define LONGDBL 0x0008 /* long double */ +#define LONGINT 0x0010 /* long integer */ +#define LLONGINT 0x0020 /* long long integer */ +#define SHORTINT 0x0040 /* short integer */ +#define ZEROPAD 0x0080 /* zero (as opposed to blank) pad */ +#define FPT 0x0100 /* Floating point number */ +#define PTRINT 0x0200 /* (unsigned) ptrdiff_t */ +#define SIZEINT 0x0400 /* (signed) size_t */ +#define CHARINT 0x0800 /* 8 bit integer */ +#define MAXINT 0x1000 /* largest integer size (intmax_t) */ + +int vfprintf(FILE* fp, const char* fmt0, __va_list ap) { + int ret; + + FLOCKFILE(fp); + ret = __vfprintf(fp, fmt0, ap); + FUNLOCKFILE(fp); + return (ret); } DEF_STRONG(vfprintf); -int -__vfprintf(FILE *fp, const char *fmt0, __va_list ap) -{ - char *fmt; /* format string */ - int ch; /* character from fmt */ - int n, n2; /* handy integers (short term usage) */ - char *cp; /* handy char pointer (short term usage) */ - struct __siov *iovp; /* for PRINT macro */ - int flags; /* flags as above */ - int ret; /* return value accumulator */ - int width; /* width from format (%8d), or 0 */ - int prec; /* precision from format; <0 for N/A */ - char sign; /* sign prefix (' ', '+', '-', or \0) */ - wchar_t wc; - mbstate_t ps; - /* - * We can decompose the printed representation of floating - * point numbers into several parts, some of which may be empty: - * - * [+|-| ] [0x|0X] MMM . NNN [e|E|p|P] [+|-] ZZ - * A B ---C--- D E F - * - * A: 'sign' holds this value if present; '\0' otherwise - * B: ox[1] holds the 'x' or 'X'; '\0' if not hexadecimal - * C: cp points to the string MMMNNN. Leading and trailing - * zeros are not in the string and must be added. - * D: expchar holds this character; '\0' if no exponent, e.g. %f - * F: at least two digits for decimal, at least one digit for hex - */ - char *decimal_point = NULL; - int signflag; /* true if float is negative */ - union { /* floating point arguments %[aAeEfFgG] */ - double dbl; - long double ldbl; - } fparg; - int expt; /* integer value of exponent */ - char expchar; /* exponent character: [eEpP\0] */ - char *dtoaend; /* pointer to end of converted digits */ - int expsize; /* character count for expstr */ - int lead; /* sig figs before decimal or group sep */ - int ndig; /* actual number of digits returned by dtoa */ - char expstr[MAXEXPDIG+2]; /* buffer for exponent string: e+ZZZ */ - char *dtoaresult = NULL; - - uintmax_t _umax; /* integer arguments %[diouxX] */ - enum { OCT, DEC, HEX } base; /* base for %[diouxX] conversion */ - int dprec; /* a copy of prec if %[diouxX], 0 otherwise */ - int realsz; /* field size expanded by dprec */ - int size; /* size of converted field or string */ - const char *xdigs; /* digits for %[xX] conversion */ +int __vfprintf(FILE* fp, const char* fmt0, __va_list ap) { + char* fmt; /* format string */ + int ch; /* character from fmt */ + int n, n2; /* handy integers (short term usage) */ + char* cp; /* handy char pointer (short term usage) */ + struct __siov* iovp; /* for PRINT macro */ + int flags; /* flags as above */ + int ret; /* return value accumulator */ + int width; /* width from format (%8d), or 0 */ + int prec; /* precision from format; <0 for N/A */ + char sign; /* sign prefix (' ', '+', '-', or \0) */ + wchar_t wc; + mbstate_t ps; + /* + * We can decompose the printed representation of floating + * point numbers into several parts, some of which may be empty: + * + * [+|-| ] [0x|0X] MMM . NNN [e|E|p|P] [+|-] ZZ + * A B ---C--- D E F + * + * A: 'sign' holds this value if present; '\0' otherwise + * B: ox[1] holds the 'x' or 'X'; '\0' if not hexadecimal + * C: cp points to the string MMMNNN. Leading and trailing + * zeros are not in the string and must be added. + * D: expchar holds this character; '\0' if no exponent, e.g. %f + * F: at least two digits for decimal, at least one digit for hex + */ + char* decimal_point = NULL; + int signflag; /* true if float is negative */ + union { /* floating point arguments %[aAeEfFgG] */ + double dbl; + long double ldbl; + } fparg; + int expt; /* integer value of exponent */ + char expchar; /* exponent character: [eEpP\0] */ + char* dtoaend; /* pointer to end of converted digits */ + int expsize; /* character count for expstr */ + int lead; /* sig figs before decimal or group sep */ + int ndig; /* actual number of digits returned by dtoa */ + char expstr[MAXEXPDIG + 2]; /* buffer for exponent string: e+ZZZ */ + char* dtoaresult = NULL; + + uintmax_t _umax; /* integer arguments %[diouxX] */ + enum { OCT, DEC, HEX } base; /* base for %[diouxX] conversion */ + int dprec; /* a copy of prec if %[diouxX], 0 otherwise */ + int realsz; /* field size expanded by dprec */ + int size; /* size of converted field or string */ + const char* xdigs; /* digits for %[xX] conversion */ #define NIOV 8 - struct __suio uio; /* output information: summary */ - struct __siov iov[NIOV];/* ... and individual io vectors */ - char buf[BUF]; /* buffer with space for digits of uintmax_t */ - char ox[2]; /* space for 0x; ox[1] is either x, X, or \0 */ - union arg *argtable; /* args, built due to positional arg */ - union arg statargtable[STATIC_ARG_TBL_SIZE]; - size_t argtablesiz; - int nextarg; /* 1-based argument index */ - va_list orgap; /* original argument pointer */ - char *convbuf; /* buffer for wide to multi-byte conversion */ - - /* - * Choose PADSIZE to trade efficiency vs. size. If larger printf - * fields occur frequently, increase PADSIZE and make the initialisers - * below longer. - */ -#define PADSIZE 16 /* pad chunk size */ - static char blanks[PADSIZE] = - {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '}; - static char zeroes[PADSIZE] = - {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'}; - - static const char xdigs_lower[16] = "0123456789abcdef"; - static const char xdigs_upper[16] = "0123456789ABCDEF"; - - /* - * BEWARE, these `goto error' on error, and PAD uses `n'. - */ -#define PRINT(ptr, len) do { \ - iovp->iov_base = (ptr); \ - iovp->iov_len = (len); \ - uio.uio_resid += (len); \ - iovp++; \ - if (++uio.uio_iovcnt >= NIOV) { \ - if (__sprint(fp, &uio)) \ - goto error; \ - iovp = iov; \ - } \ -} while (0) -#define PAD(howmany, with) do { \ - if ((n = (howmany)) > 0) { \ - while (n > PADSIZE) { \ - PRINT(with, PADSIZE); \ - n -= PADSIZE; \ - } \ - PRINT(with, n); \ - } \ -} while (0) -#define PRINTANDPAD(p, ep, len, with) do { \ - n2 = (ep) - (p); \ - if (n2 > (len)) \ - n2 = (len); \ - if (n2 > 0) \ - PRINT((p), n2); \ - PAD((len) - (n2 > 0 ? n2 : 0), (with)); \ -} while(0) -#define FLUSH() do { \ - if (uio.uio_resid && __sprint(fp, &uio)) \ - goto error; \ - uio.uio_iovcnt = 0; \ - iovp = iov; \ -} while (0) - - /* - * To extend shorts properly, we need both signed and unsigned - * argument extraction methods. - */ -#define SARG() \ - ((intmax_t)(flags&MAXINT ? GETARG(intmax_t) : \ - flags&LLONGINT ? GETARG(long long) : \ - flags&LONGINT ? GETARG(long) : \ - flags&PTRINT ? GETARG(ptrdiff_t) : \ - flags&SIZEINT ? GETARG(ssize_t) : \ - flags&SHORTINT ? (short)GETARG(int) : \ - flags&CHARINT ? (signed char)GETARG(int) : \ - GETARG(int))) -#define UARG() \ - ((uintmax_t)(flags&MAXINT ? GETARG(uintmax_t) : \ - flags&LLONGINT ? GETARG(unsigned long long) : \ - flags&LONGINT ? GETARG(unsigned long) : \ - flags&PTRINT ? (uintptr_t)GETARG(ptrdiff_t) : /* XXX */ \ - flags&SIZEINT ? GETARG(size_t) : \ - flags&SHORTINT ? (unsigned short)GETARG(int) : \ - flags&CHARINT ? (unsigned char)GETARG(int) : \ - GETARG(unsigned int))) - - /* - * Append a digit to a value and check for overflow. - */ -#define APPEND_DIGIT(val, dig) do { \ - if ((val) > INT_MAX / 10) \ - goto overflow; \ - (val) *= 10; \ - if ((val) > INT_MAX - to_digit((dig))) \ - goto overflow; \ - (val) += to_digit((dig)); \ -} while (0) - - /* - * Get * arguments, including the form *nn$. Preserve the nextarg - * that the argument can be gotten once the type is determined. - */ -#define GETASTER(val) \ - n2 = 0; \ - cp = fmt; \ - while (is_digit(*cp)) { \ - APPEND_DIGIT(n2, *cp); \ - cp++; \ - } \ - if (*cp == '$') { \ - int hold = nextarg; \ - if (argtable == NULL) { \ - argtable = statargtable; \ - if (__find_arguments(fmt0, orgap, &argtable, \ - &argtablesiz) == -1) { \ - ret = -1; \ - goto error; \ - } \ - } \ - nextarg = n2; \ - val = GETARG(int); \ - nextarg = hold; \ - fmt = ++cp; \ - } else { \ - val = GETARG(int); \ - } + struct __suio uio; /* output information: summary */ + struct __siov iov[NIOV]; /* ... and individual io vectors */ + char buf[BUF]; /* buffer with space for digits of uintmax_t */ + char ox[2]; /* space for 0x; ox[1] is either x, X, or \0 */ + union arg* argtable; /* args, built due to positional arg */ + union arg statargtable[STATIC_ARG_TBL_SIZE]; + size_t argtablesiz; + int nextarg; /* 1-based argument index */ + va_list orgap; /* original argument pointer */ + char* convbuf; /* buffer for wide to multi-byte conversion */ + + /* + * Choose PADSIZE to trade efficiency vs. size. If larger printf + * fields occur frequently, increase PADSIZE and make the initialisers + * below longer. + */ +#define PADSIZE 16 /* pad chunk size */ + static char blanks[PADSIZE] = { ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' }; + static char zeroes[PADSIZE] = { '0', '0', '0', '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', '0', '0', '0' }; + + static const char xdigs_lower[16] = "0123456789abcdef"; + static const char xdigs_upper[16] = "0123456789ABCDEF"; + + /* + * BEWARE, these `goto error' on error, and PAD uses `n'. + */ +#define PRINT(ptr, len) \ + do { \ + iovp->iov_base = (ptr); \ + iovp->iov_len = (len); \ + uio.uio_resid += (len); \ + iovp++; \ + if (++uio.uio_iovcnt >= NIOV) { \ + if (__sprint(fp, &uio)) goto error; \ + iovp = iov; \ + } \ + } while (0) +#define PAD(howmany, with) \ + do { \ + if ((n = (howmany)) > 0) { \ + while (n > PADSIZE) { \ + PRINT(with, PADSIZE); \ + n -= PADSIZE; \ + } \ + PRINT(with, n); \ + } \ + } while (0) +#define PRINTANDPAD(p, ep, len, with) \ + do { \ + n2 = (ep) - (p); \ + if (n2 > (len)) n2 = (len); \ + if (n2 > 0) PRINT((p), n2); \ + PAD((len) - (n2 > 0 ? n2 : 0), (with)); \ + } while (0) +#define FLUSH() \ + do { \ + if (uio.uio_resid && __sprint(fp, &uio)) goto error; \ + uio.uio_iovcnt = 0; \ + iovp = iov; \ + } while (0) + + /* + * To extend shorts properly, we need both signed and unsigned + * argument extraction methods. + */ +#define SARG() \ + ((intmax_t)(flags & MAXINT \ + ? GETARG(intmax_t) \ + : flags & LLONGINT \ + ? GETARG(long long) \ + : flags & LONGINT \ + ? GETARG(long) \ + : flags & PTRINT \ + ? GETARG(ptrdiff_t) \ + : flags & SIZEINT \ + ? GETARG(ssize_t) \ + : flags & SHORTINT \ + ? (short)GETARG(int) \ + : flags & CHARINT ? (signed char)GETARG(int) \ + : GETARG(int))) +#define UARG() \ + ((uintmax_t)(flags & MAXINT \ + ? GETARG(uintmax_t) \ + : flags & LLONGINT \ + ? GETARG(unsigned long long) \ + : flags & LONGINT \ + ? GETARG(unsigned long) \ + : flags & PTRINT ? (uintptr_t)GETARG(ptrdiff_t) : /* XXX */ \ + flags & SIZEINT \ + ? GETARG(size_t) \ + : flags & SHORTINT \ + ? (unsigned short)GETARG(int) \ + : flags & CHARINT ? (unsigned char)GETARG(int) \ + : GETARG(unsigned int))) + + /* + * Append a digit to a value and check for overflow. + */ +#define APPEND_DIGIT(val, dig) \ + do { \ + if ((val) > INT_MAX / 10) goto overflow; \ + (val) *= 10; \ + if ((val) > INT_MAX - to_digit((dig))) goto overflow; \ + (val) += to_digit((dig)); \ + } while (0) + + /* + * Get * arguments, including the form *nn$. Preserve the nextarg + * that the argument can be gotten once the type is determined. + */ +#define GETASTER(val) \ + n2 = 0; \ + cp = fmt; \ + while (is_digit(*cp)) { \ + APPEND_DIGIT(n2, *cp); \ + cp++; \ + } \ + if (*cp == '$') { \ + int hold = nextarg; \ + if (argtable == NULL) { \ + argtable = statargtable; \ + if (__find_arguments(fmt0, orgap, &argtable, &argtablesiz) == -1) { \ + ret = -1; \ + goto error; \ + } \ + } \ + nextarg = n2; \ + val = GETARG(int); \ + nextarg = hold; \ + fmt = ++cp; \ + } else { \ + val = GETARG(int); \ + } /* -* Get the argument indexed by nextarg. If the argument table is -* built, use it to get the argument. If its not, get the next -* argument (and arguments must be gotten sequentially). -*/ + * Get the argument indexed by nextarg. If the argument table is + * built, use it to get the argument. If its not, get the next + * argument (and arguments must be gotten sequentially). + */ #define GETARG(type) \ - ((argtable != NULL) ? *((type*)(&argtable[nextarg++])) : \ - (nextarg++, va_arg(ap, type))) - - _SET_ORIENTATION(fp, -1); - /* sorry, fprintf(read_only_file, "") returns EOF, not 0 */ - if (cantwrite(fp)) { - errno = EBADF; - return (EOF); - } - - /* optimise fprintf(stderr) (and other unbuffered Unix files) */ - if ((fp->_flags & (__SNBF|__SWR|__SRW)) == (__SNBF|__SWR) && - fp->_file >= 0) - return (__sbprintf(fp, fmt0, ap)); - - fmt = (char *)fmt0; - argtable = NULL; - nextarg = 1; - va_copy(orgap, ap); - uio.uio_iov = iovp = iov; - uio.uio_resid = 0; - uio.uio_iovcnt = 0; - ret = 0; - convbuf = NULL; - - memset(&ps, 0, sizeof(ps)); - /* - * Scan the format for conversions (`%' character). - */ - for (;;) { - cp = fmt; - while ((n = mbrtowc(&wc, fmt, MB_CUR_MAX, &ps)) > 0) { - fmt += n; - if (wc == '%') { - fmt--; - break; - } - } - if (n < 0) { - ret = -1; - goto error; - } - if (fmt != cp) { - ptrdiff_t m = fmt - cp; - if (m < 0 || m > INT_MAX - ret) - goto overflow; - PRINT(cp, m); - ret += m; - } - if (n == 0) - goto done; - fmt++; /* skip over '%' */ - - flags = 0; - dprec = 0; - width = 0; - prec = -1; - sign = '\0'; - ox[1] = '\0'; - -rflag: ch = *fmt++; -reswitch: switch (ch) { - case ' ': - /* - * ``If the space and + flags both appear, the space - * flag will be ignored.'' - * -- ANSI X3J11 - */ - if (!sign) - sign = ' '; - goto rflag; - case '#': - flags |= ALT; - goto rflag; - case '\'': - /* grouping not implemented */ - goto rflag; - case '*': - /* - * ``A negative field width argument is taken as a - * - flag followed by a positive field width.'' - * -- ANSI X3J11 - * They don't exclude field widths read from args. - */ - GETASTER(width); - if (width >= 0) - goto rflag; - if (width == INT_MIN) - goto overflow; - width = -width; - /* FALLTHROUGH */ - case '-': - flags |= LADJUST; - goto rflag; - case '+': - sign = '+'; - goto rflag; - case '.': - if ((ch = *fmt++) == '*') { - GETASTER(n); - prec = n < 0 ? -1 : n; - goto rflag; - } - n = 0; - while (is_digit(ch)) { - APPEND_DIGIT(n, ch); - ch = *fmt++; - } - if (ch == '$') { - nextarg = n; - if (argtable == NULL) { - argtable = statargtable; - if (__find_arguments(fmt0, orgap, - &argtable, &argtablesiz) == -1) { - ret = -1; - goto error; - } - } - goto rflag; - } - prec = n; - goto reswitch; - case '0': - /* - * ``Note that 0 is taken as a flag, not as the - * beginning of a field width.'' - * -- ANSI X3J11 - */ - flags |= ZEROPAD; - goto rflag; - case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - n = 0; - do { - APPEND_DIGIT(n, ch); - ch = *fmt++; - } while (is_digit(ch)); - if (ch == '$') { - nextarg = n; - if (argtable == NULL) { - argtable = statargtable; - if (__find_arguments(fmt0, orgap, - &argtable, &argtablesiz) == -1) { - ret = -1; - goto error; - } - } - goto rflag; - } - width = n; - goto reswitch; - case 'L': - flags |= LONGDBL; - goto rflag; - case 'h': - if (*fmt == 'h') { - fmt++; - flags |= CHARINT; - } else { - flags |= SHORTINT; - } - goto rflag; - case 'j': - flags |= MAXINT; - goto rflag; - case 'l': - if (*fmt == 'l') { - fmt++; - flags |= LLONGINT; - } else { - flags |= LONGINT; - } - goto rflag; - case 'q': - flags |= LLONGINT; - goto rflag; - case 't': - flags |= PTRINT; - goto rflag; - case 'z': - flags |= SIZEINT; - goto rflag; - case 'c': - if (flags & LONGINT) { - mbstate_t mbs; - size_t mbseqlen; - - memset(&mbs, 0, sizeof(mbs)); - mbseqlen = wcrtomb(buf, - (wchar_t)GETARG(wint_t), &mbs); - if (mbseqlen == (size_t)-1) { - ret = -1; - goto error; - } - cp = buf; - size = (int)mbseqlen; - } else { - *(cp = buf) = GETARG(int); - size = 1; - } - sign = '\0'; - break; - case 'D': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'd': - case 'i': - _umax = SARG(); - if ((intmax_t)_umax < 0) { - _umax = -_umax; - sign = '-'; - } - base = DEC; - goto number; - case 'a': - case 'A': - if (ch == 'a') { - ox[1] = 'x'; - xdigs = xdigs_lower; - expchar = 'p'; - } else { - ox[1] = 'X'; - xdigs = xdigs_upper; - expchar = 'P'; - } - if (prec >= 0) - prec++; - if (dtoaresult) - __freedtoa(dtoaresult); - if (flags & LONGDBL) { - fparg.ldbl = GETARG(long double); - dtoaresult = cp = - __hldtoa(fparg.ldbl, xdigs, prec, - &expt, &signflag, &dtoaend); - if (dtoaresult == NULL) { - errno = ENOMEM; - goto error; - } - } else { - fparg.dbl = GETARG(double); - dtoaresult = cp = - __hdtoa(fparg.dbl, xdigs, prec, - &expt, &signflag, &dtoaend); - if (dtoaresult == NULL) { - errno = ENOMEM; - goto error; - } - } - if (prec < 0) - prec = dtoaend - cp; - if (expt == INT_MAX) - ox[1] = '\0'; - goto fp_common; - case 'e': - case 'E': - expchar = ch; - if (prec < 0) /* account for digit before decpt */ - prec = DEFPREC + 1; - else - prec++; - goto fp_begin; - case 'f': - case 'F': - expchar = '\0'; - goto fp_begin; - case 'g': - case 'G': - expchar = ch - ('g' - 'e'); - if (prec == 0) - prec = 1; -fp_begin: - if (prec < 0) - prec = DEFPREC; - if (dtoaresult) - __freedtoa(dtoaresult); - if (flags & LONGDBL) { - fparg.ldbl = GETARG(long double); - dtoaresult = cp = - __ldtoa(&fparg.ldbl, expchar ? 2 : 3, prec, - &expt, &signflag, &dtoaend); - if (dtoaresult == NULL) { - errno = ENOMEM; - goto error; - } - } else { - fparg.dbl = GETARG(double); - dtoaresult = cp = - __dtoa(fparg.dbl, expchar ? 2 : 3, prec, - &expt, &signflag, &dtoaend); - if (dtoaresult == NULL) { - errno = ENOMEM; - goto error; - } - if (expt == 9999) - expt = INT_MAX; - } -fp_common: - if (signflag) - sign = '-'; - if (expt == INT_MAX) { /* inf or nan */ - if (*cp == 'N') - cp = (ch >= 'a') ? "nan" : "NAN"; - else - cp = (ch >= 'a') ? "inf" : "INF"; - size = 3; - flags &= ~ZEROPAD; - break; - } - flags |= FPT; - ndig = dtoaend - cp; - if (ch == 'g' || ch == 'G') { - if (expt > -4 && expt <= prec) { - /* Make %[gG] smell like %[fF] */ - expchar = '\0'; - if (flags & ALT) - prec -= expt; - else - prec = ndig - expt; - if (prec < 0) - prec = 0; - } else { - /* - * Make %[gG] smell like %[eE], but - * trim trailing zeroes if no # flag. - */ - if (!(flags & ALT)) - prec = ndig; - } - } - if (expchar) { - expsize = exponent(expstr, expt - 1, expchar); - size = expsize + prec; - if (prec > 1 || flags & ALT) - ++size; - } else { - /* space for digits before decimal point */ - if (expt > 0) - size = expt; - else /* "0" */ - size = 1; - /* space for decimal pt and following digits */ - if (prec || flags & ALT) - size += prec + 1; - lead = expt; - } - break; + ((argtable != NULL) ? *((type*)(&argtable[nextarg++])) : (nextarg++, va_arg(ap, type))) + + _SET_ORIENTATION(fp, -1); + /* sorry, fprintf(read_only_file, "") returns EOF, not 0 */ + if (cantwrite(fp)) { + errno = EBADF; + return (EOF); + } + + /* optimise fprintf(stderr) (and other unbuffered Unix files) */ + if ((fp->_flags & (__SNBF | __SWR | __SRW)) == (__SNBF | __SWR) && fp->_file >= 0) + return (__sbprintf(fp, fmt0, ap)); + + fmt = (char*)fmt0; + argtable = NULL; + nextarg = 1; + va_copy(orgap, ap); + uio.uio_iov = iovp = iov; + uio.uio_resid = 0; + uio.uio_iovcnt = 0; + ret = 0; + convbuf = NULL; + + memset(&ps, 0, sizeof(ps)); + /* + * Scan the format for conversions (`%' character). + */ + for (;;) { + cp = fmt; + while ((n = mbrtowc(&wc, fmt, MB_CUR_MAX, &ps)) > 0) { + fmt += n; + if (wc == '%') { + fmt--; + break; + } + } + if (n < 0) { + ret = -1; + goto error; + } + if (fmt != cp) { + ptrdiff_t m = fmt - cp; + if (m < 0 || m > INT_MAX - ret) goto overflow; + PRINT(cp, m); + ret += m; + } + if (n == 0) goto done; + fmt++; /* skip over '%' */ + + flags = 0; + dprec = 0; + width = 0; + prec = -1; + sign = '\0'; + ox[1] = '\0'; + + rflag: + ch = *fmt++; + reswitch: + switch (ch) { + case ' ': + /* + * ``If the space and + flags both appear, the space + * flag will be ignored.'' + * -- ANSI X3J11 + */ + if (!sign) sign = ' '; + goto rflag; + case '#': + flags |= ALT; + goto rflag; + case '\'': + /* grouping not implemented */ + goto rflag; + case '*': + /* + * ``A negative field width argument is taken as a + * - flag followed by a positive field width.'' + * -- ANSI X3J11 + * They don't exclude field widths read from args. + */ + GETASTER(width); + if (width >= 0) goto rflag; + if (width == INT_MIN) goto overflow; + width = -width; + /* FALLTHROUGH */ + case '-': + flags |= LADJUST; + goto rflag; + case '+': + sign = '+'; + goto rflag; + case '.': + if ((ch = *fmt++) == '*') { + GETASTER(n); + prec = n < 0 ? -1 : n; + goto rflag; + } + n = 0; + while (is_digit(ch)) { + APPEND_DIGIT(n, ch); + ch = *fmt++; + } + if (ch == '$') { + nextarg = n; + if (argtable == NULL) { + argtable = statargtable; + if (__find_arguments(fmt0, orgap, &argtable, &argtablesiz) == -1) { + ret = -1; + goto error; + } + } + goto rflag; + } + prec = n; + goto reswitch; + case '0': + /* + * ``Note that 0 is taken as a flag, not as the + * beginning of a field width.'' + * -- ANSI X3J11 + */ + flags |= ZEROPAD; + goto rflag; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + n = 0; + do { + APPEND_DIGIT(n, ch); + ch = *fmt++; + } while (is_digit(ch)); + if (ch == '$') { + nextarg = n; + if (argtable == NULL) { + argtable = statargtable; + if (__find_arguments(fmt0, orgap, &argtable, &argtablesiz) == -1) { + ret = -1; + goto error; + } + } + goto rflag; + } + width = n; + goto reswitch; + case 'L': + flags |= LONGDBL; + goto rflag; + case 'h': + if (*fmt == 'h') { + fmt++; + flags |= CHARINT; + } else { + flags |= SHORTINT; + } + goto rflag; + case 'j': + flags |= MAXINT; + goto rflag; + case 'l': + if (*fmt == 'l') { + fmt++; + flags |= LLONGINT; + } else { + flags |= LONGINT; + } + goto rflag; + case 'q': + flags |= LLONGINT; + goto rflag; + case 't': + flags |= PTRINT; + goto rflag; + case 'z': + flags |= SIZEINT; + goto rflag; + case 'c': + if (flags & LONGINT) { + mbstate_t mbs; + size_t mbseqlen; + + memset(&mbs, 0, sizeof(mbs)); + mbseqlen = wcrtomb(buf, (wchar_t)GETARG(wint_t), &mbs); + if (mbseqlen == (size_t)-1) { + ret = -1; + goto error; + } + cp = buf; + size = (int)mbseqlen; + } else { + *(cp = buf) = GETARG(int); + size = 1; + } + sign = '\0'; + break; + case 'D': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'd': + case 'i': + _umax = SARG(); + if ((intmax_t)_umax < 0) { + _umax = -_umax; + sign = '-'; + } + base = DEC; + goto number; + case 'a': + case 'A': + if (ch == 'a') { + ox[1] = 'x'; + xdigs = xdigs_lower; + expchar = 'p'; + } else { + ox[1] = 'X'; + xdigs = xdigs_upper; + expchar = 'P'; + } + if (prec >= 0) prec++; + if (dtoaresult) __freedtoa(dtoaresult); + if (flags & LONGDBL) { + fparg.ldbl = GETARG(long double); + dtoaresult = cp = __hldtoa(fparg.ldbl, xdigs, prec, &expt, &signflag, &dtoaend); + if (dtoaresult == NULL) { + errno = ENOMEM; + goto error; + } + } else { + fparg.dbl = GETARG(double); + dtoaresult = cp = __hdtoa(fparg.dbl, xdigs, prec, &expt, &signflag, &dtoaend); + if (dtoaresult == NULL) { + errno = ENOMEM; + goto error; + } + } + if (prec < 0) prec = dtoaend - cp; + if (expt == INT_MAX) ox[1] = '\0'; + goto fp_common; + case 'e': + case 'E': + expchar = ch; + if (prec < 0) /* account for digit before decpt */ + prec = DEFPREC + 1; + else + prec++; + goto fp_begin; + case 'f': + case 'F': + expchar = '\0'; + goto fp_begin; + case 'g': + case 'G': + expchar = ch - ('g' - 'e'); + if (prec == 0) prec = 1; + fp_begin: + if (prec < 0) prec = DEFPREC; + if (dtoaresult) __freedtoa(dtoaresult); + if (flags & LONGDBL) { + fparg.ldbl = GETARG(long double); + dtoaresult = cp = __ldtoa(&fparg.ldbl, expchar ? 2 : 3, prec, &expt, &signflag, &dtoaend); + if (dtoaresult == NULL) { + errno = ENOMEM; + goto error; + } + } else { + fparg.dbl = GETARG(double); + dtoaresult = cp = __dtoa(fparg.dbl, expchar ? 2 : 3, prec, &expt, &signflag, &dtoaend); + if (dtoaresult == NULL) { + errno = ENOMEM; + goto error; + } + if (expt == 9999) expt = INT_MAX; + } + fp_common: + if (signflag) sign = '-'; + if (expt == INT_MAX) { /* inf or nan */ + if (*cp == 'N') + cp = (ch >= 'a') ? "nan" : "NAN"; + else + cp = (ch >= 'a') ? "inf" : "INF"; + size = 3; + flags &= ~ZEROPAD; + break; + } + flags |= FPT; + ndig = dtoaend - cp; + if (ch == 'g' || ch == 'G') { + if (expt > -4 && expt <= prec) { + /* Make %[gG] smell like %[fF] */ + expchar = '\0'; + if (flags & ALT) + prec -= expt; + else + prec = ndig - expt; + if (prec < 0) prec = 0; + } else { + /* + * Make %[gG] smell like %[eE], but + * trim trailing zeroes if no # flag. + */ + if (!(flags & ALT)) prec = ndig; + } + } + if (expchar) { + expsize = exponent(expstr, expt - 1, expchar); + size = expsize + prec; + if (prec > 1 || flags & ALT) ++size; + } else { + /* space for digits before decimal point */ + if (expt > 0) + size = expt; + else /* "0" */ + size = 1; + /* space for decimal pt and following digits */ + if (prec || flags & ALT) size += prec + 1; + lead = expt; + } + break; #ifndef NO_PRINTF_PERCENT_N - case 'n': - if (flags & LLONGINT) - *GETARG(long long *) = ret; - else if (flags & LONGINT) - *GETARG(long *) = ret; - else if (flags & SHORTINT) - *GETARG(short *) = ret; - else if (flags & CHARINT) - *GETARG(signed char *) = ret; - else if (flags & PTRINT) - *GETARG(ptrdiff_t *) = ret; - else if (flags & SIZEINT) - *GETARG(ssize_t *) = ret; - else if (flags & MAXINT) - *GETARG(intmax_t *) = ret; - else - *GETARG(int *) = ret; - continue; /* no output */ -#endif /* NO_PRINTF_PERCENT_N */ - case 'O': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'o': - _umax = UARG(); - base = OCT; - goto nosign; - 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 - */ - _umax = (u_long)GETARG(void *); - base = HEX; - xdigs = xdigs_lower; - ox[1] = 'x'; - goto nosign; - case 's': - if (flags & LONGINT) { - wchar_t *wcp; - - free(convbuf); - convbuf = NULL; - if ((wcp = GETARG(wchar_t *)) == NULL) { - cp = "(null)"; - } else { - convbuf = __wcsconv(wcp, prec); - if (convbuf == NULL) { - ret = -1; - goto error; - } - cp = convbuf; - } - } else - if ((cp = GETARG(char *)) == NULL) - cp = "(null)"; - 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(cp, 0, prec); - - size = p ? (p - cp) : prec; - } else { - size_t len; - - if ((len = strlen(cp)) > INT_MAX) - goto overflow; - size = (int)len; - } - sign = '\0'; - break; - case 'U': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'u': - _umax = UARG(); - base = DEC; - goto nosign; - case 'X': - xdigs = xdigs_upper; - goto hex; - case 'x': - xdigs = xdigs_lower; -hex: _umax = UARG(); - base = HEX; - /* leading 0x/X only if non-zero */ - if (flags & ALT && _umax != 0) - ox[1] = ch; - - /* unsigned conversions */ -nosign: sign = '\0'; - /* - * ``... diouXx conversions ... if a precision is - * specified, the 0 flag will be ignored.'' - * -- ANSI X3J11 - */ -number: if ((dprec = prec) >= 0) - flags &= ~ZEROPAD; - - /* - * ``The result of converting a zero value with an - * explicit precision of zero is no characters.'' - * -- ANSI X3J11 - */ - cp = buf + BUF; - if (_umax != 0 || prec != 0) { - /* - * Unsigned mod is hard, and unsigned mod - * by a constant is easier than that by - * a variable; hence this switch. - */ - switch (base) { - case OCT: - do { - *--cp = to_char(_umax & 7); - _umax >>= 3; - } while (_umax); - /* handle octal leading 0 */ - if (flags & ALT && *cp != '0') - *--cp = '0'; - break; - - case DEC: - /* many numbers are 1 digit */ - while (_umax >= 10) { - *--cp = to_char(_umax % 10); - _umax /= 10; - } - *--cp = to_char(_umax); - break; - - case HEX: - do { - *--cp = xdigs[_umax & 15]; - _umax >>= 4; - } while (_umax); - break; - - default: - cp = "bug in vfprintf: bad base"; - size = strlen(cp); - goto skipsize; - } - } - size = buf + BUF - cp; - if (size > BUF) /* should never happen */ - abort(); - skipsize: - break; - default: /* "%?" prints ?, unless ? is NUL */ - if (ch == '\0') - goto done; - /* pretend it was %c with argument ch */ - cp = buf; - *cp = ch; - size = 1; - sign = '\0'; - break; - } - - /* - * All reasonable formats wind up here. At this point, `cp' - * points to a string which (if not flags&LADJUST) should be - * padded out to `width' places. If flags&ZEROPAD, it should - * first be prefixed by any sign or other prefix; otherwise, - * it should be blank padded before the prefix is emitted. - * After any left-hand padding and prefixing, emit zeroes - * required by a decimal %[diouxX] precision, then print the - * string proper, then emit zeroes required by any leftover - * floating precision; finally, if LADJUST, pad with blanks. - * - * Compute actual size, so we know how much to pad. - * size excludes decimal prec; realsz includes it. - */ - realsz = dprec > size ? dprec : size; - if (sign) - realsz++; - if (ox[1]) - realsz+= 2; - - /* right-adjusting blank padding */ - if ((flags & (LADJUST|ZEROPAD)) == 0) - PAD(width - realsz, blanks); - - /* prefix */ - if (sign) - PRINT(&sign, 1); - if (ox[1]) { /* ox[1] is either x, X, or \0 */ - ox[0] = '0'; - PRINT(ox, 2); - } - - /* right-adjusting zero padding */ - if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD) - PAD(width - realsz, zeroes); - - /* leading zeroes from decimal precision */ - PAD(dprec - size, zeroes); - - /* the string or number proper */ - if ((flags & FPT) == 0) { - PRINT(cp, size); - } else { /* glue together f_p fragments */ - if (decimal_point == NULL) - decimal_point = nl_langinfo(RADIXCHAR); - if (!expchar) { /* %[fF] or sufficiently short %[gG] */ - if (expt <= 0) { - PRINT(zeroes, 1); - if (prec || flags & ALT) - PRINT(decimal_point, 1); - PAD(-expt, zeroes); - /* already handled initial 0's */ - prec += expt; - } else { - PRINTANDPAD(cp, dtoaend, lead, zeroes); - cp += lead; - if (prec || flags & ALT) - PRINT(decimal_point, 1); - } - 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(cp, ndig-1); - PAD(prec - ndig, zeroes); - } else { /* XeYYY */ - PRINT(cp, 1); - } - PRINT(expstr, expsize); - } - } - /* left-adjusting padding (always blank) */ - if (flags & LADJUST) - PAD(width - realsz, blanks); - - /* finally, adjust ret */ - if (width < realsz) - width = realsz; - if (width > INT_MAX - ret) - goto overflow; - ret += width; - - FLUSH(); /* copy out the I/O vectors */ - } + case 'n': + if (flags & LLONGINT) + *GETARG(long long*) = ret; + else if (flags & LONGINT) + *GETARG(long*) = ret; + else if (flags & SHORTINT) + *GETARG(short*) = ret; + else if (flags & CHARINT) + *GETARG(signed char*) = ret; + else if (flags & PTRINT) + *GETARG(ptrdiff_t*) = ret; + else if (flags & SIZEINT) + *GETARG(ssize_t*) = ret; + else if (flags & MAXINT) + *GETARG(intmax_t*) = ret; + else + *GETARG(int*) = ret; + continue; /* no output */ +#endif /* NO_PRINTF_PERCENT_N */ + case 'O': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'o': + _umax = UARG(); + base = OCT; + goto nosign; + 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 + */ + _umax = (u_long)GETARG(void*); + base = HEX; + xdigs = xdigs_lower; + ox[1] = 'x'; + goto nosign; + case 's': + if (flags & LONGINT) { + wchar_t* wcp; + + free(convbuf); + convbuf = NULL; + if ((wcp = GETARG(wchar_t*)) == NULL) { + cp = "(null)"; + } else { + convbuf = __wcsconv(wcp, prec); + if (convbuf == NULL) { + ret = -1; + goto error; + } + cp = convbuf; + } + } else if ((cp = GETARG(char*)) == NULL) + cp = "(null)"; + 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(cp, 0, prec); + + size = p ? (p - cp) : prec; + } else { + size_t len; + + if ((len = strlen(cp)) > INT_MAX) goto overflow; + size = (int)len; + } + sign = '\0'; + break; + case 'U': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'u': + _umax = UARG(); + base = DEC; + goto nosign; + case 'X': + xdigs = xdigs_upper; + goto hex; + case 'x': + xdigs = xdigs_lower; + hex: + _umax = UARG(); + base = HEX; + /* leading 0x/X only if non-zero */ + if (flags & ALT && _umax != 0) ox[1] = ch; + + /* unsigned conversions */ + nosign: + sign = '\0'; + /* + * ``... diouXx conversions ... if a precision is + * specified, the 0 flag will be ignored.'' + * -- ANSI X3J11 + */ + number: + if ((dprec = prec) >= 0) flags &= ~ZEROPAD; + + /* + * ``The result of converting a zero value with an + * explicit precision of zero is no characters.'' + * -- ANSI X3J11 + */ + cp = buf + BUF; + if (_umax != 0 || prec != 0) { + /* + * Unsigned mod is hard, and unsigned mod + * by a constant is easier than that by + * a variable; hence this switch. + */ + switch (base) { + case OCT: + do { + *--cp = to_char(_umax & 7); + _umax >>= 3; + } while (_umax); + /* handle octal leading 0 */ + if (flags & ALT && *cp != '0') *--cp = '0'; + break; + + case DEC: + /* many numbers are 1 digit */ + while (_umax >= 10) { + *--cp = to_char(_umax % 10); + _umax /= 10; + } + *--cp = to_char(_umax); + break; + + case HEX: + do { + *--cp = xdigs[_umax & 15]; + _umax >>= 4; + } while (_umax); + break; + + default: + cp = "bug in vfprintf: bad base"; + size = strlen(cp); + goto skipsize; + } + } + size = buf + BUF - cp; + if (size > BUF) /* should never happen */ + abort(); + skipsize: + break; + default: /* "%?" prints ?, unless ? is NUL */ + if (ch == '\0') goto done; + /* pretend it was %c with argument ch */ + cp = buf; + *cp = ch; + size = 1; + sign = '\0'; + break; + } + + /* + * All reasonable formats wind up here. At this point, `cp' + * points to a string which (if not flags&LADJUST) should be + * padded out to `width' places. If flags&ZEROPAD, it should + * first be prefixed by any sign or other prefix; otherwise, + * it should be blank padded before the prefix is emitted. + * After any left-hand padding and prefixing, emit zeroes + * required by a decimal %[diouxX] precision, then print the + * string proper, then emit zeroes required by any leftover + * floating precision; finally, if LADJUST, pad with blanks. + * + * Compute actual size, so we know how much to pad. + * size excludes decimal prec; realsz includes it. + */ + realsz = dprec > size ? dprec : size; + if (sign) realsz++; + if (ox[1]) realsz += 2; + + /* right-adjusting blank padding */ + if ((flags & (LADJUST | ZEROPAD)) == 0) PAD(width - realsz, blanks); + + /* prefix */ + if (sign) PRINT(&sign, 1); + if (ox[1]) { /* ox[1] is either x, X, or \0 */ + ox[0] = '0'; + PRINT(ox, 2); + } + + /* right-adjusting zero padding */ + if ((flags & (LADJUST | ZEROPAD)) == ZEROPAD) PAD(width - realsz, zeroes); + + /* leading zeroes from decimal precision */ + PAD(dprec - size, zeroes); + + /* the string or number proper */ + if ((flags & FPT) == 0) { + PRINT(cp, size); + } else { /* glue together f_p fragments */ + if (decimal_point == NULL) decimal_point = nl_langinfo(RADIXCHAR); + if (!expchar) { /* %[fF] or sufficiently short %[gG] */ + if (expt <= 0) { + PRINT(zeroes, 1); + if (prec || flags & ALT) PRINT(decimal_point, 1); + PAD(-expt, zeroes); + /* already handled initial 0's */ + prec += expt; + } else { + PRINTANDPAD(cp, dtoaend, lead, zeroes); + cp += lead; + if (prec || flags & ALT) PRINT(decimal_point, 1); + } + 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(cp, ndig - 1); + PAD(prec - ndig, zeroes); + } else { /* XeYYY */ + PRINT(cp, 1); + } + PRINT(expstr, expsize); + } + } + /* left-adjusting padding (always blank) */ + if (flags & LADJUST) PAD(width - realsz, blanks); + + /* finally, adjust ret */ + if (width < realsz) width = realsz; + if (width > INT_MAX - ret) goto overflow; + ret += width; + + FLUSH(); /* copy out the I/O vectors */ + } done: - FLUSH(); + FLUSH(); error: - va_end(orgap); - if (__sferror(fp)) - ret = -1; - goto finish; + va_end(orgap); + if (__sferror(fp)) ret = -1; + goto finish; overflow: - errno = ENOMEM; - ret = -1; + errno = ENOMEM; + ret = -1; finish: - free(convbuf); - if (dtoaresult) - __freedtoa(dtoaresult); - if (argtable != NULL && argtable != statargtable) { - munmap(argtable, argtablesiz); - argtable = NULL; - } - return (ret); + free(convbuf); + if (dtoaresult) __freedtoa(dtoaresult); + if (argtable != NULL && argtable != statargtable) { + munmap(argtable, argtablesiz); + argtable = NULL; + } + return (ret); } /* * 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_LLONG 10 -#define T_U_LLONG 11 -#define TP_LLONG 12 -#define T_DOUBLE 13 -#define T_LONG_DOUBLE 14 -#define TP_CHAR 15 -#define TP_VOID 16 -#define T_PTRINT 17 -#define TP_PTRINT 18 -#define T_SIZEINT 19 -#define T_SSIZEINT 20 -#define TP_SSIZEINT 21 -#define T_MAXINT 22 -#define T_MAXUINT 23 -#define TP_MAXINT 24 -#define T_CHAR 25 -#define T_U_CHAR 26 -#define T_WINT 27 -#define TP_WCHAR 28 +#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_LLONG 10 +#define T_U_LLONG 11 +#define TP_LLONG 12 +#define T_DOUBLE 13 +#define T_LONG_DOUBLE 14 +#define TP_CHAR 15 +#define TP_VOID 16 +#define T_PTRINT 17 +#define TP_PTRINT 18 +#define T_SIZEINT 19 +#define T_SSIZEINT 20 +#define TP_SSIZEINT 21 +#define T_MAXINT 22 +#define T_MAXUINT 23 +#define TP_MAXINT 24 +#define T_CHAR 25 +#define T_U_CHAR 26 +#define T_WINT 27 +#define TP_WCHAR 28 /* * Find all arguments when a positional parameter is encountered. Returns a @@ -1103,413 +1054,414 @@ finish: * used since we are attempting to make snprintf thread safe, and alloca is * problematic since we have nested functions..) */ -static int -__find_arguments(const char *fmt0, va_list ap, union arg **argtable, - size_t *argtablesiz) -{ - char *fmt; /* format string */ - int ch; /* character from fmt */ - int n, n2; /* handy integer (short term usage) */ - char *cp; /* handy char pointer (short term usage) */ - int flags; /* flags as above */ - unsigned char *typetable; /* table of types */ - unsigned char 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 */ - int ret = 0; /* return value */ - wchar_t wc; - mbstate_t ps; - - /* - * Add an argument type to the table, expanding if necessary. - */ -#define ADDTYPE(type) \ - ((nextarg >= tablesize) ? \ - __grow_type_table(&typetable, &tablesize) : 0, \ - (nextarg > tablemax) ? tablemax = nextarg : 0, \ - typetable[nextarg++] = type) - -#define ADDSARG() \ - ((flags&MAXINT) ? ADDTYPE(T_MAXINT) : \ - ((flags&PTRINT) ? ADDTYPE(T_PTRINT) : \ - ((flags&SIZEINT) ? ADDTYPE(T_SSIZEINT) : \ - ((flags&LLONGINT) ? ADDTYPE(T_LLONG) : \ - ((flags&LONGINT) ? ADDTYPE(T_LONG) : \ - ((flags&SHORTINT) ? ADDTYPE(T_SHORT) : \ - ((flags&CHARINT) ? ADDTYPE(T_CHAR) : ADDTYPE(T_INT)))))))) - -#define ADDUARG() \ - ((flags&MAXINT) ? ADDTYPE(T_MAXUINT) : \ - ((flags&PTRINT) ? ADDTYPE(T_PTRINT) : \ - ((flags&SIZEINT) ? ADDTYPE(T_SIZEINT) : \ - ((flags&LLONGINT) ? ADDTYPE(T_U_LLONG) : \ - ((flags&LONGINT) ? ADDTYPE(T_U_LONG) : \ - ((flags&SHORTINT) ? ADDTYPE(T_U_SHORT) : \ - ((flags&CHARINT) ? ADDTYPE(T_U_CHAR) : ADDTYPE(T_U_INT)))))))) - - /* - * Add * arguments to the type array. - */ -#define ADDASTER() \ - n2 = 0; \ - cp = fmt; \ - while (is_digit(*cp)) { \ - APPEND_DIGIT(n2, *cp); \ - cp++; \ - } \ - if (*cp == '$') { \ - int hold = nextarg; \ - nextarg = n2; \ - ADDTYPE(T_INT); \ - nextarg = hold; \ - fmt = ++cp; \ - } else { \ - ADDTYPE(T_INT); \ - } - fmt = (char *)fmt0; - typetable = stattypetable; - tablesize = STATIC_ARG_TBL_SIZE; - tablemax = 0; - nextarg = 1; - memset(typetable, T_UNUSED, STATIC_ARG_TBL_SIZE); - memset(&ps, 0, sizeof(ps)); - - /* - * Scan the format for conversions (`%' character). - */ - for (;;) { - cp = fmt; - while ((n = mbrtowc(&wc, fmt, MB_CUR_MAX, &ps)) > 0) { - fmt += n; - if (wc == '%') { - fmt--; - break; - } - } - if (n < 0) - return (-1); - if (n == 0) - goto done; - fmt++; /* skip over '%' */ - - flags = 0; - -rflag: ch = *fmt++; -reswitch: switch (ch) { - case ' ': - case '#': - case '\'': - goto rflag; - case '*': - ADDASTER(); - goto rflag; - case '-': - case '+': - goto rflag; - case '.': - if ((ch = *fmt++) == '*') { - ADDASTER(); - goto rflag; - } - while (is_digit(ch)) { - ch = *fmt++; - } - goto reswitch; - case '0': - goto rflag; - case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - n = 0; - do { - APPEND_DIGIT(n ,ch); - ch = *fmt++; - } while (is_digit(ch)); - if (ch == '$') { - nextarg = n; - goto rflag; - } - goto reswitch; - case 'L': - flags |= LONGDBL; - goto rflag; - case 'h': - if (*fmt == 'h') { - fmt++; - flags |= CHARINT; - } else { - flags |= SHORTINT; - } - goto rflag; - case 'j': - flags |= MAXINT; - goto rflag; - case 'l': - if (*fmt == 'l') { - fmt++; - flags |= LLONGINT; - } else { - flags |= LONGINT; - } - goto rflag; - case 'q': - flags |= LLONGINT; - goto rflag; - case 't': - flags |= PTRINT; - goto rflag; - case 'z': - flags |= SIZEINT; - goto rflag; - case 'c': - if (flags & LONGINT) - ADDTYPE(T_WINT); - else - ADDTYPE(T_INT); - break; - case 'D': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'd': - case 'i': - ADDSARG(); - break; - case 'a': - case 'A': - case 'e': - case 'E': - case 'f': - case 'F': - case 'g': - case 'G': - if (flags & LONGDBL) - ADDTYPE(T_LONG_DOUBLE); - else - ADDTYPE(T_DOUBLE); - break; +static int __find_arguments(const char* fmt0, va_list ap, union arg** argtable, + size_t* argtablesiz) { + char* fmt; /* format string */ + int ch; /* character from fmt */ + int n, n2; /* handy integer (short term usage) */ + char* cp; /* handy char pointer (short term usage) */ + int flags; /* flags as above */ + unsigned char* typetable; /* table of types */ + unsigned char 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 */ + int ret = 0; /* return value */ + wchar_t wc; + mbstate_t ps; + + /* + * Add an argument type to the table, expanding if necessary. + */ +#define ADDTYPE(type) \ + ((nextarg >= tablesize) ? __grow_type_table(&typetable, &tablesize) : 0, \ + (nextarg > tablemax) ? tablemax = nextarg : 0, typetable[nextarg++] = type) + +#define ADDSARG() \ + ((flags & MAXINT) \ + ? ADDTYPE(T_MAXINT) \ + : ((flags & PTRINT) ? ADDTYPE(T_PTRINT) \ + : ((flags & SIZEINT) \ + ? ADDTYPE(T_SSIZEINT) \ + : ((flags & LLONGINT) \ + ? ADDTYPE(T_LLONG) \ + : ((flags & LONGINT) \ + ? ADDTYPE(T_LONG) \ + : ((flags & SHORTINT) \ + ? ADDTYPE(T_SHORT) \ + : ((flags & CHARINT) ? ADDTYPE(T_CHAR) \ + : ADDTYPE(T_INT)))))))) + +#define ADDUARG() \ + ((flags & MAXINT) \ + ? ADDTYPE(T_MAXUINT) \ + : ((flags & PTRINT) \ + ? ADDTYPE(T_PTRINT) \ + : ((flags & SIZEINT) \ + ? ADDTYPE(T_SIZEINT) \ + : ((flags & LLONGINT) \ + ? ADDTYPE(T_U_LLONG) \ + : ((flags & LONGINT) \ + ? ADDTYPE(T_U_LONG) \ + : ((flags & SHORTINT) \ + ? ADDTYPE(T_U_SHORT) \ + : ((flags & CHARINT) ? ADDTYPE(T_U_CHAR) \ + : ADDTYPE(T_U_INT)))))))) + + /* + * Add * arguments to the type array. + */ +#define ADDASTER() \ + n2 = 0; \ + cp = fmt; \ + while (is_digit(*cp)) { \ + APPEND_DIGIT(n2, *cp); \ + cp++; \ + } \ + if (*cp == '$') { \ + int hold = nextarg; \ + nextarg = n2; \ + ADDTYPE(T_INT); \ + nextarg = hold; \ + fmt = ++cp; \ + } else { \ + ADDTYPE(T_INT); \ + } + fmt = (char*)fmt0; + typetable = stattypetable; + tablesize = STATIC_ARG_TBL_SIZE; + tablemax = 0; + nextarg = 1; + memset(typetable, T_UNUSED, STATIC_ARG_TBL_SIZE); + memset(&ps, 0, sizeof(ps)); + + /* + * Scan the format for conversions (`%' character). + */ + for (;;) { + cp = fmt; + while ((n = mbrtowc(&wc, fmt, MB_CUR_MAX, &ps)) > 0) { + fmt += n; + if (wc == '%') { + fmt--; + break; + } + } + if (n < 0) return (-1); + if (n == 0) goto done; + fmt++; /* skip over '%' */ + + flags = 0; + + rflag: + ch = *fmt++; + reswitch: + switch (ch) { + case ' ': + case '#': + case '\'': + goto rflag; + case '*': + ADDASTER(); + goto rflag; + case '-': + case '+': + goto rflag; + case '.': + if ((ch = *fmt++) == '*') { + ADDASTER(); + goto rflag; + } + while (is_digit(ch)) { + ch = *fmt++; + } + goto reswitch; + case '0': + goto rflag; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + n = 0; + do { + APPEND_DIGIT(n, ch); + ch = *fmt++; + } while (is_digit(ch)); + if (ch == '$') { + nextarg = n; + goto rflag; + } + goto reswitch; + case 'L': + flags |= LONGDBL; + goto rflag; + case 'h': + if (*fmt == 'h') { + fmt++; + flags |= CHARINT; + } else { + flags |= SHORTINT; + } + goto rflag; + case 'j': + flags |= MAXINT; + goto rflag; + case 'l': + if (*fmt == 'l') { + fmt++; + flags |= LLONGINT; + } else { + flags |= LONGINT; + } + goto rflag; + case 'q': + flags |= LLONGINT; + goto rflag; + case 't': + flags |= PTRINT; + goto rflag; + case 'z': + flags |= SIZEINT; + goto rflag; + case 'c': + if (flags & LONGINT) + ADDTYPE(T_WINT); + else + ADDTYPE(T_INT); + break; + case 'D': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'd': + case 'i': + ADDSARG(); + break; + case 'a': + case 'A': + case 'e': + case 'E': + case 'f': + case 'F': + case 'g': + case 'G': + if (flags & LONGDBL) + ADDTYPE(T_LONG_DOUBLE); + else + ADDTYPE(T_DOUBLE); + break; #ifndef NO_PRINTF_PERCENT_N - case 'n': - if (flags & LLONGINT) - ADDTYPE(TP_LLONG); - else if (flags & LONGINT) - ADDTYPE(TP_LONG); - else if (flags & SHORTINT) - ADDTYPE(TP_SHORT); - else if (flags & PTRINT) - ADDTYPE(TP_PTRINT); - else if (flags & SIZEINT) - ADDTYPE(TP_SSIZEINT); - else if (flags & MAXINT) - ADDTYPE(TP_MAXINT); - else - ADDTYPE(TP_INT); - continue; /* no output */ -#endif /* NO_PRINTF_PERCENT_N */ - case 'O': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'o': - ADDUARG(); - break; - case 'p': - ADDTYPE(TP_VOID); - break; - case 's': - if (flags & LONGINT) - ADDTYPE(TP_WCHAR); - else - ADDTYPE(TP_CHAR); - break; - case 'U': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'u': - case 'X': - case 'x': - ADDUARG(); - break; - default: /* "%?" prints ?, unless ? is NUL */ - if (ch == '\0') - goto done; - break; - } - } + case 'n': + if (flags & LLONGINT) + ADDTYPE(TP_LLONG); + else if (flags & LONGINT) + ADDTYPE(TP_LONG); + else if (flags & SHORTINT) + ADDTYPE(TP_SHORT); + else if (flags & PTRINT) + ADDTYPE(TP_PTRINT); + else if (flags & SIZEINT) + ADDTYPE(TP_SSIZEINT); + else if (flags & MAXINT) + ADDTYPE(TP_MAXINT); + else + ADDTYPE(TP_INT); + continue; /* no output */ +#endif /* NO_PRINTF_PERCENT_N */ + case 'O': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'o': + ADDUARG(); + break; + case 'p': + ADDTYPE(TP_VOID); + break; + case 's': + if (flags & LONGINT) + ADDTYPE(TP_WCHAR); + else + ADDTYPE(TP_CHAR); + break; + case 'U': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'u': + case 'X': + case 'x': + ADDUARG(); + break; + default: /* "%?" prints ?, unless ? is NUL */ + if (ch == '\0') goto done; + break; + } + } done: - /* - * Build the argument table. - */ - if (tablemax >= STATIC_ARG_TBL_SIZE) { - *argtablesiz = sizeof(union arg) * (tablemax + 1); - *argtable = mmap(NULL, *argtablesiz, - PROT_WRITE|PROT_READ, MAP_ANON|MAP_PRIVATE, -1, 0); - if (*argtable == MAP_FAILED) - return (-1); - } + /* + * Build the argument table. + */ + if (tablemax >= STATIC_ARG_TBL_SIZE) { + *argtablesiz = sizeof(union arg) * (tablemax + 1); + *argtable = mmap(NULL, *argtablesiz, PROT_WRITE | PROT_READ, MAP_ANON | MAP_PRIVATE, -1, 0); + if (*argtable == MAP_FAILED) return (-1); + } #if 0 /* XXX is this required? */ (*argtable)[0].intarg = 0; #endif - for (n = 1; n <= tablemax; n++) { - switch (typetable[n]) { - case T_UNUSED: - case T_CHAR: - case T_U_CHAR: - case T_SHORT: - case T_U_SHORT: - case T_INT: - (*argtable)[n].intarg = va_arg(ap, int); - break; - case TP_SHORT: - (*argtable)[n].pshortarg = va_arg(ap, short *); - break; - case T_U_INT: - (*argtable)[n].uintarg = va_arg(ap, unsigned int); - break; - case TP_INT: - (*argtable)[n].pintarg = va_arg(ap, int *); - break; - case T_LONG: - (*argtable)[n].longarg = va_arg(ap, long); - break; - case T_U_LONG: - (*argtable)[n].ulongarg = va_arg(ap, unsigned long); - break; - case TP_LONG: - (*argtable)[n].plongarg = va_arg(ap, long *); - break; - 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_DOUBLE: - (*argtable)[n].doublearg = va_arg(ap, double); - break; - case T_LONG_DOUBLE: - (*argtable)[n].longdoublearg = va_arg(ap, long double); - break; - case TP_CHAR: - (*argtable)[n].pchararg = va_arg(ap, char *); - break; - case TP_VOID: - (*argtable)[n].pvoidarg = va_arg(ap, void *); - break; - case T_PTRINT: - (*argtable)[n].ptrdiffarg = va_arg(ap, ptrdiff_t); - break; - case TP_PTRINT: - (*argtable)[n].pptrdiffarg = va_arg(ap, ptrdiff_t *); - break; - case T_SIZEINT: - (*argtable)[n].sizearg = va_arg(ap, size_t); - break; - case T_SSIZEINT: - (*argtable)[n].ssizearg = va_arg(ap, ssize_t); - break; - case TP_SSIZEINT: - (*argtable)[n].pssizearg = va_arg(ap, ssize_t *); - break; - case T_MAXINT: - (*argtable)[n].intmaxarg = va_arg(ap, intmax_t); - break; - case T_MAXUINT: - (*argtable)[n].uintmaxarg = va_arg(ap, uintmax_t); - break; - case TP_MAXINT: - (*argtable)[n].pintmaxarg = va_arg(ap, intmax_t *); - break; - case T_WINT: - (*argtable)[n].wintarg = va_arg(ap, wint_t); - break; - case TP_WCHAR: - (*argtable)[n].pwchararg = va_arg(ap, wchar_t *); - break; - } - } - goto finish; + for (n = 1; n <= tablemax; n++) { + switch (typetable[n]) { + case T_UNUSED: + case T_CHAR: + case T_U_CHAR: + case T_SHORT: + case T_U_SHORT: + case T_INT: + (*argtable)[n].intarg = va_arg(ap, int); + break; + case TP_SHORT: + (*argtable)[n].pshortarg = va_arg(ap, short*); + break; + case T_U_INT: + (*argtable)[n].uintarg = va_arg(ap, unsigned int); + break; + case TP_INT: + (*argtable)[n].pintarg = va_arg(ap, int*); + break; + case T_LONG: + (*argtable)[n].longarg = va_arg(ap, long); + break; + case T_U_LONG: + (*argtable)[n].ulongarg = va_arg(ap, unsigned long); + break; + case TP_LONG: + (*argtable)[n].plongarg = va_arg(ap, long*); + break; + 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_DOUBLE: + (*argtable)[n].doublearg = va_arg(ap, double); + break; + case T_LONG_DOUBLE: + (*argtable)[n].longdoublearg = va_arg(ap, long double); + break; + case TP_CHAR: + (*argtable)[n].pchararg = va_arg(ap, char*); + break; + case TP_VOID: + (*argtable)[n].pvoidarg = va_arg(ap, void*); + break; + case T_PTRINT: + (*argtable)[n].ptrdiffarg = va_arg(ap, ptrdiff_t); + break; + case TP_PTRINT: + (*argtable)[n].pptrdiffarg = va_arg(ap, ptrdiff_t*); + break; + case T_SIZEINT: + (*argtable)[n].sizearg = va_arg(ap, size_t); + break; + case T_SSIZEINT: + (*argtable)[n].ssizearg = va_arg(ap, ssize_t); + break; + case TP_SSIZEINT: + (*argtable)[n].pssizearg = va_arg(ap, ssize_t*); + break; + case T_MAXINT: + (*argtable)[n].intmaxarg = va_arg(ap, intmax_t); + break; + case T_MAXUINT: + (*argtable)[n].uintmaxarg = va_arg(ap, uintmax_t); + break; + case TP_MAXINT: + (*argtable)[n].pintmaxarg = va_arg(ap, intmax_t*); + break; + case T_WINT: + (*argtable)[n].wintarg = va_arg(ap, wint_t); + break; + case TP_WCHAR: + (*argtable)[n].pwchararg = va_arg(ap, wchar_t*); + break; + } + } + goto finish; overflow: - errno = ENOMEM; - ret = -1; + errno = ENOMEM; + ret = -1; finish: - if (typetable != NULL && typetable != stattypetable) { - munmap(typetable, *argtablesiz); - typetable = NULL; - } - return (ret); + if (typetable != NULL && typetable != stattypetable) { + munmap(typetable, *argtablesiz); + typetable = NULL; + } + return (ret); } /* * Increase the size of the type table. */ -static int -__grow_type_table(unsigned char **typetable, int *tablesize) -{ - unsigned char *oldtable = *typetable; - int newsize = *tablesize * 2; - - if (newsize < getpagesize()) - newsize = getpagesize(); - - if (*tablesize == STATIC_ARG_TBL_SIZE) { - *typetable = mmap(NULL, newsize, PROT_WRITE|PROT_READ, - MAP_ANON|MAP_PRIVATE, -1, 0); - if (*typetable == MAP_FAILED) - return (-1); - bcopy(oldtable, *typetable, *tablesize); - } else { - unsigned char *new = mmap(NULL, newsize, PROT_WRITE|PROT_READ, - MAP_ANON|MAP_PRIVATE, -1, 0); - if (new == MAP_FAILED) - return (-1); - memmove(new, *typetable, *tablesize); - munmap(*typetable, *tablesize); - *typetable = new; - } - memset(*typetable + *tablesize, T_UNUSED, (newsize - *tablesize)); - - *tablesize = newsize; - return (0); +static int __grow_type_table(unsigned char** typetable, int* tablesize) { + unsigned char* oldtable = *typetable; + int newsize = *tablesize * 2; + + if (newsize < getpagesize()) newsize = getpagesize(); + + if (*tablesize == STATIC_ARG_TBL_SIZE) { + *typetable = mmap(NULL, newsize, PROT_WRITE | PROT_READ, MAP_ANON | MAP_PRIVATE, -1, 0); + if (*typetable == MAP_FAILED) return (-1); + bcopy(oldtable, *typetable, *tablesize); + } else { + unsigned char* new = mmap(NULL, newsize, PROT_WRITE | PROT_READ, MAP_ANON | MAP_PRIVATE, -1, 0); + if (new == MAP_FAILED) return (-1); + memmove(new, *typetable, *tablesize); + munmap(*typetable, *tablesize); + *typetable = new; + } + memset(*typetable + *tablesize, T_UNUSED, (newsize - *tablesize)); + + *tablesize = newsize; + return (0); } - -static int -exponent(char *p0, int exp, int fmtch) -{ - char *p, *t; - char expbuf[MAXEXPDIG]; - - p = p0; - *p++ = fmtch; - if (exp < 0) { - exp = -exp; - *p++ = '-'; - } else - *p++ = '+'; - t = expbuf + MAXEXPDIG; - if (exp > 9) { - do { - *--t = to_char(exp % 10); - } while ((exp /= 10) > 9); - *--t = to_char(exp); - for (; t < expbuf + MAXEXPDIG; *p++ = *t++) - /* nothing */; - } else { - /* - * Exponents for decimal floating point conversions - * (%[eEgG]) must be at least two characters long, - * whereas exponents for hexadecimal conversions can - * be only one character long. - */ - if (fmtch == 'e' || fmtch == 'E') - *p++ = '0'; - *p++ = to_char(exp); - } - return (p - p0); +static int exponent(char* p0, int exp, int fmtch) { + char *p, *t; + char expbuf[MAXEXPDIG]; + + p = p0; + *p++ = fmtch; + if (exp < 0) { + exp = -exp; + *p++ = '-'; + } else + *p++ = '+'; + t = expbuf + MAXEXPDIG; + if (exp > 9) { + do { + *--t = to_char(exp % 10); + } while ((exp /= 10) > 9); + *--t = to_char(exp); + for (; t < expbuf + MAXEXPDIG; *p++ = *t++) /* nothing */; + } else { + /* + * Exponents for decimal floating point conversions + * (%[eEgG]) must be at least two characters long, + * whereas exponents for hexadecimal conversions can + * be only one character long. + */ + if (fmtch == 'e' || fmtch == 'E') *p++ = '0'; + *p++ = to_char(exp); + } + return (p - p0); } diff --git a/libc/stdio/vfscanf.c b/libc/stdio/vfscanf.c index 792d7ce96e..c18e214a37 100644 --- a/libc/stdio/vfscanf.c +++ b/libc/stdio/vfscanf.c @@ -32,746 +32,724 @@ */ #include <ctype.h> -#include <wctype.h> #include <inttypes.h> #include <stdarg.h> #include <stddef.h> #include <stdio.h> #include <stdlib.h> #include <string.h> +#include <wctype.h> #include "local.h" #include "floatio.h" -#define BUF 513 /* Maximum length of numeric string. */ +#define BUF 513 /* Maximum length of numeric string. */ /* * Flags used during conversion. */ -#define LONG 0x00001 /* l: long or double */ -#define LONGDBL 0x00002 /* L: long double */ -#define SHORT 0x00004 /* h: short */ -#define SHORTSHORT 0x00008 /* hh: 8 bit integer */ -#define LLONG 0x00010 /* ll: long long (+ deprecated q: quad) */ -#define POINTER 0x00020 /* p: void * (as hex) */ -#define SIZEINT 0x00040 /* z: (signed) size_t */ -#define MAXINT 0x00080 /* j: intmax_t */ -#define PTRINT 0x00100 /* t: ptrdiff_t */ -#define NOSKIP 0x00200 /* [ or c: do not skip blanks */ -#define SUPPRESS 0x00400 /* *: suppress assignment */ -#define UNSIGNED 0x00800 /* %[oupxX] conversions */ +#define LONG 0x00001 /* l: long or double */ +#define LONGDBL 0x00002 /* L: long double */ +#define SHORT 0x00004 /* h: short */ +#define SHORTSHORT 0x00008 /* hh: 8 bit integer */ +#define LLONG 0x00010 /* ll: long long (+ deprecated q: quad) */ +#define POINTER 0x00020 /* p: void * (as hex) */ +#define SIZEINT 0x00040 /* z: (signed) size_t */ +#define MAXINT 0x00080 /* j: intmax_t */ +#define PTRINT 0x00100 /* t: ptrdiff_t */ +#define NOSKIP 0x00200 /* [ or c: do not skip blanks */ +#define SUPPRESS 0x00400 /* *: suppress assignment */ +#define UNSIGNED 0x00800 /* %[oupxX] conversions */ /* * The following are used in numeric conversions only: * SIGNOK, HAVESIGN, NDIGITS, DPTOK, and EXPOK are for floating point; * SIGNOK, HAVESIGN, NDIGITS, PFXOK, and NZDIGITS are for integral. */ -#define SIGNOK 0x01000 /* +/- is (still) legal */ -#define HAVESIGN 0x02000 /* sign detected */ -#define NDIGITS 0x04000 /* no digits detected */ +#define SIGNOK 0x01000 /* +/- is (still) legal */ +#define HAVESIGN 0x02000 /* sign detected */ +#define NDIGITS 0x04000 /* no digits detected */ -#define DPTOK 0x08000 /* (float) decimal point is still legal */ -#define EXPOK 0x10000 /* (float) exponent (e+3, etc) still legal */ +#define DPTOK 0x08000 /* (float) decimal point is still legal */ +#define EXPOK 0x10000 /* (float) exponent (e+3, etc) still legal */ -#define PFXOK 0x08000 /* 0x prefix is (still) legal */ -#define NZDIGITS 0x10000 /* no zero digits detected */ +#define PFXOK 0x08000 /* 0x prefix is (still) legal */ +#define NZDIGITS 0x10000 /* no zero digits detected */ /* * Conversion types. */ -#define CT_CHAR 0 /* %c conversion */ -#define CT_CCL 1 /* %[...] conversion */ -#define CT_STRING 2 /* %s conversion */ -#define CT_INT 3 /* integer, i.e., strtoimax or strtoumax */ -#define CT_FLOAT 4 /* floating, i.e., strtod */ +#define CT_CHAR 0 /* %c conversion */ +#define CT_CCL 1 /* %[...] conversion */ +#define CT_STRING 2 /* %s conversion */ +#define CT_INT 3 /* integer, i.e., strtoimax or strtoumax */ +#define CT_FLOAT 4 /* floating, i.e., strtod */ #define u_char unsigned char #define u_long unsigned long -static u_char *__sccl(char *, u_char *); +static u_char* __sccl(char*, u_char*); /* * Internal, unlocked version of vfscanf */ -int -__svfscanf(FILE *fp, const char *fmt0, __va_list ap) -{ - u_char *fmt = (u_char *)fmt0; - int c; /* character from format, or conversion */ - size_t width; /* field width, or 0 */ - char *p; /* points into all kinds of strings */ - int n; /* handy integer */ - int flags; /* flags as defined above */ - char *p0; /* saves original value of p when necessary */ - int nassigned; /* number of fields assigned */ - int nread; /* number of characters consumed from fp */ - int base; /* base argument to strtoimax/strtouimax */ - char ccltab[256]; /* character class table for %[...] */ - char buf[BUF]; /* buffer for numeric conversions */ - wchar_t *wcp; /* handy wide character pointer */ - size_t nconv; /* length of multibyte sequence converted */ - mbstate_t mbs; - - /* `basefix' is used to avoid `if' tests in the integer scanner */ - static short basefix[17] = - { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; - - _SET_ORIENTATION(fp, -1); - - nassigned = 0; - nread = 0; - base = 0; /* XXX just to keep gcc happy */ - for (;;) { - c = *fmt++; - if (c == 0) - return (nassigned); - if (isspace(c)) { - while ((fp->_r > 0 || __srefill(fp) == 0) && - isspace(*fp->_p)) - nread++, fp->_r--, fp->_p++; - continue; - } - if (c != '%') - goto literal; - width = 0; - flags = 0; - /* - * switch on the format. continue if done; - * break once format type is derived. - */ -again: c = *fmt++; - switch (c) { - case '%': -literal: - if (fp->_r <= 0 && __srefill(fp)) - goto input_failure; - if (*fp->_p != c) - goto match_failure; - fp->_r--, fp->_p++; - nread++; - continue; - - case '*': - flags |= SUPPRESS; - goto again; - case 'j': - flags |= MAXINT; - goto again; - case 'L': - flags |= LONGDBL; - goto again; - case 'h': - if (*fmt == 'h') { - fmt++; - flags |= SHORTSHORT; - } else { - flags |= SHORT; - } - goto again; - case 'l': - if (*fmt == 'l') { - fmt++; - flags |= LLONG; - } else { - flags |= LONG; - } - goto again; - case 'q': - flags |= LLONG; /* deprecated */ - goto again; - case 't': - flags |= PTRINT; - goto again; - case 'z': - flags |= SIZEINT; - goto again; - - case '0': case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - width = width * 10 + c - '0'; - goto again; - - /* - * Conversions. - * Those marked `compat' are for 4.[123]BSD compatibility. - * - * (According to ANSI, E and X formats are supposed - * to the same as e and x. Sorry about that.) - */ - case 'D': /* compat */ - flags |= LONG; - /* FALLTHROUGH */ - case 'd': - c = CT_INT; - base = 10; - break; - - case 'i': - c = CT_INT; - base = 0; - break; - - case 'O': /* compat */ - flags |= LONG; - /* FALLTHROUGH */ - case 'o': - c = CT_INT; - flags |= UNSIGNED; - base = 8; - break; - - case 'u': - c = CT_INT; - flags |= UNSIGNED; - base = 10; - break; - - case 'X': - case 'x': - flags |= PFXOK; /* enable 0x prefixing */ - c = CT_INT; - flags |= UNSIGNED; - base = 16; - break; - - case 'e': case 'E': - case 'f': case 'F': - case 'g': case 'G': - case 'a': case 'A': - c = CT_FLOAT; - break; - - case 's': - c = CT_STRING; - break; - - case '[': - fmt = __sccl(ccltab, fmt); - flags |= NOSKIP; - c = CT_CCL; - break; - - case 'c': - flags |= NOSKIP; - c = CT_CHAR; - break; - - case 'p': /* pointer format is like hex */ - flags |= POINTER | PFXOK; - c = CT_INT; - flags |= UNSIGNED; - base = 16; - break; - - case 'n': - if (flags & SUPPRESS) - continue; - if (flags & SHORTSHORT) - *va_arg(ap, signed char *) = nread; - else if (flags & SHORT) - *va_arg(ap, short *) = nread; - else if (flags & LONG) - *va_arg(ap, long *) = nread; - else if (flags & SIZEINT) - *va_arg(ap, ssize_t *) = nread; - else if (flags & PTRINT) - *va_arg(ap, ptrdiff_t *) = nread; - else if (flags & LLONG) - *va_arg(ap, long long *) = nread; - else if (flags & MAXINT) - *va_arg(ap, intmax_t *) = nread; - else - *va_arg(ap, int *) = nread; - continue; - - /* - * Disgusting backwards compatibility hacks. XXX - */ - case '\0': /* compat */ - return (EOF); - - default: /* compat */ - if (isupper(c)) - flags |= LONG; - c = CT_INT; - base = 10; - break; - } - - /* - * We have a conversion that requires input. - */ - if (fp->_r <= 0 && __srefill(fp)) - goto input_failure; - - /* - * Consume leading white space, except for formats - * that suppress this. - */ - if ((flags & NOSKIP) == 0) { - while (isspace(*fp->_p)) { - nread++; - if (--fp->_r > 0) - fp->_p++; - else if (__srefill(fp)) - goto input_failure; - } - /* - * Note that there is at least one character in - * the buffer, so conversions that do not set NOSKIP - * ca no longer result in an input failure. - */ - } - - /* - * Do the conversion. - */ - switch (c) { - - case CT_CHAR: - /* scan arbitrary characters (sets NOSKIP) */ - if (width == 0) - width = 1; - if (flags & LONG) { - if ((flags & SUPPRESS) == 0) - wcp = va_arg(ap, wchar_t *); - else - wcp = NULL; - n = 0; - while (width != 0) { - if (n == (int)MB_CUR_MAX) { - fp->_flags |= __SERR; - goto input_failure; - } - buf[n++] = *fp->_p; - fp->_p++; - fp->_r--; - memset(&mbs, 0, sizeof(mbs)); - nconv = mbrtowc(wcp, buf, n, &mbs); - if (nconv == (size_t)-1) { - fp->_flags |= __SERR; - goto input_failure; - } - if (nconv == 0 && !(flags & SUPPRESS)) - *wcp = L'\0'; - if (nconv != (size_t)-2) { - nread += n; - width--; - if (!(flags & SUPPRESS)) - wcp++; - n = 0; - } - if (fp->_r <= 0 && __srefill(fp)) { - if (n != 0) { - fp->_flags |= __SERR; - goto input_failure; - } - break; - } - } - if (!(flags & SUPPRESS)) - nassigned++; - } else if (flags & SUPPRESS) { - size_t sum = 0; - for (;;) { - if ((n = fp->_r) < (int)width) { - sum += n; - width -= n; - fp->_p += n; - if (__srefill(fp)) { - if (sum == 0) - goto input_failure; - break; - } - } else { - sum += width; - fp->_r -= width; - fp->_p += width; - break; - } - } - nread += sum; - } else { - size_t r = fread((void *)va_arg(ap, char *), 1, - width, fp); - - if (r == 0) - goto input_failure; - nread += r; - nassigned++; - } - break; - - case CT_CCL: - /* scan a (nonempty) character class (sets NOSKIP) */ - if (width == 0) - width = (size_t)~0; /* `infinity' */ - /* take only those things in the class */ - if (flags & LONG) { - wchar_t twc; - int nchars; - - if ((flags & SUPPRESS) == 0) - wcp = va_arg(ap, wchar_t *); - else - wcp = &twc; - n = 0; - nchars = 0; - while (width != 0) { - if (n == (int)MB_CUR_MAX) { - fp->_flags |= __SERR; - goto input_failure; - } - buf[n++] = *fp->_p; - fp->_p++; - fp->_r--; - memset(&mbs, 0, sizeof(mbs)); - nconv = mbrtowc(wcp, buf, n, &mbs); - if (nconv == (size_t)-1) { - fp->_flags |= __SERR; - goto input_failure; - } - if (nconv == 0) - *wcp = L'\0'; - if (nconv != (size_t)-2) { - if (wctob(*wcp) != EOF && - !ccltab[wctob(*wcp)]) { - while (n != 0) { - n--; - ungetc(buf[n], - fp); - } - break; - } - nread += n; - width--; - if (!(flags & SUPPRESS)) - wcp++; - nchars++; - n = 0; - } - if (fp->_r <= 0 && __srefill(fp)) { - if (n != 0) { - fp->_flags |= __SERR; - goto input_failure; - } - break; - } - } - if (n != 0) { - fp->_flags |= __SERR; - goto input_failure; - } - n = nchars; - if (n == 0) - goto match_failure; - if (!(flags & SUPPRESS)) { - *wcp = L'\0'; - nassigned++; - } - } else - /* take only those things in the class */ - if (flags & SUPPRESS) { - n = 0; - while (ccltab[*fp->_p]) { - n++, fp->_r--, fp->_p++; - if (--width == 0) - break; - if (fp->_r <= 0 && __srefill(fp)) { - if (n == 0) - goto input_failure; - break; - } - } - if (n == 0) - goto match_failure; - } else { - p0 = p = va_arg(ap, char *); - while (ccltab[*fp->_p]) { - fp->_r--; - *p++ = *fp->_p++; - if (--width == 0) - break; - if (fp->_r <= 0 && __srefill(fp)) { - if (p == p0) - goto input_failure; - break; - } - } - n = p - p0; - if (n == 0) - goto match_failure; - *p = '\0'; - nassigned++; - } - nread += n; - break; - - case CT_STRING: - /* like CCL, but zero-length string OK, & no NOSKIP */ - if (width == 0) - width = (size_t)~0; - if (flags & LONG) { - wchar_t twc; - - if ((flags & SUPPRESS) == 0) - wcp = va_arg(ap, wchar_t *); - else - wcp = &twc; - n = 0; - while (!isspace(*fp->_p) && width != 0) { - if (n == (int)MB_CUR_MAX) { - fp->_flags |= __SERR; - goto input_failure; - } - buf[n++] = *fp->_p; - fp->_p++; - fp->_r--; - memset(&mbs, 0, sizeof(mbs)); - nconv = mbrtowc(wcp, buf, n, &mbs); - if (nconv == (size_t)-1) { - fp->_flags |= __SERR; - goto input_failure; - } - if (nconv == 0) - *wcp = L'\0'; - if (nconv != (size_t)-2) { - if (iswspace(*wcp)) { - while (n != 0) { - n--; - ungetc(buf[n], - fp); - } - break; - } - nread += n; - width--; - if (!(flags & SUPPRESS)) - wcp++; - n = 0; - } - if (fp->_r <= 0 && __srefill(fp)) { - if (n != 0) { - fp->_flags |= __SERR; - goto input_failure; - } - break; - } - } - if (!(flags & SUPPRESS)) { - *wcp = L'\0'; - nassigned++; - } - } else if (flags & SUPPRESS) { - n = 0; - while (!isspace(*fp->_p)) { - n++, fp->_r--, fp->_p++; - if (--width == 0) - break; - if (fp->_r <= 0 && __srefill(fp)) - break; - } - nread += n; - } else { - p0 = p = va_arg(ap, char *); - while (!isspace(*fp->_p)) { - fp->_r--; - *p++ = *fp->_p++; - if (--width == 0) - break; - if (fp->_r <= 0 && __srefill(fp)) - break; - } - *p = '\0'; - nread += p - p0; - nassigned++; - } - continue; - - case CT_INT: - /* scan an integer as if by strtoimax/strtoumax */ +int __svfscanf(FILE* fp, const char* fmt0, __va_list ap) { + u_char* fmt = (u_char*)fmt0; + int c; /* character from format, or conversion */ + size_t width; /* field width, or 0 */ + char* p; /* points into all kinds of strings */ + int n; /* handy integer */ + int flags; /* flags as defined above */ + char* p0; /* saves original value of p when necessary */ + int nassigned; /* number of fields assigned */ + int nread; /* number of characters consumed from fp */ + int base; /* base argument to strtoimax/strtouimax */ + char ccltab[256]; /* character class table for %[...] */ + char buf[BUF]; /* buffer for numeric conversions */ + wchar_t* wcp; /* handy wide character pointer */ + size_t nconv; /* length of multibyte sequence converted */ + mbstate_t mbs; + + /* `basefix' is used to avoid `if' tests in the integer scanner */ + static short basefix[17] = { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; + + _SET_ORIENTATION(fp, -1); + + nassigned = 0; + nread = 0; + base = 0; /* XXX just to keep gcc happy */ + for (;;) { + c = *fmt++; + if (c == 0) return (nassigned); + if (isspace(c)) { + while ((fp->_r > 0 || __srefill(fp) == 0) && isspace(*fp->_p)) nread++, fp->_r--, fp->_p++; + continue; + } + if (c != '%') goto literal; + width = 0; + flags = 0; + /* + * switch on the format. continue if done; + * break once format type is derived. + */ + again: + c = *fmt++; + switch (c) { + case '%': + literal: + if (fp->_r <= 0 && __srefill(fp)) goto input_failure; + if (*fp->_p != c) goto match_failure; + fp->_r--, fp->_p++; + nread++; + continue; + + case '*': + flags |= SUPPRESS; + goto again; + case 'j': + flags |= MAXINT; + goto again; + case 'L': + flags |= LONGDBL; + goto again; + case 'h': + if (*fmt == 'h') { + fmt++; + flags |= SHORTSHORT; + } else { + flags |= SHORT; + } + goto again; + case 'l': + if (*fmt == 'l') { + fmt++; + flags |= LLONG; + } else { + flags |= LONG; + } + goto again; + case 'q': + flags |= LLONG; /* deprecated */ + goto again; + case 't': + flags |= PTRINT; + goto again; + case 'z': + flags |= SIZEINT; + goto again; + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + width = width * 10 + c - '0'; + goto again; + + /* + * Conversions. + * Those marked `compat' are for 4.[123]BSD compatibility. + * + * (According to ANSI, E and X formats are supposed + * to the same as e and x. Sorry about that.) + */ + case 'D': /* compat */ + flags |= LONG; + /* FALLTHROUGH */ + case 'd': + c = CT_INT; + base = 10; + break; + + case 'i': + c = CT_INT; + base = 0; + break; + + case 'O': /* compat */ + flags |= LONG; + /* FALLTHROUGH */ + case 'o': + c = CT_INT; + flags |= UNSIGNED; + base = 8; + break; + + case 'u': + c = CT_INT; + flags |= UNSIGNED; + base = 10; + break; + + case 'X': + case 'x': + flags |= PFXOK; /* enable 0x prefixing */ + c = CT_INT; + flags |= UNSIGNED; + base = 16; + break; + + case 'e': + case 'E': + case 'f': + case 'F': + case 'g': + case 'G': + case 'a': + case 'A': + c = CT_FLOAT; + break; + + case 's': + c = CT_STRING; + break; + + case '[': + fmt = __sccl(ccltab, fmt); + flags |= NOSKIP; + c = CT_CCL; + break; + + case 'c': + flags |= NOSKIP; + c = CT_CHAR; + break; + + case 'p': /* pointer format is like hex */ + flags |= POINTER | PFXOK; + c = CT_INT; + flags |= UNSIGNED; + base = 16; + break; + + case 'n': + if (flags & SUPPRESS) continue; + if (flags & SHORTSHORT) + *va_arg(ap, signed char*) = nread; + else if (flags & SHORT) + *va_arg(ap, short*) = nread; + else if (flags & LONG) + *va_arg(ap, long*) = nread; + else if (flags & SIZEINT) + *va_arg(ap, ssize_t*) = nread; + else if (flags & PTRINT) + *va_arg(ap, ptrdiff_t*) = nread; + else if (flags & LLONG) + *va_arg(ap, long long*) = nread; + else if (flags & MAXINT) + *va_arg(ap, intmax_t*) = nread; + else + *va_arg(ap, int*) = nread; + continue; + + /* + * Disgusting backwards compatibility hacks. XXX + */ + case '\0': /* compat */ + return (EOF); + + default: /* compat */ + if (isupper(c)) flags |= LONG; + c = CT_INT; + base = 10; + break; + } + + /* + * We have a conversion that requires input. + */ + if (fp->_r <= 0 && __srefill(fp)) goto input_failure; + + /* + * Consume leading white space, except for formats + * that suppress this. + */ + if ((flags & NOSKIP) == 0) { + while (isspace(*fp->_p)) { + nread++; + if (--fp->_r > 0) + fp->_p++; + else if (__srefill(fp)) + goto input_failure; + } + /* + * Note that there is at least one character in + * the buffer, so conversions that do not set NOSKIP + * ca no longer result in an input failure. + */ + } + + /* + * Do the conversion. + */ + switch (c) { + case CT_CHAR: + /* scan arbitrary characters (sets NOSKIP) */ + if (width == 0) width = 1; + if (flags & LONG) { + if ((flags & SUPPRESS) == 0) + wcp = va_arg(ap, wchar_t*); + else + wcp = NULL; + n = 0; + while (width != 0) { + if (n == (int)MB_CUR_MAX) { + fp->_flags |= __SERR; + goto input_failure; + } + buf[n++] = *fp->_p; + fp->_p++; + fp->_r--; + memset(&mbs, 0, sizeof(mbs)); + nconv = mbrtowc(wcp, buf, n, &mbs); + if (nconv == (size_t)-1) { + fp->_flags |= __SERR; + goto input_failure; + } + if (nconv == 0 && !(flags & SUPPRESS)) *wcp = L'\0'; + if (nconv != (size_t)-2) { + nread += n; + width--; + if (!(flags & SUPPRESS)) wcp++; + n = 0; + } + if (fp->_r <= 0 && __srefill(fp)) { + if (n != 0) { + fp->_flags |= __SERR; + goto input_failure; + } + break; + } + } + if (!(flags & SUPPRESS)) nassigned++; + } else if (flags & SUPPRESS) { + size_t sum = 0; + for (;;) { + if ((n = fp->_r) < (int)width) { + sum += n; + width -= n; + fp->_p += n; + if (__srefill(fp)) { + if (sum == 0) goto input_failure; + break; + } + } else { + sum += width; + fp->_r -= width; + fp->_p += width; + break; + } + } + nread += sum; + } else { + size_t r = fread((void*)va_arg(ap, char*), 1, width, fp); + + if (r == 0) goto input_failure; + nread += r; + nassigned++; + } + break; + + case CT_CCL: + /* scan a (nonempty) character class (sets NOSKIP) */ + if (width == 0) width = (size_t)~0; /* `infinity' */ + /* take only those things in the class */ + if (flags & LONG) { + wchar_t twc; + int nchars; + + if ((flags & SUPPRESS) == 0) + wcp = va_arg(ap, wchar_t*); + else + wcp = &twc; + n = 0; + nchars = 0; + while (width != 0) { + if (n == (int)MB_CUR_MAX) { + fp->_flags |= __SERR; + goto input_failure; + } + buf[n++] = *fp->_p; + fp->_p++; + fp->_r--; + memset(&mbs, 0, sizeof(mbs)); + nconv = mbrtowc(wcp, buf, n, &mbs); + if (nconv == (size_t)-1) { + fp->_flags |= __SERR; + goto input_failure; + } + if (nconv == 0) *wcp = L'\0'; + if (nconv != (size_t)-2) { + if (wctob(*wcp) != EOF && !ccltab[wctob(*wcp)]) { + while (n != 0) { + n--; + ungetc(buf[n], fp); + } + break; + } + nread += n; + width--; + if (!(flags & SUPPRESS)) wcp++; + nchars++; + n = 0; + } + if (fp->_r <= 0 && __srefill(fp)) { + if (n != 0) { + fp->_flags |= __SERR; + goto input_failure; + } + break; + } + } + if (n != 0) { + fp->_flags |= __SERR; + goto input_failure; + } + n = nchars; + if (n == 0) goto match_failure; + if (!(flags & SUPPRESS)) { + *wcp = L'\0'; + nassigned++; + } + } else + /* take only those things in the class */ + if (flags & SUPPRESS) { + n = 0; + while (ccltab[*fp->_p]) { + n++, fp->_r--, fp->_p++; + if (--width == 0) break; + if (fp->_r <= 0 && __srefill(fp)) { + if (n == 0) goto input_failure; + break; + } + } + if (n == 0) goto match_failure; + } else { + p0 = p = va_arg(ap, char*); + while (ccltab[*fp->_p]) { + fp->_r--; + *p++ = *fp->_p++; + if (--width == 0) break; + if (fp->_r <= 0 && __srefill(fp)) { + if (p == p0) goto input_failure; + break; + } + } + n = p - p0; + if (n == 0) goto match_failure; + *p = '\0'; + nassigned++; + } + nread += n; + break; + + case CT_STRING: + /* like CCL, but zero-length string OK, & no NOSKIP */ + if (width == 0) width = (size_t)~0; + if (flags & LONG) { + wchar_t twc; + + if ((flags & SUPPRESS) == 0) + wcp = va_arg(ap, wchar_t*); + else + wcp = &twc; + n = 0; + while (!isspace(*fp->_p) && width != 0) { + if (n == (int)MB_CUR_MAX) { + fp->_flags |= __SERR; + goto input_failure; + } + buf[n++] = *fp->_p; + fp->_p++; + fp->_r--; + memset(&mbs, 0, sizeof(mbs)); + nconv = mbrtowc(wcp, buf, n, &mbs); + if (nconv == (size_t)-1) { + fp->_flags |= __SERR; + goto input_failure; + } + if (nconv == 0) *wcp = L'\0'; + if (nconv != (size_t)-2) { + if (iswspace(*wcp)) { + while (n != 0) { + n--; + ungetc(buf[n], fp); + } + break; + } + nread += n; + width--; + if (!(flags & SUPPRESS)) wcp++; + n = 0; + } + if (fp->_r <= 0 && __srefill(fp)) { + if (n != 0) { + fp->_flags |= __SERR; + goto input_failure; + } + break; + } + } + if (!(flags & SUPPRESS)) { + *wcp = L'\0'; + nassigned++; + } + } else if (flags & SUPPRESS) { + n = 0; + while (!isspace(*fp->_p)) { + n++, fp->_r--, fp->_p++; + if (--width == 0) break; + if (fp->_r <= 0 && __srefill(fp)) break; + } + nread += n; + } else { + p0 = p = va_arg(ap, char*); + while (!isspace(*fp->_p)) { + fp->_r--; + *p++ = *fp->_p++; + if (--width == 0) break; + if (fp->_r <= 0 && __srefill(fp)) break; + } + *p = '\0'; + nread += p - p0; + nassigned++; + } + continue; + + case CT_INT: + /* scan an integer as if by strtoimax/strtoumax */ #ifdef hardway - if (width == 0 || width > sizeof(buf) - 1) - width = sizeof(buf) - 1; + if (width == 0 || width > sizeof(buf) - 1) width = sizeof(buf) - 1; #else - /* size_t is unsigned, hence this optimisation */ - if (--width > sizeof(buf) - 2) - width = sizeof(buf) - 2; - width++; + /* size_t is unsigned, hence this optimisation */ + if (--width > sizeof(buf) - 2) width = sizeof(buf) - 2; + width++; #endif - flags |= SIGNOK | NDIGITS | NZDIGITS; - for (p = buf; width; width--) { - c = *fp->_p; - /* - * Switch on the character; `goto ok' - * if we accept it as a part of number. - */ - switch (c) { - - /* - * The digit 0 is always legal, but is - * special. For %i conversions, if no - * digits (zero or nonzero) have been - * scanned (only signs), we will have - * base==0. In that case, we should set - * it to 8 and enable 0x prefixing. - * Also, if we have not scanned zero digits - * before this, do not turn off prefixing - * (someone else will turn it off if we - * have scanned any nonzero digits). - */ - case '0': - if (base == 0) { - base = 8; - flags |= PFXOK; - } - if (flags & NZDIGITS) - flags &= ~(SIGNOK|NZDIGITS|NDIGITS); - else - flags &= ~(SIGNOK|PFXOK|NDIGITS); - goto ok; - - /* 1 through 7 always legal */ - case '1': case '2': case '3': - case '4': case '5': case '6': case '7': - base = basefix[base]; - flags &= ~(SIGNOK | PFXOK | NDIGITS); - goto ok; - - /* digits 8 and 9 ok iff decimal or hex */ - case '8': case '9': - base = basefix[base]; - if (base <= 8) - break; /* not legal here */ - flags &= ~(SIGNOK | PFXOK | NDIGITS); - goto ok; - - /* letters ok iff hex */ - case 'A': case 'B': case 'C': - case 'D': case 'E': case 'F': - case 'a': case 'b': case 'c': - case 'd': case 'e': case 'f': - /* no need to fix base here */ - if (base <= 10) - break; /* not legal here */ - flags &= ~(SIGNOK | PFXOK | NDIGITS); - goto ok; - - /* sign ok only as first character */ - case '+': case '-': - if (flags & SIGNOK) { - flags &= ~SIGNOK; - flags |= HAVESIGN; - goto ok; - } - break; - - /* - * x ok iff flag still set and 2nd char (or - * 3rd char if we have a sign). - */ - case 'x': case 'X': - if ((flags & PFXOK) && p == - buf + 1 + !!(flags & HAVESIGN)) { - base = 16; /* if %i */ - flags &= ~PFXOK; - goto ok; - } - break; - } - - /* - * If we got here, c is not a legal character - * for a number. Stop accumulating digits. - */ - break; - ok: - /* - * c is legal: store it and look at the next. - */ - *p++ = c; - if (--fp->_r > 0) - fp->_p++; - else if (__srefill(fp)) - break; /* EOF */ - } - /* - * If we had only a sign, it is no good; push - * back the sign. If the number ends in `x', - * it was [sign] '0' 'x', so push back the x - * and treat it as [sign] '0'. - */ - if (flags & NDIGITS) { - if (p > buf) - (void) ungetc(*(u_char *)--p, fp); - goto match_failure; - } - c = ((u_char *)p)[-1]; - if (c == 'x' || c == 'X') { - --p; - (void) ungetc(c, fp); - } - if ((flags & SUPPRESS) == 0) { - uintmax_t res; - - *p = '\0'; - if (flags & UNSIGNED) - res = strtoumax(buf, NULL, base); - else - res = strtoimax(buf, NULL, base); - if (flags & POINTER) - *va_arg(ap, void **) = - (void *)(uintptr_t)res; - else if (flags & MAXINT) - *va_arg(ap, intmax_t *) = res; - else if (flags & LLONG) - *va_arg(ap, long long *) = res; - else if (flags & SIZEINT) - *va_arg(ap, ssize_t *) = res; - else if (flags & PTRINT) - *va_arg(ap, ptrdiff_t *) = res; - else if (flags & LONG) - *va_arg(ap, long *) = res; - else if (flags & SHORT) - *va_arg(ap, short *) = res; - else if (flags & SHORTSHORT) - *va_arg(ap, signed char *) = res; - else - *va_arg(ap, int *) = res; - nassigned++; - } - nread += p - buf; - break; - - case CT_FLOAT: - /* scan a floating point number as if by strtod */ - if (width == 0 || width > sizeof(buf) - 1) - width = sizeof(buf) - 1; - if ((width = parsefloat(fp, buf, buf + width)) == 0) - goto match_failure; - if ((flags & SUPPRESS) == 0) { - if (flags & LONGDBL) { - long double res = strtold(buf, &p); - *va_arg(ap, long double *) = res; - } else if (flags & LONG) { - double res = strtod(buf, &p); - *va_arg(ap, double *) = res; - } else { - float res = strtof(buf, &p); - *va_arg(ap, float *) = res; - } - if ((size_t)(p - buf) != width) abort(); - nassigned++; - } - nread += width; - break; - } - } + flags |= SIGNOK | NDIGITS | NZDIGITS; + for (p = buf; width; width--) { + c = *fp->_p; + /* + * Switch on the character; `goto ok' + * if we accept it as a part of number. + */ + switch (c) { + /* + * The digit 0 is always legal, but is + * special. For %i conversions, if no + * digits (zero or nonzero) have been + * scanned (only signs), we will have + * base==0. In that case, we should set + * it to 8 and enable 0x prefixing. + * Also, if we have not scanned zero digits + * before this, do not turn off prefixing + * (someone else will turn it off if we + * have scanned any nonzero digits). + */ + case '0': + if (base == 0) { + base = 8; + flags |= PFXOK; + } + if (flags & NZDIGITS) + flags &= ~(SIGNOK | NZDIGITS | NDIGITS); + else + flags &= ~(SIGNOK | PFXOK | NDIGITS); + goto ok; + + /* 1 through 7 always legal */ + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + base = basefix[base]; + flags &= ~(SIGNOK | PFXOK | NDIGITS); + goto ok; + + /* digits 8 and 9 ok iff decimal or hex */ + case '8': + case '9': + base = basefix[base]; + if (base <= 8) break; /* not legal here */ + flags &= ~(SIGNOK | PFXOK | NDIGITS); + goto ok; + + /* letters ok iff hex */ + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + /* no need to fix base here */ + if (base <= 10) break; /* not legal here */ + flags &= ~(SIGNOK | PFXOK | NDIGITS); + goto ok; + + /* sign ok only as first character */ + case '+': + case '-': + if (flags & SIGNOK) { + flags &= ~SIGNOK; + flags |= HAVESIGN; + goto ok; + } + break; + + /* + * x ok iff flag still set and 2nd char (or + * 3rd char if we have a sign). + */ + case 'x': + case 'X': + if ((flags & PFXOK) && p == buf + 1 + !!(flags & HAVESIGN)) { + base = 16; /* if %i */ + flags &= ~PFXOK; + goto ok; + } + break; + } + + /* + * If we got here, c is not a legal character + * for a number. Stop accumulating digits. + */ + break; + ok: + /* + * c is legal: store it and look at the next. + */ + *p++ = c; + if (--fp->_r > 0) + fp->_p++; + else if (__srefill(fp)) + break; /* EOF */ + } + /* + * If we had only a sign, it is no good; push + * back the sign. If the number ends in `x', + * it was [sign] '0' 'x', so push back the x + * and treat it as [sign] '0'. + */ + if (flags & NDIGITS) { + if (p > buf) (void)ungetc(*(u_char*)--p, fp); + goto match_failure; + } + c = ((u_char*)p)[-1]; + if (c == 'x' || c == 'X') { + --p; + (void)ungetc(c, fp); + } + if ((flags & SUPPRESS) == 0) { + uintmax_t res; + + *p = '\0'; + if (flags & UNSIGNED) + res = strtoumax(buf, NULL, base); + else + res = strtoimax(buf, NULL, base); + if (flags & POINTER) + *va_arg(ap, void**) = (void*)(uintptr_t)res; + else if (flags & MAXINT) + *va_arg(ap, intmax_t*) = res; + else if (flags & LLONG) + *va_arg(ap, long long*) = res; + else if (flags & SIZEINT) + *va_arg(ap, ssize_t*) = res; + else if (flags & PTRINT) + *va_arg(ap, ptrdiff_t*) = res; + else if (flags & LONG) + *va_arg(ap, long*) = res; + else if (flags & SHORT) + *va_arg(ap, short*) = res; + else if (flags & SHORTSHORT) + *va_arg(ap, signed char*) = res; + else + *va_arg(ap, int*) = res; + nassigned++; + } + nread += p - buf; + break; + + case CT_FLOAT: + /* scan a floating point number as if by strtod */ + if (width == 0 || width > sizeof(buf) - 1) width = sizeof(buf) - 1; + if ((width = parsefloat(fp, buf, buf + width)) == 0) goto match_failure; + if ((flags & SUPPRESS) == 0) { + if (flags & LONGDBL) { + long double res = strtold(buf, &p); + *va_arg(ap, long double*) = res; + } else if (flags & LONG) { + double res = strtod(buf, &p); + *va_arg(ap, double*) = res; + } else { + float res = strtof(buf, &p); + *va_arg(ap, float*) = res; + } + if ((size_t)(p - buf) != width) abort(); + nassigned++; + } + nread += width; + break; + } + } input_failure: - if (nassigned == 0) - nassigned = -1; + if (nassigned == 0) nassigned = -1; match_failure: - return (nassigned); + return (nassigned); } /* @@ -780,103 +758,94 @@ match_failure: * closing `]'. The table has a 1 wherever characters should be * considered part of the scanset. */ -static u_char * -__sccl(char *tab, u_char *fmt) -{ - int c, n, v; - - /* first `clear' the whole table */ - c = *fmt++; /* first char hat => negated scanset */ - if (c == '^') { - v = 1; /* default => accept */ - c = *fmt++; /* get new first char */ - } else - v = 0; /* default => reject */ - /* should probably use memset here */ - for (n = 0; n < 256; n++) - tab[n] = v; - if (c == 0) - return (fmt - 1);/* format ended before closing ] */ - - /* - * Now set the entries corresponding to the actual scanset - * to the opposite of the above. - * - * The first character may be ']' (or '-') without being special; - * the last character may be '-'. - */ - v = 1 - v; - for (;;) { - tab[c] = v; /* take character c */ -doswitch: - n = *fmt++; /* and examine the next */ - switch (n) { - - case 0: /* format ended too soon */ - return (fmt - 1); - - case '-': - /* - * A scanset of the form - * [01+-] - * is defined as `the digit 0, the digit 1, - * the character +, the character -', but - * the effect of a scanset such as - * [a-zA-Z0-9] - * is implementation defined. The V7 Unix - * scanf treats `a-z' as `the letters a through - * z', but treats `a-a' as `the letter a, the - * character -, and the letter a'. - * - * For compatibility, the `-' is not considerd - * to define a range if the character following - * it is either a close bracket (required by ANSI) - * or is not numerically greater than the character - * we just stored in the table (c). - */ - n = *fmt; - if (n == ']' || n < c) { - c = '-'; - break; /* resume the for(;;) */ - } - fmt++; - do { /* fill in the range */ - tab[++c] = v; - } while (c < n); -#if 1 /* XXX another disgusting compatibility hack */ - /* - * Alas, the V7 Unix scanf also treats formats - * such as [a-c-e] as `the letters a through e'. - * This too is permitted by the standard.... - */ - goto doswitch; +static u_char* __sccl(char* tab, u_char* fmt) { + int c, n, v; + + /* first `clear' the whole table */ + c = *fmt++; /* first char hat => negated scanset */ + if (c == '^') { + v = 1; /* default => accept */ + c = *fmt++; /* get new first char */ + } else + v = 0; /* default => reject */ + /* should probably use memset here */ + for (n = 0; n < 256; n++) tab[n] = v; + if (c == 0) return (fmt - 1); /* format ended before closing ] */ + + /* + * Now set the entries corresponding to the actual scanset + * to the opposite of the above. + * + * The first character may be ']' (or '-') without being special; + * the last character may be '-'. + */ + v = 1 - v; + for (;;) { + tab[c] = v; /* take character c */ + doswitch: + n = *fmt++; /* and examine the next */ + switch (n) { + case 0: /* format ended too soon */ + return (fmt - 1); + + case '-': + /* + * A scanset of the form + * [01+-] + * is defined as `the digit 0, the digit 1, + * the character +, the character -', but + * the effect of a scanset such as + * [a-zA-Z0-9] + * is implementation defined. The V7 Unix + * scanf treats `a-z' as `the letters a through + * z', but treats `a-a' as `the letter a, the + * character -, and the letter a'. + * + * For compatibility, the `-' is not considerd + * to define a range if the character following + * it is either a close bracket (required by ANSI) + * or is not numerically greater than the character + * we just stored in the table (c). + */ + n = *fmt; + if (n == ']' || n < c) { + c = '-'; + break; /* resume the for(;;) */ + } + fmt++; + do { /* fill in the range */ + tab[++c] = v; + } while (c < n); +#if 1 /* XXX another disgusting compatibility hack */ + /* + * Alas, the V7 Unix scanf also treats formats + * such as [a-c-e] as `the letters a through e'. + * This too is permitted by the standard.... + */ + goto doswitch; #else - c = *fmt++; - if (c == 0) - return (fmt - 1); - if (c == ']') - return (fmt); + c = *fmt++; + if (c == 0) return (fmt - 1); + if (c == ']') return (fmt); #endif - break; + break; - case ']': /* end of scanset */ - return (fmt); + case ']': /* end of scanset */ + return (fmt); - default: /* just another character */ - c = n; - break; - } - } - /* NOTREACHED */ + default: /* just another character */ + c = n; + break; + } + } + /* NOTREACHED */ } -int -vfscanf(FILE *fp, const char *fmt0, __va_list ap) -{ - int r; +int vfscanf(FILE* fp, const char* fmt0, __va_list ap) { + int r; - FLOCKFILE(fp); - r = __svfscanf(fp, fmt0, ap); - FUNLOCKFILE(fp); - return (r); + FLOCKFILE(fp); + r = __svfscanf(fp, fmt0, ap); + FUNLOCKFILE(fp); + return (r); } diff --git a/libc/stdio/vfwprintf.c b/libc/stdio/vfwprintf.c index e0ad84feb6..647b59af1f 100644 --- a/libc/stdio/vfwprintf.c +++ b/libc/stdio/vfwprintf.c @@ -37,118 +37,112 @@ * This code is large and complicated... */ -#include <sys/types.h> #include <sys/mman.h> +#include <sys/types.h> #include <errno.h> #include <langinfo.h> #include <limits.h> #include <stdarg.h> #include <stddef.h> -#include <stdio.h> #include <stdint.h> +#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> +#include <wchar.h> -#include "local.h" #include "fvwrite.h" +#include "local.h" union arg { - int intarg; - unsigned int uintarg; - long longarg; - unsigned long ulongarg; - long long longlongarg; - unsigned long long ulonglongarg; - ptrdiff_t ptrdiffarg; - size_t sizearg; - ssize_t ssizearg; - intmax_t intmaxarg; - uintmax_t uintmaxarg; - void *pvoidarg; - char *pchararg; - signed char *pschararg; - short *pshortarg; - int *pintarg; - long *plongarg; - long long *plonglongarg; - ptrdiff_t *pptrdiffarg; - ssize_t *pssizearg; - intmax_t *pintmaxarg; - double doublearg; - long double longdoublearg; - wint_t wintarg; - wchar_t *pwchararg; + int intarg; + unsigned int uintarg; + long longarg; + unsigned long ulongarg; + long long longlongarg; + unsigned long long ulonglongarg; + ptrdiff_t ptrdiffarg; + size_t sizearg; + ssize_t ssizearg; + intmax_t intmaxarg; + uintmax_t uintmaxarg; + void* pvoidarg; + char* pchararg; + signed char* pschararg; + short* pshortarg; + int* pintarg; + long* plongarg; + long long* plonglongarg; + ptrdiff_t* pptrdiffarg; + ssize_t* pssizearg; + intmax_t* pintmaxarg; + double doublearg; + long double longdoublearg; + wint_t wintarg; + wchar_t* pwchararg; }; -static int __find_arguments(const wchar_t *fmt0, va_list ap, union arg **argtable, - size_t *argtablesiz); -static int __grow_type_table(unsigned char **typetable, int *tablesize); +static int __find_arguments(const wchar_t* fmt0, va_list ap, union arg** argtable, + size_t* argtablesiz); +static int __grow_type_table(unsigned char** typetable, int* tablesize); /* * Helper function for `fprintf to unbuffered unix file': creates a * temporary buffer. We only work on write-only files; this avoids * worries about ungetc buffers and so forth. */ -static int -__sbprintf(FILE *fp, const wchar_t *fmt, va_list ap) -{ - int ret; - FILE fake; - struct __sfileext fakeext; - unsigned char buf[BUFSIZ]; - - _FILEEXT_SETUP(&fake, &fakeext); - /* copy the important variables */ - fake._flags = fp->_flags & ~__SNBF; - fake._file = fp->_file; - fake._cookie = fp->_cookie; - fake._write = fp->_write; - - /* set up the buffer */ - fake._bf._base = fake._p = buf; - fake._bf._size = fake._w = sizeof(buf); - fake._lbfsize = 0; /* not actually used, but Just In Case */ - - /* do the work, then copy any error status */ - ret = __vfwprintf(&fake, fmt, ap); - if (ret >= 0 && __sflush(&fake)) - ret = EOF; - if (fake._flags & __SERR) - fp->_flags |= __SERR; - return (ret); +static int __sbprintf(FILE* fp, const wchar_t* fmt, va_list ap) { + int ret; + FILE fake; + struct __sfileext fakeext; + unsigned char buf[BUFSIZ]; + + _FILEEXT_SETUP(&fake, &fakeext); + /* copy the important variables */ + fake._flags = fp->_flags & ~__SNBF; + fake._file = fp->_file; + fake._cookie = fp->_cookie; + fake._write = fp->_write; + + /* set up the buffer */ + fake._bf._base = fake._p = buf; + fake._bf._size = fake._w = sizeof(buf); + fake._lbfsize = 0; /* not actually used, but Just In Case */ + + /* do the work, then copy any error status */ + ret = __vfwprintf(&fake, fmt, ap); + if (ret >= 0 && __sflush(&fake)) ret = EOF; + if (fake._flags & __SERR) fp->_flags |= __SERR; + return (ret); } /* * Like __fputwc_unlock, but handles fake string (__SSTR) files properly. * File must already be locked. */ -static wint_t -__xfputwc(wchar_t wc, FILE *fp) -{ - mbstate_t mbs; - char buf[MB_LEN_MAX]; - struct __suio uio; - struct __siov iov; - size_t len; - - if ((fp->_flags & __SSTR) == 0) - return (__fputwc_unlock(wc, fp)); - - bzero(&mbs, sizeof(mbs)); - len = wcrtomb(buf, wc, &mbs); - if (len == (size_t)-1) { - fp->_flags |= __SERR; - errno = EILSEQ; - return (WEOF); - } - uio.uio_iov = &iov; - uio.uio_resid = len; - uio.uio_iovcnt = 1; - iov.iov_base = buf; - iov.iov_len = len; - return (__sfvwrite(fp, &uio) != EOF ? (wint_t)wc : WEOF); +static wint_t __xfputwc(wchar_t wc, FILE* fp) { + mbstate_t mbs; + char buf[MB_LEN_MAX]; + struct __suio uio; + struct __siov iov; + size_t len; + + if ((fp->_flags & __SSTR) == 0) return (__fputwc_unlock(wc, fp)); + + bzero(&mbs, sizeof(mbs)); + len = wcrtomb(buf, wc, &mbs); + if (len == (size_t)-1) { + fp->_flags |= __SERR; + errno = EILSEQ; + return (WEOF); + } + uio.uio_iov = &iov; + uio.uio_resid = len; + uio.uio_iovcnt = 1; + iov.iov_base = buf; + iov.iov_len = len; + return (__sfvwrite(fp, &uio) != EOF ? (wint_t)wc : WEOF); } /* @@ -156,74 +150,66 @@ __xfputwc(wchar_t wc, FILE *fp) * string representation. ``prec'' specifies the maximum number of bytes * to output. If ``prec'' is greater than or equal to zero, we can't assume * that the multibyte character string ends in a null character. - * + * * Returns NULL on failure. * To find out what happened check errno for ENOMEM, EILSEQ and EINVAL. */ -static wchar_t * -__mbsconv(char *mbsarg, int prec) -{ - mbstate_t mbs; - wchar_t *convbuf, *wcp; - const char *p; - size_t insize, nchars, nconv; - - if (mbsarg == NULL) - return (NULL); - - /* - * Supplied argument is a multibyte string; convert it to wide - * characters first. - */ - if (prec >= 0) { - /* - * String is not guaranteed to be NUL-terminated. Find the - * number of characters to print. - */ - p = mbsarg; - insize = nchars = nconv = 0; - bzero(&mbs, sizeof(mbs)); - while (nchars != (size_t)prec) { - nconv = mbrlen(p, MB_CUR_MAX, &mbs); - if (nconv == (size_t)0 || nconv == (size_t)-1 || - nconv == (size_t)-2) - break; - p += nconv; - nchars++; - insize += nconv; - } - if (nconv == (size_t)-1 || nconv == (size_t)-2) - return (NULL); - } else - insize = strlen(mbsarg); - - /* - * Allocate buffer for the result and perform the conversion, - * converting at most `size' bytes of the input multibyte string to - * wide characters for printing. - */ - convbuf = calloc(insize + 1, sizeof(*convbuf)); - if (convbuf == NULL) - return (NULL); - wcp = convbuf; - p = mbsarg; - bzero(&mbs, sizeof(mbs)); - nconv = 0; - while (insize != 0) { - nconv = mbrtowc(wcp, p, insize, &mbs); - if (nconv == 0 || nconv == (size_t)-1 || nconv == (size_t)-2) - break; - wcp++; - p += nconv; - insize -= nconv; - } - if (nconv == (size_t)-1 || nconv == (size_t)-2) { - free(convbuf); - return (NULL); - } - *wcp = '\0'; - - return (convbuf); +static wchar_t* __mbsconv(char* mbsarg, int prec) { + mbstate_t mbs; + wchar_t *convbuf, *wcp; + const char* p; + size_t insize, nchars, nconv; + + if (mbsarg == NULL) return (NULL); + + /* + * Supplied argument is a multibyte string; convert it to wide + * characters first. + */ + if (prec >= 0) { + /* + * String is not guaranteed to be NUL-terminated. Find the + * number of characters to print. + */ + p = mbsarg; + insize = nchars = nconv = 0; + bzero(&mbs, sizeof(mbs)); + while (nchars != (size_t)prec) { + nconv = mbrlen(p, MB_CUR_MAX, &mbs); + if (nconv == (size_t)0 || nconv == (size_t)-1 || nconv == (size_t)-2) break; + p += nconv; + nchars++; + insize += nconv; + } + if (nconv == (size_t)-1 || nconv == (size_t)-2) return (NULL); + } else + insize = strlen(mbsarg); + + /* + * Allocate buffer for the result and perform the conversion, + * converting at most `size' bytes of the input multibyte string to + * wide characters for printing. + */ + convbuf = calloc(insize + 1, sizeof(*convbuf)); + if (convbuf == NULL) return (NULL); + wcp = convbuf; + p = mbsarg; + bzero(&mbs, sizeof(mbs)); + nconv = 0; + while (insize != 0) { + nconv = mbrtowc(wcp, p, insize, &mbs); + if (nconv == 0 || nconv == (size_t)-1 || nconv == (size_t)-2) break; + wcp++; + p += nconv; + insize -= nconv; + } + if (nconv == (size_t)-1 || nconv == (size_t)-2) { + free(convbuf); + return (NULL); + } + *wcp = '\0'; + + return (convbuf); } #include <float.h> @@ -232,9 +218,9 @@ __mbsconv(char *mbsarg, int prec) #include "floatio.h" #include "gdtoa.h" -#define DEFPREC 6 +#define DEFPREC 6 -static int exponent(wchar_t *, int, int); +static int exponent(wchar_t*, int, int); /* * The size of the buffer we use as scratch space for integer @@ -243,842 +229,805 @@ static int exponent(wchar_t *, int, int); * characters between each pair of digits. 100 bytes is a * conservative overestimate even for a 128-bit uintmax_t. */ -#define BUF 100 - -#define STATIC_ARG_TBL_SIZE 8 /* Size of static argument table. */ +#define BUF 100 +#define STATIC_ARG_TBL_SIZE 8 /* Size of static argument table. */ /* * Macros for converting digits to letters and vice versa */ -#define to_digit(c) ((c) - '0') -#define is_digit(c) ((unsigned)to_digit(c) <= 9) -#define to_char(n) ((wchar_t)((n) + '0')) +#define to_digit(c) ((c) - '0') +#define is_digit(c) ((unsigned)to_digit(c) <= 9) +#define to_char(n) ((wchar_t)((n) + '0')) /* * Flags used during conversion. */ -#define ALT 0x0001 /* alternate form */ -#define LADJUST 0x0004 /* left adjustment */ -#define LONGDBL 0x0008 /* long double */ -#define LONGINT 0x0010 /* long integer */ -#define LLONGINT 0x0020 /* long long integer */ -#define SHORTINT 0x0040 /* short integer */ -#define ZEROPAD 0x0080 /* zero (as opposed to blank) pad */ -#define FPT 0x0100 /* Floating point number */ -#define PTRINT 0x0200 /* (unsigned) ptrdiff_t */ -#define SIZEINT 0x0400 /* (signed) size_t */ -#define CHARINT 0x0800 /* 8 bit integer */ -#define MAXINT 0x1000 /* largest integer size (intmax_t) */ - -int -__vfwprintf(FILE * __restrict fp, const wchar_t * __restrict fmt0, __va_list ap) -{ - wchar_t *fmt; /* format string */ - wchar_t ch; /* character from fmt */ - int n, n2, n3; /* handy integers (short term usage) */ - wchar_t *cp; /* handy char pointer (short term usage) */ - int flags; /* flags as above */ - int ret; /* return value accumulator */ - int width; /* width from format (%8d), or 0 */ - int prec; /* precision from format; <0 for N/A */ - wchar_t sign; /* sign prefix (' ', '+', '-', or \0) */ - /* - * We can decompose the printed representation of floating - * point numbers into several parts, some of which may be empty: - * - * [+|-| ] [0x|0X] MMM . NNN [e|E|p|P] [+|-] ZZ - * A B ---C--- D E F - * - * A: 'sign' holds this value if present; '\0' otherwise - * B: ox[1] holds the 'x' or 'X'; '\0' if not hexadecimal - * C: cp points to the string MMMNNN. Leading and trailing - * zeros are not in the string and must be added. - * D: expchar holds this character; '\0' if no exponent, e.g. %f - * F: at least two digits for decimal, at least one digit for hex - */ - char *decimal_point = NULL; - int signflag; /* true if float is negative */ - union { /* floating point arguments %[aAeEfFgG] */ - double dbl; - long double ldbl; - } fparg; - int expt; /* integer value of exponent */ - char expchar; /* exponent character: [eEpP\0] */ - char *dtoaend; /* pointer to end of converted digits */ - int expsize; /* character count for expstr */ - int lead; /* sig figs before decimal or group sep */ - int ndig; /* actual number of digits returned by dtoa */ - wchar_t expstr[MAXEXPDIG+2]; /* buffer for exponent string: e+ZZZ */ - char *dtoaresult = NULL; - - uintmax_t _umax; /* integer arguments %[diouxX] */ - enum { OCT, DEC, HEX } base; /* base for %[diouxX] conversion */ - int dprec; /* a copy of prec if %[diouxX], 0 otherwise */ - int realsz; /* field size expanded by dprec */ - int size; /* size of converted field or string */ - const char *xdigs; /* digits for %[xX] conversion */ - wchar_t buf[BUF]; /* buffer with space for digits of uintmax_t */ - wchar_t ox[2]; /* space for 0x; ox[1] is either x, X, or \0 */ - union arg *argtable; /* args, built due to positional arg */ - union arg statargtable[STATIC_ARG_TBL_SIZE]; - size_t argtablesiz; - int nextarg; /* 1-based argument index */ - va_list orgap; /* original argument pointer */ - wchar_t *convbuf; /* buffer for multibyte to wide conversion */ - - /* - * Choose PADSIZE to trade efficiency vs. size. If larger printf - * fields occur frequently, increase PADSIZE and make the initialisers - * below longer. - */ -#define PADSIZE 16 /* pad chunk size */ - static wchar_t blanks[PADSIZE] = - {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '}; - static wchar_t zeroes[PADSIZE] = - {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'}; - - static const char xdigs_lower[16] = "0123456789abcdef"; - static const char xdigs_upper[16] = "0123456789ABCDEF"; - - /* - * BEWARE, these `goto error' on error, PRINT uses 'n3', - * PAD uses `n' and 'n3', and PRINTANDPAD uses 'n', 'n2', and 'n3'. - */ -#define PRINT(ptr, len) do { \ - for (n3 = 0; n3 < (len); n3++) { \ - if ((__xfputwc((ptr)[n3], fp)) == WEOF) \ - goto error; \ - } \ -} while (0) -#define PAD(howmany, with) do { \ - if ((n = (howmany)) > 0) { \ - while (n > PADSIZE) { \ - PRINT(with, PADSIZE); \ - n -= PADSIZE; \ - } \ - PRINT(with, n); \ - } \ -} while (0) -#define PRINTANDPAD(p, ep, len, with) do { \ - n2 = (ep) - (p); \ - if (n2 > (len)) \ - n2 = (len); \ - if (n2 > 0) \ - PRINT((p), n2); \ - PAD((len) - (n2 > 0 ? n2 : 0), (with)); \ -} while(0) - - /* - * To extend shorts properly, we need both signed and unsigned - * argument extraction methods. - */ -#define SARG() \ - ((intmax_t)(flags&MAXINT ? GETARG(intmax_t) : \ - flags&LLONGINT ? GETARG(long long) : \ - flags&LONGINT ? GETARG(long) : \ - flags&PTRINT ? GETARG(ptrdiff_t) : \ - flags&SIZEINT ? GETARG(ssize_t) : \ - flags&SHORTINT ? (short)GETARG(int) : \ - flags&CHARINT ? (signed char)GETARG(int) : \ - GETARG(int))) -#define UARG() \ - ((uintmax_t)(flags&MAXINT ? GETARG(uintmax_t) : \ - flags&LLONGINT ? GETARG(unsigned long long) : \ - flags&LONGINT ? GETARG(unsigned long) : \ - flags&PTRINT ? (uintptr_t)GETARG(ptrdiff_t) : /* XXX */ \ - flags&SIZEINT ? GETARG(size_t) : \ - flags&SHORTINT ? (unsigned short)GETARG(int) : \ - flags&CHARINT ? (unsigned char)GETARG(int) : \ - GETARG(unsigned int))) - - /* - * Append a digit to a value and check for overflow. - */ -#define APPEND_DIGIT(val, dig) do { \ - if ((val) > INT_MAX / 10) \ - goto overflow; \ - (val) *= 10; \ - if ((val) > INT_MAX - to_digit((dig))) \ - goto overflow; \ - (val) += to_digit((dig)); \ -} while (0) - - /* - * Get * arguments, including the form *nn$. Preserve the nextarg - * that the argument can be gotten once the type is determined. - */ -#define GETASTER(val) \ - n2 = 0; \ - cp = fmt; \ - while (is_digit(*cp)) { \ - APPEND_DIGIT(n2, *cp); \ - cp++; \ - } \ - if (*cp == '$') { \ - int hold = nextarg; \ - if (argtable == NULL) { \ - argtable = statargtable; \ - __find_arguments(fmt0, orgap, &argtable, &argtablesiz); \ - } \ - nextarg = n2; \ - val = GETARG(int); \ - nextarg = hold; \ - fmt = ++cp; \ - } else { \ - val = GETARG(int); \ - } +#define ALT 0x0001 /* alternate form */ +#define LADJUST 0x0004 /* left adjustment */ +#define LONGDBL 0x0008 /* long double */ +#define LONGINT 0x0010 /* long integer */ +#define LLONGINT 0x0020 /* long long integer */ +#define SHORTINT 0x0040 /* short integer */ +#define ZEROPAD 0x0080 /* zero (as opposed to blank) pad */ +#define FPT 0x0100 /* Floating point number */ +#define PTRINT 0x0200 /* (unsigned) ptrdiff_t */ +#define SIZEINT 0x0400 /* (signed) size_t */ +#define CHARINT 0x0800 /* 8 bit integer */ +#define MAXINT 0x1000 /* largest integer size (intmax_t) */ + +int __vfwprintf(FILE* __restrict fp, const wchar_t* __restrict fmt0, __va_list ap) { + wchar_t* fmt; /* format string */ + wchar_t ch; /* character from fmt */ + int n, n2, n3; /* handy integers (short term usage) */ + wchar_t* cp; /* handy char pointer (short term usage) */ + int flags; /* flags as above */ + int ret; /* return value accumulator */ + int width; /* width from format (%8d), or 0 */ + int prec; /* precision from format; <0 for N/A */ + wchar_t sign; /* sign prefix (' ', '+', '-', or \0) */ + /* + * We can decompose the printed representation of floating + * point numbers into several parts, some of which may be empty: + * + * [+|-| ] [0x|0X] MMM . NNN [e|E|p|P] [+|-] ZZ + * A B ---C--- D E F + * + * A: 'sign' holds this value if present; '\0' otherwise + * B: ox[1] holds the 'x' or 'X'; '\0' if not hexadecimal + * C: cp points to the string MMMNNN. Leading and trailing + * zeros are not in the string and must be added. + * D: expchar holds this character; '\0' if no exponent, e.g. %f + * F: at least two digits for decimal, at least one digit for hex + */ + char* decimal_point = NULL; + int signflag; /* true if float is negative */ + union { /* floating point arguments %[aAeEfFgG] */ + double dbl; + long double ldbl; + } fparg; + int expt; /* integer value of exponent */ + char expchar; /* exponent character: [eEpP\0] */ + char* dtoaend; /* pointer to end of converted digits */ + int expsize; /* character count for expstr */ + int lead; /* sig figs before decimal or group sep */ + int ndig; /* actual number of digits returned by dtoa */ + wchar_t expstr[MAXEXPDIG + 2]; /* buffer for exponent string: e+ZZZ */ + char* dtoaresult = NULL; + + uintmax_t _umax; /* integer arguments %[diouxX] */ + enum { OCT, DEC, HEX } base; /* base for %[diouxX] conversion */ + int dprec; /* a copy of prec if %[diouxX], 0 otherwise */ + int realsz; /* field size expanded by dprec */ + int size; /* size of converted field or string */ + const char* xdigs; /* digits for %[xX] conversion */ + wchar_t buf[BUF]; /* buffer with space for digits of uintmax_t */ + wchar_t ox[2]; /* space for 0x; ox[1] is either x, X, or \0 */ + union arg* argtable; /* args, built due to positional arg */ + union arg statargtable[STATIC_ARG_TBL_SIZE]; + size_t argtablesiz; + int nextarg; /* 1-based argument index */ + va_list orgap; /* original argument pointer */ + wchar_t* convbuf; /* buffer for multibyte to wide conversion */ + + /* + * Choose PADSIZE to trade efficiency vs. size. If larger printf + * fields occur frequently, increase PADSIZE and make the initialisers + * below longer. + */ +#define PADSIZE 16 /* pad chunk size */ + static wchar_t blanks[PADSIZE] = { ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' }; + static wchar_t zeroes[PADSIZE] = { '0', '0', '0', '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', '0', '0', '0' }; + + static const char xdigs_lower[16] = "0123456789abcdef"; + static const char xdigs_upper[16] = "0123456789ABCDEF"; + + /* + * BEWARE, these `goto error' on error, PRINT uses 'n3', + * PAD uses `n' and 'n3', and PRINTANDPAD uses 'n', 'n2', and 'n3'. + */ +#define PRINT(ptr, len) \ + do { \ + for (n3 = 0; n3 < (len); n3++) { \ + if ((__xfputwc((ptr)[n3], fp)) == WEOF) goto error; \ + } \ + } while (0) +#define PAD(howmany, with) \ + do { \ + if ((n = (howmany)) > 0) { \ + while (n > PADSIZE) { \ + PRINT(with, PADSIZE); \ + n -= PADSIZE; \ + } \ + PRINT(with, n); \ + } \ + } while (0) +#define PRINTANDPAD(p, ep, len, with) \ + do { \ + n2 = (ep) - (p); \ + if (n2 > (len)) n2 = (len); \ + if (n2 > 0) PRINT((p), n2); \ + PAD((len) - (n2 > 0 ? n2 : 0), (with)); \ + } while (0) + + /* + * To extend shorts properly, we need both signed and unsigned + * argument extraction methods. + */ +#define SARG() \ + ((intmax_t)(flags & MAXINT \ + ? GETARG(intmax_t) \ + : flags & LLONGINT \ + ? GETARG(long long) \ + : flags & LONGINT \ + ? GETARG(long) \ + : flags & PTRINT \ + ? GETARG(ptrdiff_t) \ + : flags & SIZEINT \ + ? GETARG(ssize_t) \ + : flags & SHORTINT \ + ? (short)GETARG(int) \ + : flags & CHARINT ? (signed char)GETARG(int) \ + : GETARG(int))) +#define UARG() \ + ((uintmax_t)(flags & MAXINT \ + ? GETARG(uintmax_t) \ + : flags & LLONGINT \ + ? GETARG(unsigned long long) \ + : flags & LONGINT \ + ? GETARG(unsigned long) \ + : flags & PTRINT ? (uintptr_t)GETARG(ptrdiff_t) : /* XXX */ \ + flags & SIZEINT \ + ? GETARG(size_t) \ + : flags & SHORTINT \ + ? (unsigned short)GETARG(int) \ + : flags & CHARINT ? (unsigned char)GETARG(int) \ + : GETARG(unsigned int))) + + /* + * Append a digit to a value and check for overflow. + */ +#define APPEND_DIGIT(val, dig) \ + do { \ + if ((val) > INT_MAX / 10) goto overflow; \ + (val) *= 10; \ + if ((val) > INT_MAX - to_digit((dig))) goto overflow; \ + (val) += to_digit((dig)); \ + } while (0) + + /* + * Get * arguments, including the form *nn$. Preserve the nextarg + * that the argument can be gotten once the type is determined. + */ +#define GETASTER(val) \ + n2 = 0; \ + cp = fmt; \ + while (is_digit(*cp)) { \ + APPEND_DIGIT(n2, *cp); \ + cp++; \ + } \ + if (*cp == '$') { \ + int hold = nextarg; \ + if (argtable == NULL) { \ + argtable = statargtable; \ + __find_arguments(fmt0, orgap, &argtable, &argtablesiz); \ + } \ + nextarg = n2; \ + val = GETARG(int); \ + nextarg = hold; \ + fmt = ++cp; \ + } else { \ + val = GETARG(int); \ + } /* -* Get the argument indexed by nextarg. If the argument table is -* built, use it to get the argument. If its not, get the next -* argument (and arguments must be gotten sequentially). -*/ + * Get the argument indexed by nextarg. If the argument table is + * built, use it to get the argument. If its not, get the next + * argument (and arguments must be gotten sequentially). + */ #define GETARG(type) \ - ((argtable != NULL) ? *((type*)(&argtable[nextarg++])) : \ - (nextarg++, va_arg(ap, type))) - - _SET_ORIENTATION(fp, 1); - /* sorry, fwprintf(read_only_file, "") returns EOF, not 0 */ - if (cantwrite(fp)) { - errno = EBADF; - return (EOF); - } - - /* optimise fwprintf(stderr) (and other unbuffered Unix files) */ - if ((fp->_flags & (__SNBF|__SWR|__SRW)) == (__SNBF|__SWR) && - fp->_file >= 0) - return (__sbprintf(fp, fmt0, ap)); - - fmt = (wchar_t *)fmt0; - argtable = NULL; - nextarg = 1; - va_copy(orgap, ap); - ret = 0; - convbuf = NULL; - - /* - * Scan the format for conversions (`%' character). - */ - for (;;) { - for (cp = fmt; (ch = *fmt) != '\0' && ch != '%'; fmt++) - continue; - if (fmt != cp) { - ptrdiff_t m = fmt - cp; - if (m < 0 || m > INT_MAX - ret) - goto overflow; - PRINT(cp, m); - ret += m; - } - if (ch == '\0') - goto done; - fmt++; /* skip over '%' */ - - flags = 0; - dprec = 0; - width = 0; - prec = -1; - sign = '\0'; - ox[1] = '\0'; - -rflag: ch = *fmt++; -reswitch: switch (ch) { - case ' ': - /* - * ``If the space and + flags both appear, the space - * flag will be ignored.'' - * -- ANSI X3J11 - */ - if (!sign) - sign = ' '; - goto rflag; - case '#': - flags |= ALT; - goto rflag; - case '\'': - /* grouping not implemented */ - goto rflag; - case '*': - /* - * ``A negative field width argument is taken as a - * - flag followed by a positive field width.'' - * -- ANSI X3J11 - * They don't exclude field widths read from args. - */ - GETASTER(width); - if (width >= 0) - goto rflag; - if (width == INT_MIN) - goto overflow; - width = -width; - /* FALLTHROUGH */ - case '-': - flags |= LADJUST; - goto rflag; - case '+': - sign = '+'; - goto rflag; - case '.': - if ((ch = *fmt++) == '*') { - GETASTER(n); - prec = n < 0 ? -1 : n; - goto rflag; - } - n = 0; - while (is_digit(ch)) { - APPEND_DIGIT(n, ch); - ch = *fmt++; - } - if (ch == '$') { - nextarg = n; - if (argtable == NULL) { - argtable = statargtable; - __find_arguments(fmt0, orgap, - &argtable, &argtablesiz); - } - goto rflag; - } - prec = n; - goto reswitch; - case '0': - /* - * ``Note that 0 is taken as a flag, not as the - * beginning of a field width.'' - * -- ANSI X3J11 - */ - flags |= ZEROPAD; - goto rflag; - case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - n = 0; - do { - APPEND_DIGIT(n, ch); - ch = *fmt++; - } while (is_digit(ch)); - if (ch == '$') { - nextarg = n; - if (argtable == NULL) { - argtable = statargtable; - __find_arguments(fmt0, orgap, - &argtable, &argtablesiz); - } - goto rflag; - } - width = n; - goto reswitch; - case 'L': - flags |= LONGDBL; - goto rflag; - case 'h': - if (*fmt == 'h') { - fmt++; - flags |= CHARINT; - } else { - flags |= SHORTINT; - } - goto rflag; - case 'j': - flags |= MAXINT; - goto rflag; - case 'l': - if (*fmt == 'l') { - fmt++; - flags |= LLONGINT; - } else { - flags |= LONGINT; - } - goto rflag; - case 'q': - flags |= LLONGINT; - goto rflag; - case 't': - flags |= PTRINT; - goto rflag; - case 'z': - flags |= SIZEINT; - goto rflag; - case 'C': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'c': - if (flags & LONGINT) - *(cp = buf) = (wchar_t)GETARG(wint_t); - else - *(cp = buf) = (wchar_t)btowc(GETARG(int)); - size = 1; - sign = '\0'; - break; - case 'D': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'd': - case 'i': - _umax = SARG(); - if ((intmax_t)_umax < 0) { - _umax = -_umax; - sign = '-'; - } - base = DEC; - goto number; - case 'a': - case 'A': - if (ch == 'a') { - ox[1] = 'x'; - xdigs = xdigs_lower; - expchar = 'p'; - } else { - ox[1] = 'X'; - xdigs = xdigs_upper; - expchar = 'P'; - } - if (prec >= 0) - prec++; - if (dtoaresult) - __freedtoa(dtoaresult); - if (flags & LONGDBL) { - fparg.ldbl = GETARG(long double); - dtoaresult = - __hldtoa(fparg.ldbl, xdigs, prec, - &expt, &signflag, &dtoaend); - if (dtoaresult == NULL) { - errno = ENOMEM; - goto error; - } - } else { - fparg.dbl = GETARG(double); - dtoaresult = - __hdtoa(fparg.dbl, xdigs, prec, - &expt, &signflag, &dtoaend); - if (dtoaresult == NULL) { - errno = ENOMEM; - goto error; - } - } - if (prec < 0) - prec = dtoaend - dtoaresult; - if (expt == INT_MAX) - ox[1] = '\0'; - free(convbuf); - cp = convbuf = __mbsconv(dtoaresult, -1); - if (cp == NULL) - goto error; - ndig = dtoaend - dtoaresult; - goto fp_common; - case 'e': - case 'E': - expchar = ch; - if (prec < 0) /* account for digit before decpt */ - prec = DEFPREC + 1; - else - prec++; - goto fp_begin; - case 'f': - case 'F': - expchar = '\0'; - goto fp_begin; - case 'g': - case 'G': - expchar = ch - ('g' - 'e'); - if (prec == 0) - prec = 1; -fp_begin: - if (prec < 0) - prec = DEFPREC; - if (dtoaresult) - __freedtoa(dtoaresult); - if (flags & LONGDBL) { - fparg.ldbl = GETARG(long double); - dtoaresult = - __ldtoa(&fparg.ldbl, expchar ? 2 : 3, prec, - &expt, &signflag, &dtoaend); - if (dtoaresult == NULL) { - errno = ENOMEM; - goto error; - } - } else { - fparg.dbl = GETARG(double); - dtoaresult = - __dtoa(fparg.dbl, expchar ? 2 : 3, prec, - &expt, &signflag, &dtoaend); - if (dtoaresult == NULL) { - errno = ENOMEM; - goto error; - } - if (expt == 9999) - expt = INT_MAX; - } - free(convbuf); - cp = convbuf = __mbsconv(dtoaresult, -1); - if (cp == NULL) - goto error; - ndig = dtoaend - dtoaresult; -fp_common: - if (signflag) - sign = '-'; - if (expt == INT_MAX) { /* inf or nan */ - if (*cp == 'N') - cp = (ch >= 'a') ? L"nan" : L"NAN"; - else - cp = (ch >= 'a') ? L"inf" : L"INF"; - size = 3; - flags &= ~ZEROPAD; - break; - } - flags |= FPT; - if (ch == 'g' || ch == 'G') { - if (expt > -4 && expt <= prec) { - /* Make %[gG] smell like %[fF] */ - expchar = '\0'; - if (flags & ALT) - prec -= expt; - else - prec = ndig - expt; - if (prec < 0) - prec = 0; - } else { - /* - * Make %[gG] smell like %[eE], but - * trim trailing zeroes if no # flag. - */ - if (!(flags & ALT)) - prec = ndig; - } - } - if (expchar) { - expsize = exponent(expstr, expt - 1, expchar); - size = expsize + prec; - if (prec > 1 || flags & ALT) - ++size; - } else { - /* space for digits before decimal point */ - if (expt > 0) - size = expt; - else /* "0" */ - size = 1; - /* space for decimal pt and following digits */ - if (prec || flags & ALT) - size += prec + 1; - lead = expt; - } - break; + ((argtable != NULL) ? *((type*)(&argtable[nextarg++])) : (nextarg++, va_arg(ap, type))) + + _SET_ORIENTATION(fp, 1); + /* sorry, fwprintf(read_only_file, "") returns EOF, not 0 */ + if (cantwrite(fp)) { + errno = EBADF; + return (EOF); + } + + /* optimise fwprintf(stderr) (and other unbuffered Unix files) */ + if ((fp->_flags & (__SNBF | __SWR | __SRW)) == (__SNBF | __SWR) && fp->_file >= 0) + return (__sbprintf(fp, fmt0, ap)); + + fmt = (wchar_t*)fmt0; + argtable = NULL; + nextarg = 1; + va_copy(orgap, ap); + ret = 0; + convbuf = NULL; + + /* + * Scan the format for conversions (`%' character). + */ + for (;;) { + for (cp = fmt; (ch = *fmt) != '\0' && ch != '%'; fmt++) continue; + if (fmt != cp) { + ptrdiff_t m = fmt - cp; + if (m < 0 || m > INT_MAX - ret) goto overflow; + PRINT(cp, m); + ret += m; + } + if (ch == '\0') goto done; + fmt++; /* skip over '%' */ + + flags = 0; + dprec = 0; + width = 0; + prec = -1; + sign = '\0'; + ox[1] = '\0'; + + rflag: + ch = *fmt++; + reswitch: + switch (ch) { + case ' ': + /* + * ``If the space and + flags both appear, the space + * flag will be ignored.'' + * -- ANSI X3J11 + */ + if (!sign) sign = ' '; + goto rflag; + case '#': + flags |= ALT; + goto rflag; + case '\'': + /* grouping not implemented */ + goto rflag; + case '*': + /* + * ``A negative field width argument is taken as a + * - flag followed by a positive field width.'' + * -- ANSI X3J11 + * They don't exclude field widths read from args. + */ + GETASTER(width); + if (width >= 0) goto rflag; + if (width == INT_MIN) goto overflow; + width = -width; + /* FALLTHROUGH */ + case '-': + flags |= LADJUST; + goto rflag; + case '+': + sign = '+'; + goto rflag; + case '.': + if ((ch = *fmt++) == '*') { + GETASTER(n); + prec = n < 0 ? -1 : n; + goto rflag; + } + n = 0; + while (is_digit(ch)) { + APPEND_DIGIT(n, ch); + ch = *fmt++; + } + if (ch == '$') { + nextarg = n; + if (argtable == NULL) { + argtable = statargtable; + __find_arguments(fmt0, orgap, &argtable, &argtablesiz); + } + goto rflag; + } + prec = n; + goto reswitch; + case '0': + /* + * ``Note that 0 is taken as a flag, not as the + * beginning of a field width.'' + * -- ANSI X3J11 + */ + flags |= ZEROPAD; + goto rflag; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + n = 0; + do { + APPEND_DIGIT(n, ch); + ch = *fmt++; + } while (is_digit(ch)); + if (ch == '$') { + nextarg = n; + if (argtable == NULL) { + argtable = statargtable; + __find_arguments(fmt0, orgap, &argtable, &argtablesiz); + } + goto rflag; + } + width = n; + goto reswitch; + case 'L': + flags |= LONGDBL; + goto rflag; + case 'h': + if (*fmt == 'h') { + fmt++; + flags |= CHARINT; + } else { + flags |= SHORTINT; + } + goto rflag; + case 'j': + flags |= MAXINT; + goto rflag; + case 'l': + if (*fmt == 'l') { + fmt++; + flags |= LLONGINT; + } else { + flags |= LONGINT; + } + goto rflag; + case 'q': + flags |= LLONGINT; + goto rflag; + case 't': + flags |= PTRINT; + goto rflag; + case 'z': + flags |= SIZEINT; + goto rflag; + case 'C': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'c': + if (flags & LONGINT) + *(cp = buf) = (wchar_t)GETARG(wint_t); + else + *(cp = buf) = (wchar_t)btowc(GETARG(int)); + size = 1; + sign = '\0'; + break; + case 'D': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'd': + case 'i': + _umax = SARG(); + if ((intmax_t)_umax < 0) { + _umax = -_umax; + sign = '-'; + } + base = DEC; + goto number; + case 'a': + case 'A': + if (ch == 'a') { + ox[1] = 'x'; + xdigs = xdigs_lower; + expchar = 'p'; + } else { + ox[1] = 'X'; + xdigs = xdigs_upper; + expchar = 'P'; + } + if (prec >= 0) prec++; + if (dtoaresult) __freedtoa(dtoaresult); + if (flags & LONGDBL) { + fparg.ldbl = GETARG(long double); + dtoaresult = __hldtoa(fparg.ldbl, xdigs, prec, &expt, &signflag, &dtoaend); + if (dtoaresult == NULL) { + errno = ENOMEM; + goto error; + } + } else { + fparg.dbl = GETARG(double); + dtoaresult = __hdtoa(fparg.dbl, xdigs, prec, &expt, &signflag, &dtoaend); + if (dtoaresult == NULL) { + errno = ENOMEM; + goto error; + } + } + if (prec < 0) prec = dtoaend - dtoaresult; + if (expt == INT_MAX) ox[1] = '\0'; + free(convbuf); + cp = convbuf = __mbsconv(dtoaresult, -1); + if (cp == NULL) goto error; + ndig = dtoaend - dtoaresult; + goto fp_common; + case 'e': + case 'E': + expchar = ch; + if (prec < 0) /* account for digit before decpt */ + prec = DEFPREC + 1; + else + prec++; + goto fp_begin; + case 'f': + case 'F': + expchar = '\0'; + goto fp_begin; + case 'g': + case 'G': + expchar = ch - ('g' - 'e'); + if (prec == 0) prec = 1; + fp_begin: + if (prec < 0) prec = DEFPREC; + if (dtoaresult) __freedtoa(dtoaresult); + if (flags & LONGDBL) { + fparg.ldbl = GETARG(long double); + dtoaresult = __ldtoa(&fparg.ldbl, expchar ? 2 : 3, prec, &expt, &signflag, &dtoaend); + if (dtoaresult == NULL) { + errno = ENOMEM; + goto error; + } + } else { + fparg.dbl = GETARG(double); + dtoaresult = __dtoa(fparg.dbl, expchar ? 2 : 3, prec, &expt, &signflag, &dtoaend); + if (dtoaresult == NULL) { + errno = ENOMEM; + goto error; + } + if (expt == 9999) expt = INT_MAX; + } + free(convbuf); + cp = convbuf = __mbsconv(dtoaresult, -1); + if (cp == NULL) goto error; + ndig = dtoaend - dtoaresult; + fp_common: + if (signflag) sign = '-'; + if (expt == INT_MAX) { /* inf or nan */ + if (*cp == 'N') + cp = (ch >= 'a') ? L"nan" : L"NAN"; + else + cp = (ch >= 'a') ? L"inf" : L"INF"; + size = 3; + flags &= ~ZEROPAD; + break; + } + flags |= FPT; + if (ch == 'g' || ch == 'G') { + if (expt > -4 && expt <= prec) { + /* Make %[gG] smell like %[fF] */ + expchar = '\0'; + if (flags & ALT) + prec -= expt; + else + prec = ndig - expt; + if (prec < 0) prec = 0; + } else { + /* + * Make %[gG] smell like %[eE], but + * trim trailing zeroes if no # flag. + */ + if (!(flags & ALT)) prec = ndig; + } + } + if (expchar) { + expsize = exponent(expstr, expt - 1, expchar); + size = expsize + prec; + if (prec > 1 || flags & ALT) ++size; + } else { + /* space for digits before decimal point */ + if (expt > 0) + size = expt; + else /* "0" */ + size = 1; + /* space for decimal pt and following digits */ + if (prec || flags & ALT) size += prec + 1; + lead = expt; + } + break; #ifndef NO_PRINTF_PERCENT_N - case 'n': - if (flags & LLONGINT) - *GETARG(long long *) = ret; - else if (flags & LONGINT) - *GETARG(long *) = ret; - else if (flags & SHORTINT) - *GETARG(short *) = ret; - else if (flags & CHARINT) - *GETARG(signed char *) = ret; - else if (flags & PTRINT) - *GETARG(ptrdiff_t *) = ret; - else if (flags & SIZEINT) - *GETARG(ssize_t *) = ret; - else if (flags & MAXINT) - *GETARG(intmax_t *) = ret; - else - *GETARG(int *) = ret; - continue; /* no output */ -#endif /* NO_PRINTF_PERCENT_N */ - case 'O': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'o': - _umax = UARG(); - base = OCT; - goto nosign; - 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 - */ - _umax = (u_long)GETARG(void *); - base = HEX; - xdigs = xdigs_lower; - ox[1] = 'x'; - goto nosign; - case 'S': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 's': - if (flags & LONGINT) { - if ((cp = GETARG(wchar_t *)) == NULL) - cp = L"(null)"; - } else { - char *mbsarg; - if ((mbsarg = GETARG(char *)) == NULL) - mbsarg = "(null)"; - free(convbuf); - convbuf = __mbsconv(mbsarg, prec); - if (convbuf == NULL) { - fp->_flags |= __SERR; - goto error; - } else - cp = convbuf; - } - if (prec >= 0) { - /* - * can't use wcslen; can only look for the - * NUL in the first `prec' characters, and - * wcslen() will go further. - */ - wchar_t *p = wmemchr(cp, 0, prec); - - size = p ? (p - cp) : prec; - } else { - size_t len; - - if ((len = wcslen(cp)) > INT_MAX) - goto overflow; - size = (int)len; - } - sign = '\0'; - break; - case 'U': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'u': - _umax = UARG(); - base = DEC; - goto nosign; - case 'X': - xdigs = xdigs_upper; - goto hex; - case 'x': - xdigs = xdigs_lower; -hex: _umax = UARG(); - base = HEX; - /* leading 0x/X only if non-zero */ - if (flags & ALT && _umax != 0) - ox[1] = ch; - - /* unsigned conversions */ -nosign: sign = '\0'; - /* - * ``... diouXx conversions ... if a precision is - * specified, the 0 flag will be ignored.'' - * -- ANSI X3J11 - */ -number: if ((dprec = prec) >= 0) - flags &= ~ZEROPAD; - - /* - * ``The result of converting a zero value with an - * explicit precision of zero is no characters.'' - * -- ANSI X3J11 - */ - cp = buf + BUF; - if (_umax != 0 || prec != 0) { - /* - * Unsigned mod is hard, and unsigned mod - * by a constant is easier than that by - * a variable; hence this switch. - */ - switch (base) { - case OCT: - do { - *--cp = to_char(_umax & 7); - _umax >>= 3; - } while (_umax); - /* handle octal leading 0 */ - if (flags & ALT && *cp != '0') - *--cp = '0'; - break; - - case DEC: - /* many numbers are 1 digit */ - while (_umax >= 10) { - *--cp = to_char(_umax % 10); - _umax /= 10; - } - *--cp = to_char(_umax); - break; - - case HEX: - do { - *--cp = xdigs[_umax & 15]; - _umax >>= 4; - } while (_umax); - break; - - default: - cp = L"bug in vfwprintf: bad base"; - size = wcslen(cp); - goto skipsize; - } - } - size = buf + BUF - cp; - if (size > BUF) /* should never happen */ - abort(); - skipsize: - break; - default: /* "%?" prints ?, unless ? is NUL */ - if (ch == '\0') - goto done; - /* pretend it was %c with argument ch */ - cp = buf; - *cp = ch; - size = 1; - sign = '\0'; - break; - } - - /* - * All reasonable formats wind up here. At this point, `cp' - * points to a string which (if not flags&LADJUST) should be - * padded out to `width' places. If flags&ZEROPAD, it should - * first be prefixed by any sign or other prefix; otherwise, - * it should be blank padded before the prefix is emitted. - * After any left-hand padding and prefixing, emit zeroes - * required by a decimal %[diouxX] precision, then print the - * string proper, then emit zeroes required by any leftover - * floating precision; finally, if LADJUST, pad with blanks. - * - * Compute actual size, so we know how much to pad. - * size excludes decimal prec; realsz includes it. - */ - realsz = dprec > size ? dprec : size; - if (sign) - realsz++; - if (ox[1]) - realsz+= 2; - - /* right-adjusting blank padding */ - if ((flags & (LADJUST|ZEROPAD)) == 0) - PAD(width - realsz, blanks); - - /* prefix */ - if (sign) - PRINT(&sign, 1); - if (ox[1]) { /* ox[1] is either x, X, or \0 */ - ox[0] = '0'; - PRINT(ox, 2); - } - - /* right-adjusting zero padding */ - if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD) - PAD(width - realsz, zeroes); - - /* leading zeroes from decimal precision */ - PAD(dprec - size, zeroes); - - /* the string or number proper */ - if ((flags & FPT) == 0) { - PRINT(cp, size); - } else { /* glue together f_p fragments */ - if (decimal_point == NULL) - decimal_point = nl_langinfo(RADIXCHAR); - if (!expchar) { /* %[fF] or sufficiently short %[gG] */ - if (expt <= 0) { - PRINT(zeroes, 1); - if (prec || flags & ALT) - PRINT(decimal_point, 1); - PAD(-expt, zeroes); - /* already handled initial 0's */ - prec += expt; - } else { - PRINTANDPAD(cp, convbuf + ndig, - lead, zeroes); - cp += lead; - if (prec || flags & ALT) - PRINT(decimal_point, 1); - } - PRINTANDPAD(cp, convbuf + ndig, prec, zeroes); - } else { /* %[eE] or sufficiently long %[gG] */ - if (prec > 1 || flags & ALT) { - buf[0] = *cp++; - buf[1] = *decimal_point; - PRINT(buf, 2); - PRINT(cp, ndig-1); - PAD(prec - ndig, zeroes); - } else { /* XeYYY */ - PRINT(cp, 1); - } - PRINT(expstr, expsize); - } - } - /* left-adjusting padding (always blank) */ - if (flags & LADJUST) - PAD(width - realsz, blanks); - - /* finally, adjust ret */ - if (width < realsz) - width = realsz; - if (width > INT_MAX - ret) - goto overflow; - ret += width; - } + case 'n': + if (flags & LLONGINT) + *GETARG(long long*) = ret; + else if (flags & LONGINT) + *GETARG(long*) = ret; + else if (flags & SHORTINT) + *GETARG(short*) = ret; + else if (flags & CHARINT) + *GETARG(signed char*) = ret; + else if (flags & PTRINT) + *GETARG(ptrdiff_t*) = ret; + else if (flags & SIZEINT) + *GETARG(ssize_t*) = ret; + else if (flags & MAXINT) + *GETARG(intmax_t*) = ret; + else + *GETARG(int*) = ret; + continue; /* no output */ +#endif /* NO_PRINTF_PERCENT_N */ + case 'O': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'o': + _umax = UARG(); + base = OCT; + goto nosign; + 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 + */ + _umax = (u_long)GETARG(void*); + base = HEX; + xdigs = xdigs_lower; + ox[1] = 'x'; + goto nosign; + case 'S': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 's': + if (flags & LONGINT) { + if ((cp = GETARG(wchar_t*)) == NULL) cp = L"(null)"; + } else { + char* mbsarg; + if ((mbsarg = GETARG(char*)) == NULL) mbsarg = "(null)"; + free(convbuf); + convbuf = __mbsconv(mbsarg, prec); + if (convbuf == NULL) { + fp->_flags |= __SERR; + goto error; + } else + cp = convbuf; + } + if (prec >= 0) { + /* + * can't use wcslen; can only look for the + * NUL in the first `prec' characters, and + * wcslen() will go further. + */ + wchar_t* p = wmemchr(cp, 0, prec); + + size = p ? (p - cp) : prec; + } else { + size_t len; + + if ((len = wcslen(cp)) > INT_MAX) goto overflow; + size = (int)len; + } + sign = '\0'; + break; + case 'U': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'u': + _umax = UARG(); + base = DEC; + goto nosign; + case 'X': + xdigs = xdigs_upper; + goto hex; + case 'x': + xdigs = xdigs_lower; + hex: + _umax = UARG(); + base = HEX; + /* leading 0x/X only if non-zero */ + if (flags & ALT && _umax != 0) ox[1] = ch; + + /* unsigned conversions */ + nosign: + sign = '\0'; + /* + * ``... diouXx conversions ... if a precision is + * specified, the 0 flag will be ignored.'' + * -- ANSI X3J11 + */ + number: + if ((dprec = prec) >= 0) flags &= ~ZEROPAD; + + /* + * ``The result of converting a zero value with an + * explicit precision of zero is no characters.'' + * -- ANSI X3J11 + */ + cp = buf + BUF; + if (_umax != 0 || prec != 0) { + /* + * Unsigned mod is hard, and unsigned mod + * by a constant is easier than that by + * a variable; hence this switch. + */ + switch (base) { + case OCT: + do { + *--cp = to_char(_umax & 7); + _umax >>= 3; + } while (_umax); + /* handle octal leading 0 */ + if (flags & ALT && *cp != '0') *--cp = '0'; + break; + + case DEC: + /* many numbers are 1 digit */ + while (_umax >= 10) { + *--cp = to_char(_umax % 10); + _umax /= 10; + } + *--cp = to_char(_umax); + break; + + case HEX: + do { + *--cp = xdigs[_umax & 15]; + _umax >>= 4; + } while (_umax); + break; + + default: + cp = L"bug in vfwprintf: bad base"; + size = wcslen(cp); + goto skipsize; + } + } + size = buf + BUF - cp; + if (size > BUF) /* should never happen */ + abort(); + skipsize: + break; + default: /* "%?" prints ?, unless ? is NUL */ + if (ch == '\0') goto done; + /* pretend it was %c with argument ch */ + cp = buf; + *cp = ch; + size = 1; + sign = '\0'; + break; + } + + /* + * All reasonable formats wind up here. At this point, `cp' + * points to a string which (if not flags&LADJUST) should be + * padded out to `width' places. If flags&ZEROPAD, it should + * first be prefixed by any sign or other prefix; otherwise, + * it should be blank padded before the prefix is emitted. + * After any left-hand padding and prefixing, emit zeroes + * required by a decimal %[diouxX] precision, then print the + * string proper, then emit zeroes required by any leftover + * floating precision; finally, if LADJUST, pad with blanks. + * + * Compute actual size, so we know how much to pad. + * size excludes decimal prec; realsz includes it. + */ + realsz = dprec > size ? dprec : size; + if (sign) realsz++; + if (ox[1]) realsz += 2; + + /* right-adjusting blank padding */ + if ((flags & (LADJUST | ZEROPAD)) == 0) PAD(width - realsz, blanks); + + /* prefix */ + if (sign) PRINT(&sign, 1); + if (ox[1]) { /* ox[1] is either x, X, or \0 */ + ox[0] = '0'; + PRINT(ox, 2); + } + + /* right-adjusting zero padding */ + if ((flags & (LADJUST | ZEROPAD)) == ZEROPAD) PAD(width - realsz, zeroes); + + /* leading zeroes from decimal precision */ + PAD(dprec - size, zeroes); + + /* the string or number proper */ + if ((flags & FPT) == 0) { + PRINT(cp, size); + } else { /* glue together f_p fragments */ + if (decimal_point == NULL) decimal_point = nl_langinfo(RADIXCHAR); + if (!expchar) { /* %[fF] or sufficiently short %[gG] */ + if (expt <= 0) { + PRINT(zeroes, 1); + if (prec || flags & ALT) PRINT(decimal_point, 1); + PAD(-expt, zeroes); + /* already handled initial 0's */ + prec += expt; + } else { + PRINTANDPAD(cp, convbuf + ndig, lead, zeroes); + cp += lead; + if (prec || flags & ALT) PRINT(decimal_point, 1); + } + PRINTANDPAD(cp, convbuf + ndig, prec, zeroes); + } else { /* %[eE] or sufficiently long %[gG] */ + if (prec > 1 || flags & ALT) { + buf[0] = *cp++; + buf[1] = *decimal_point; + PRINT(buf, 2); + PRINT(cp, ndig - 1); + PAD(prec - ndig, zeroes); + } else { /* XeYYY */ + PRINT(cp, 1); + } + PRINT(expstr, expsize); + } + } + /* left-adjusting padding (always blank) */ + if (flags & LADJUST) PAD(width - realsz, blanks); + + /* finally, adjust ret */ + if (width < realsz) width = realsz; + if (width > INT_MAX - ret) goto overflow; + ret += width; + } done: error: - va_end(orgap); - if (__sferror(fp)) - ret = -1; - goto finish; + va_end(orgap); + if (__sferror(fp)) ret = -1; + goto finish; overflow: - errno = ENOMEM; - ret = -1; + errno = ENOMEM; + ret = -1; finish: - free(convbuf); - if (dtoaresult) - __freedtoa(dtoaresult); - if (argtable != NULL && argtable != statargtable) { - munmap(argtable, argtablesiz); - argtable = NULL; - } - return (ret); + free(convbuf); + if (dtoaresult) __freedtoa(dtoaresult); + if (argtable != NULL && argtable != statargtable) { + munmap(argtable, argtablesiz); + argtable = NULL; + } + return (ret); } -int -vfwprintf(FILE * __restrict fp, const wchar_t * __restrict fmt0, __va_list ap) -{ - int r; +int vfwprintf(FILE* __restrict fp, const wchar_t* __restrict fmt0, __va_list ap) { + int r; - FLOCKFILE(fp); - r = __vfwprintf(fp, fmt0, ap); - FUNLOCKFILE(fp); + FLOCKFILE(fp); + r = __vfwprintf(fp, fmt0, ap); + FUNLOCKFILE(fp); - return (r); + return (r); } DEF_STRONG(vfwprintf); /* * 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_LLONG 10 -#define T_U_LLONG 11 -#define TP_LLONG 12 -#define T_DOUBLE 13 -#define T_LONG_DOUBLE 14 -#define TP_CHAR 15 -#define TP_VOID 16 -#define T_PTRINT 17 -#define TP_PTRINT 18 -#define T_SIZEINT 19 -#define T_SSIZEINT 20 -#define TP_SSIZEINT 21 -#define T_MAXINT 22 -#define T_MAXUINT 23 -#define TP_MAXINT 24 -#define T_CHAR 25 -#define T_U_CHAR 26 -#define T_WINT 27 -#define TP_WCHAR 28 +#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_LLONG 10 +#define T_U_LLONG 11 +#define TP_LLONG 12 +#define T_DOUBLE 13 +#define T_LONG_DOUBLE 14 +#define TP_CHAR 15 +#define TP_VOID 16 +#define T_PTRINT 17 +#define TP_PTRINT 18 +#define T_SIZEINT 19 +#define T_SSIZEINT 20 +#define TP_SSIZEINT 21 +#define T_MAXINT 22 +#define T_MAXUINT 23 +#define TP_MAXINT 24 +#define T_CHAR 25 +#define T_U_CHAR 26 +#define T_WINT 27 +#define TP_WCHAR 28 /* * Find all arguments when a positional parameter is encountered. Returns a @@ -1088,399 +1037,400 @@ DEF_STRONG(vfwprintf); * used since we are attempting to make snprintf thread safe, and alloca is * problematic since we have nested functions..) */ -static int -__find_arguments(const wchar_t *fmt0, va_list ap, union arg **argtable, - size_t *argtablesiz) -{ - wchar_t *fmt; /* format string */ - int ch; /* character from fmt */ - int n, n2; /* handy integer (short term usage) */ - wchar_t *cp; /* handy char pointer (short term usage) */ - int flags; /* flags as above */ - unsigned char *typetable; /* table of types */ - unsigned char 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 */ - int ret = 0; /* return value */ - - /* - * Add an argument type to the table, expanding if necessary. - */ -#define ADDTYPE(type) \ - ((nextarg >= tablesize) ? \ - __grow_type_table(&typetable, &tablesize) : 0, \ - (nextarg > tablemax) ? tablemax = nextarg : 0, \ - typetable[nextarg++] = type) - -#define ADDSARG() \ - ((flags&MAXINT) ? ADDTYPE(T_MAXINT) : \ - ((flags&PTRINT) ? ADDTYPE(T_PTRINT) : \ - ((flags&SIZEINT) ? ADDTYPE(T_SSIZEINT) : \ - ((flags&LLONGINT) ? ADDTYPE(T_LLONG) : \ - ((flags&LONGINT) ? ADDTYPE(T_LONG) : \ - ((flags&SHORTINT) ? ADDTYPE(T_SHORT) : \ - ((flags&CHARINT) ? ADDTYPE(T_CHAR) : ADDTYPE(T_INT)))))))) - -#define ADDUARG() \ - ((flags&MAXINT) ? ADDTYPE(T_MAXUINT) : \ - ((flags&PTRINT) ? ADDTYPE(T_PTRINT) : \ - ((flags&SIZEINT) ? ADDTYPE(T_SIZEINT) : \ - ((flags&LLONGINT) ? ADDTYPE(T_U_LLONG) : \ - ((flags&LONGINT) ? ADDTYPE(T_U_LONG) : \ - ((flags&SHORTINT) ? ADDTYPE(T_U_SHORT) : \ - ((flags&CHARINT) ? ADDTYPE(T_U_CHAR) : ADDTYPE(T_U_INT)))))))) - - /* - * Add * arguments to the type array. - */ -#define ADDASTER() \ - n2 = 0; \ - cp = fmt; \ - while (is_digit(*cp)) { \ - APPEND_DIGIT(n2, *cp); \ - cp++; \ - } \ - if (*cp == '$') { \ - int hold = nextarg; \ - nextarg = n2; \ - ADDTYPE(T_INT); \ - nextarg = hold; \ - fmt = ++cp; \ - } else { \ - ADDTYPE(T_INT); \ - } - fmt = (wchar_t *)fmt0; - typetable = stattypetable; - tablesize = STATIC_ARG_TBL_SIZE; - tablemax = 0; - nextarg = 1; - memset(typetable, T_UNUSED, STATIC_ARG_TBL_SIZE); - - /* - * Scan the format for conversions (`%' character). - */ - for (;;) { - for (cp = fmt; (ch = *fmt) != '\0' && ch != '%'; fmt++) - continue; - if (ch == '\0') - goto done; - fmt++; /* skip over '%' */ - - flags = 0; - -rflag: ch = *fmt++; -reswitch: switch (ch) { - case ' ': - case '#': - case '\'': - goto rflag; - case '*': - ADDASTER(); - goto rflag; - case '-': - case '+': - goto rflag; - case '.': - if ((ch = *fmt++) == '*') { - ADDASTER(); - goto rflag; - } - while (is_digit(ch)) { - ch = *fmt++; - } - goto reswitch; - case '0': - goto rflag; - case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - n = 0; - do { - APPEND_DIGIT(n ,ch); - ch = *fmt++; - } while (is_digit(ch)); - if (ch == '$') { - nextarg = n; - goto rflag; - } - goto reswitch; - case 'L': - flags |= LONGDBL; - goto rflag; - case 'h': - if (*fmt == 'h') { - fmt++; - flags |= CHARINT; - } else { - flags |= SHORTINT; - } - goto rflag; - case 'l': - if (*fmt == 'l') { - fmt++; - flags |= LLONGINT; - } else { - flags |= LONGINT; - } - goto rflag; - case 'q': - flags |= LLONGINT; - goto rflag; - case 't': - flags |= PTRINT; - goto rflag; - case 'z': - flags |= SIZEINT; - goto rflag; - case 'C': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'c': - if (flags & LONGINT) - ADDTYPE(T_WINT); - else - ADDTYPE(T_INT); - break; - case 'D': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'd': - case 'i': - ADDSARG(); - break; - case 'a': - case 'A': - case 'e': - case 'E': - case 'f': - case 'F': - case 'g': - case 'G': - if (flags & LONGDBL) - ADDTYPE(T_LONG_DOUBLE); - else - ADDTYPE(T_DOUBLE); - break; +static int __find_arguments(const wchar_t* fmt0, va_list ap, union arg** argtable, + size_t* argtablesiz) { + wchar_t* fmt; /* format string */ + int ch; /* character from fmt */ + int n, n2; /* handy integer (short term usage) */ + wchar_t* cp; /* handy char pointer (short term usage) */ + int flags; /* flags as above */ + unsigned char* typetable; /* table of types */ + unsigned char 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 */ + int ret = 0; /* return value */ + + /* + * Add an argument type to the table, expanding if necessary. + */ +#define ADDTYPE(type) \ + ((nextarg >= tablesize) ? __grow_type_table(&typetable, &tablesize) : 0, \ + (nextarg > tablemax) ? tablemax = nextarg : 0, typetable[nextarg++] = type) + +#define ADDSARG() \ + ((flags & MAXINT) \ + ? ADDTYPE(T_MAXINT) \ + : ((flags & PTRINT) ? ADDTYPE(T_PTRINT) \ + : ((flags & SIZEINT) \ + ? ADDTYPE(T_SSIZEINT) \ + : ((flags & LLONGINT) \ + ? ADDTYPE(T_LLONG) \ + : ((flags & LONGINT) \ + ? ADDTYPE(T_LONG) \ + : ((flags & SHORTINT) \ + ? ADDTYPE(T_SHORT) \ + : ((flags & CHARINT) ? ADDTYPE(T_CHAR) \ + : ADDTYPE(T_INT)))))))) + +#define ADDUARG() \ + ((flags & MAXINT) \ + ? ADDTYPE(T_MAXUINT) \ + : ((flags & PTRINT) \ + ? ADDTYPE(T_PTRINT) \ + : ((flags & SIZEINT) \ + ? ADDTYPE(T_SIZEINT) \ + : ((flags & LLONGINT) \ + ? ADDTYPE(T_U_LLONG) \ + : ((flags & LONGINT) \ + ? ADDTYPE(T_U_LONG) \ + : ((flags & SHORTINT) \ + ? ADDTYPE(T_U_SHORT) \ + : ((flags & CHARINT) ? ADDTYPE(T_U_CHAR) \ + : ADDTYPE(T_U_INT)))))))) + + /* + * Add * arguments to the type array. + */ +#define ADDASTER() \ + n2 = 0; \ + cp = fmt; \ + while (is_digit(*cp)) { \ + APPEND_DIGIT(n2, *cp); \ + cp++; \ + } \ + if (*cp == '$') { \ + int hold = nextarg; \ + nextarg = n2; \ + ADDTYPE(T_INT); \ + nextarg = hold; \ + fmt = ++cp; \ + } else { \ + ADDTYPE(T_INT); \ + } + fmt = (wchar_t*)fmt0; + typetable = stattypetable; + tablesize = STATIC_ARG_TBL_SIZE; + tablemax = 0; + nextarg = 1; + memset(typetable, T_UNUSED, STATIC_ARG_TBL_SIZE); + + /* + * Scan the format for conversions (`%' character). + */ + for (;;) { + for (cp = fmt; (ch = *fmt) != '\0' && ch != '%'; fmt++) continue; + if (ch == '\0') goto done; + fmt++; /* skip over '%' */ + + flags = 0; + + rflag: + ch = *fmt++; + reswitch: + switch (ch) { + case ' ': + case '#': + case '\'': + goto rflag; + case '*': + ADDASTER(); + goto rflag; + case '-': + case '+': + goto rflag; + case '.': + if ((ch = *fmt++) == '*') { + ADDASTER(); + goto rflag; + } + while (is_digit(ch)) { + ch = *fmt++; + } + goto reswitch; + case '0': + goto rflag; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + n = 0; + do { + APPEND_DIGIT(n, ch); + ch = *fmt++; + } while (is_digit(ch)); + if (ch == '$') { + nextarg = n; + goto rflag; + } + goto reswitch; + case 'L': + flags |= LONGDBL; + goto rflag; + case 'h': + if (*fmt == 'h') { + fmt++; + flags |= CHARINT; + } else { + flags |= SHORTINT; + } + goto rflag; + case 'l': + if (*fmt == 'l') { + fmt++; + flags |= LLONGINT; + } else { + flags |= LONGINT; + } + goto rflag; + case 'q': + flags |= LLONGINT; + goto rflag; + case 't': + flags |= PTRINT; + goto rflag; + case 'z': + flags |= SIZEINT; + goto rflag; + case 'C': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'c': + if (flags & LONGINT) + ADDTYPE(T_WINT); + else + ADDTYPE(T_INT); + break; + case 'D': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'd': + case 'i': + ADDSARG(); + break; + case 'a': + case 'A': + case 'e': + case 'E': + case 'f': + case 'F': + case 'g': + case 'G': + if (flags & LONGDBL) + ADDTYPE(T_LONG_DOUBLE); + else + ADDTYPE(T_DOUBLE); + break; #ifndef NO_PRINTF_PERCENT_N - case 'n': - if (flags & LLONGINT) - ADDTYPE(TP_LLONG); - else if (flags & LONGINT) - ADDTYPE(TP_LONG); - else if (flags & SHORTINT) - ADDTYPE(TP_SHORT); - else if (flags & PTRINT) - ADDTYPE(TP_PTRINT); - else if (flags & SIZEINT) - ADDTYPE(TP_SSIZEINT); - else if (flags & MAXINT) - ADDTYPE(TP_MAXINT); - else - ADDTYPE(TP_INT); - continue; /* no output */ -#endif /* NO_PRINTF_PERCENT_N */ - case 'O': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'o': - ADDUARG(); - break; - case 'p': - ADDTYPE(TP_VOID); - break; - case 'S': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 's': - if (flags & LONGINT) - ADDTYPE(TP_CHAR); - else - ADDTYPE(TP_WCHAR); - break; - case 'U': - flags |= LONGINT; - /*FALLTHROUGH*/ - case 'u': - case 'X': - case 'x': - ADDUARG(); - break; - default: /* "%?" prints ?, unless ? is NUL */ - if (ch == '\0') - goto done; - break; - } - } + case 'n': + if (flags & LLONGINT) + ADDTYPE(TP_LLONG); + else if (flags & LONGINT) + ADDTYPE(TP_LONG); + else if (flags & SHORTINT) + ADDTYPE(TP_SHORT); + else if (flags & PTRINT) + ADDTYPE(TP_PTRINT); + else if (flags & SIZEINT) + ADDTYPE(TP_SSIZEINT); + else if (flags & MAXINT) + ADDTYPE(TP_MAXINT); + else + ADDTYPE(TP_INT); + continue; /* no output */ +#endif /* NO_PRINTF_PERCENT_N */ + case 'O': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'o': + ADDUARG(); + break; + case 'p': + ADDTYPE(TP_VOID); + break; + case 'S': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 's': + if (flags & LONGINT) + ADDTYPE(TP_CHAR); + else + ADDTYPE(TP_WCHAR); + break; + case 'U': + flags |= LONGINT; + /*FALLTHROUGH*/ + case 'u': + case 'X': + case 'x': + ADDUARG(); + break; + default: /* "%?" prints ?, unless ? is NUL */ + if (ch == '\0') goto done; + break; + } + } done: - /* - * Build the argument table. - */ - if (tablemax >= STATIC_ARG_TBL_SIZE) { - *argtablesiz = sizeof(union arg) * (tablemax + 1); - *argtable = mmap(NULL, *argtablesiz, - PROT_WRITE|PROT_READ, MAP_ANON|MAP_PRIVATE, -1, 0); - if (*argtable == MAP_FAILED) - return (-1); - } + /* + * Build the argument table. + */ + if (tablemax >= STATIC_ARG_TBL_SIZE) { + *argtablesiz = sizeof(union arg) * (tablemax + 1); + *argtable = mmap(NULL, *argtablesiz, PROT_WRITE | PROT_READ, MAP_ANON | MAP_PRIVATE, -1, 0); + if (*argtable == MAP_FAILED) return (-1); + } #if 0 /* XXX is this required? */ (*argtable)[0].intarg = 0; #endif - for (n = 1; n <= tablemax; n++) { - switch (typetable[n]) { - case T_UNUSED: - case T_CHAR: - case T_U_CHAR: - case T_SHORT: - case T_U_SHORT: - case T_INT: - (*argtable)[n].intarg = va_arg(ap, int); - break; - case TP_SHORT: - (*argtable)[n].pshortarg = va_arg(ap, short *); - break; - case T_U_INT: - (*argtable)[n].uintarg = va_arg(ap, unsigned int); - break; - case TP_INT: - (*argtable)[n].pintarg = va_arg(ap, int *); - break; - case T_LONG: - (*argtable)[n].longarg = va_arg(ap, long); - break; - case T_U_LONG: - (*argtable)[n].ulongarg = va_arg(ap, unsigned long); - break; - case TP_LONG: - (*argtable)[n].plongarg = va_arg(ap, long *); - break; - 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_DOUBLE: - (*argtable)[n].doublearg = va_arg(ap, double); - break; - case T_LONG_DOUBLE: - (*argtable)[n].longdoublearg = va_arg(ap, long double); - break; - case TP_CHAR: - (*argtable)[n].pchararg = va_arg(ap, char *); - break; - case TP_VOID: - (*argtable)[n].pvoidarg = va_arg(ap, void *); - break; - case T_PTRINT: - (*argtable)[n].ptrdiffarg = va_arg(ap, ptrdiff_t); - break; - case TP_PTRINT: - (*argtable)[n].pptrdiffarg = va_arg(ap, ptrdiff_t *); - break; - case T_SIZEINT: - (*argtable)[n].sizearg = va_arg(ap, size_t); - break; - case T_SSIZEINT: - (*argtable)[n].ssizearg = va_arg(ap, ssize_t); - break; - case TP_SSIZEINT: - (*argtable)[n].pssizearg = va_arg(ap, ssize_t *); - break; - case TP_MAXINT: - (*argtable)[n].intmaxarg = va_arg(ap, intmax_t); - break; - case T_WINT: - (*argtable)[n].wintarg = va_arg(ap, wint_t); - break; - case TP_WCHAR: - (*argtable)[n].pwchararg = va_arg(ap, wchar_t *); - break; - } - } - goto finish; + for (n = 1; n <= tablemax; n++) { + switch (typetable[n]) { + case T_UNUSED: + case T_CHAR: + case T_U_CHAR: + case T_SHORT: + case T_U_SHORT: + case T_INT: + (*argtable)[n].intarg = va_arg(ap, int); + break; + case TP_SHORT: + (*argtable)[n].pshortarg = va_arg(ap, short*); + break; + case T_U_INT: + (*argtable)[n].uintarg = va_arg(ap, unsigned int); + break; + case TP_INT: + (*argtable)[n].pintarg = va_arg(ap, int*); + break; + case T_LONG: + (*argtable)[n].longarg = va_arg(ap, long); + break; + case T_U_LONG: + (*argtable)[n].ulongarg = va_arg(ap, unsigned long); + break; + case TP_LONG: + (*argtable)[n].plongarg = va_arg(ap, long*); + break; + 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_DOUBLE: + (*argtable)[n].doublearg = va_arg(ap, double); + break; + case T_LONG_DOUBLE: + (*argtable)[n].longdoublearg = va_arg(ap, long double); + break; + case TP_CHAR: + (*argtable)[n].pchararg = va_arg(ap, char*); + break; + case TP_VOID: + (*argtable)[n].pvoidarg = va_arg(ap, void*); + break; + case T_PTRINT: + (*argtable)[n].ptrdiffarg = va_arg(ap, ptrdiff_t); + break; + case TP_PTRINT: + (*argtable)[n].pptrdiffarg = va_arg(ap, ptrdiff_t*); + break; + case T_SIZEINT: + (*argtable)[n].sizearg = va_arg(ap, size_t); + break; + case T_SSIZEINT: + (*argtable)[n].ssizearg = va_arg(ap, ssize_t); + break; + case TP_SSIZEINT: + (*argtable)[n].pssizearg = va_arg(ap, ssize_t*); + break; + case TP_MAXINT: + (*argtable)[n].intmaxarg = va_arg(ap, intmax_t); + break; + case T_WINT: + (*argtable)[n].wintarg = va_arg(ap, wint_t); + break; + case TP_WCHAR: + (*argtable)[n].pwchararg = va_arg(ap, wchar_t*); + break; + } + } + goto finish; overflow: - errno = ENOMEM; - ret = -1; + errno = ENOMEM; + ret = -1; finish: - if (typetable != NULL && typetable != stattypetable) { - munmap(typetable, *argtablesiz); - typetable = NULL; - } - return (ret); + if (typetable != NULL && typetable != stattypetable) { + munmap(typetable, *argtablesiz); + typetable = NULL; + } + return (ret); } /* * Increase the size of the type table. */ -static int -__grow_type_table(unsigned char **typetable, int *tablesize) -{ - unsigned char *oldtable = *typetable; - int newsize = *tablesize * 2; - - if (newsize < getpagesize()) - newsize = getpagesize(); - - if (*tablesize == STATIC_ARG_TBL_SIZE) { - *typetable = mmap(NULL, newsize, PROT_WRITE|PROT_READ, - MAP_ANON|MAP_PRIVATE, -1, 0); - if (*typetable == MAP_FAILED) - return (-1); - bcopy(oldtable, *typetable, *tablesize); - } else { - unsigned char *new = mmap(NULL, newsize, PROT_WRITE|PROT_READ, - MAP_ANON|MAP_PRIVATE, -1, 0); - if (new == MAP_FAILED) - return (-1); - memmove(new, *typetable, *tablesize); - munmap(*typetable, *tablesize); - *typetable = new; - } - memset(*typetable + *tablesize, T_UNUSED, (newsize - *tablesize)); - - *tablesize = newsize; - return (0); +static int __grow_type_table(unsigned char** typetable, int* tablesize) { + unsigned char* oldtable = *typetable; + int newsize = *tablesize * 2; + + if (newsize < getpagesize()) newsize = getpagesize(); + + if (*tablesize == STATIC_ARG_TBL_SIZE) { + *typetable = mmap(NULL, newsize, PROT_WRITE | PROT_READ, MAP_ANON | MAP_PRIVATE, -1, 0); + if (*typetable == MAP_FAILED) return (-1); + bcopy(oldtable, *typetable, *tablesize); + } else { + unsigned char* new = mmap(NULL, newsize, PROT_WRITE | PROT_READ, MAP_ANON | MAP_PRIVATE, -1, 0); + if (new == MAP_FAILED) return (-1); + memmove(new, *typetable, *tablesize); + munmap(*typetable, *tablesize); + *typetable = new; + } + memset(*typetable + *tablesize, T_UNUSED, (newsize - *tablesize)); + + *tablesize = newsize; + return (0); } - -static int -exponent(wchar_t *p0, int exp, int fmtch) -{ - wchar_t *p, *t; - wchar_t expbuf[MAXEXPDIG]; - - p = p0; - *p++ = fmtch; - if (exp < 0) { - exp = -exp; - *p++ = '-'; - } else - *p++ = '+'; - t = expbuf + MAXEXPDIG; - if (exp > 9) { - do { - *--t = to_char(exp % 10); - } while ((exp /= 10) > 9); - *--t = to_char(exp); - for (; t < expbuf + MAXEXPDIG; *p++ = *t++) - /* nothing */; - } else { - /* - * Exponents for decimal floating point conversions - * (%[eEgG]) must be at least two characters long, - * whereas exponents for hexadecimal conversions can - * be only one character long. - */ - if (fmtch == 'e' || fmtch == 'E') - *p++ = '0'; - *p++ = to_char(exp); - } - return (p - p0); +static int exponent(wchar_t* p0, int exp, int fmtch) { + wchar_t *p, *t; + wchar_t expbuf[MAXEXPDIG]; + + p = p0; + *p++ = fmtch; + if (exp < 0) { + exp = -exp; + *p++ = '-'; + } else + *p++ = '+'; + t = expbuf + MAXEXPDIG; + if (exp > 9) { + do { + *--t = to_char(exp % 10); + } while ((exp /= 10) > 9); + *--t = to_char(exp); + for (; t < expbuf + MAXEXPDIG; *p++ = *t++) /* nothing */; + } else { + /* + * Exponents for decimal floating point conversions + * (%[eEgG]) must be at least two characters long, + * whereas exponents for hexadecimal conversions can + * be only one character long. + */ + if (fmtch == 'e' || fmtch == 'E') *p++ = '0'; + *p++ = to_char(exp); + } + return (p - p0); } diff --git a/libc/stdio/vfwscanf.c b/libc/stdio/vfwscanf.c index a05fffe006..c74c6e7c8c 100644 --- a/libc/stdio/vfwscanf.c +++ b/libc/stdio/vfwscanf.c @@ -44,54 +44,54 @@ #include "floatio.h" -#define BUF 513 /* Maximum length of numeric string. */ +#define BUF 513 /* Maximum length of numeric string. */ /* * Flags used during conversion. */ -#define LONG 0x00001 /* l: long or double */ -#define LONGDBL 0x00002 /* L: long double */ -#define SHORT 0x00004 /* h: short */ -#define SHORTSHORT 0x00008 /* hh: 8 bit integer */ -#define LLONG 0x00010 /* ll: long long (+ deprecated q: quad) */ -#define POINTER 0x00020 /* p: void * (as hex) */ -#define SIZEINT 0x00040 /* z: (signed) size_t */ -#define MAXINT 0x00080 /* j: intmax_t */ -#define PTRINT 0x00100 /* t: ptrdiff_t */ -#define NOSKIP 0x00200 /* [ or c: do not skip blanks */ -#define SUPPRESS 0x00400 /* *: suppress assignment */ -#define UNSIGNED 0x00800 /* %[oupxX] conversions */ +#define LONG 0x00001 /* l: long or double */ +#define LONGDBL 0x00002 /* L: long double */ +#define SHORT 0x00004 /* h: short */ +#define SHORTSHORT 0x00008 /* hh: 8 bit integer */ +#define LLONG 0x00010 /* ll: long long (+ deprecated q: quad) */ +#define POINTER 0x00020 /* p: void * (as hex) */ +#define SIZEINT 0x00040 /* z: (signed) size_t */ +#define MAXINT 0x00080 /* j: intmax_t */ +#define PTRINT 0x00100 /* t: ptrdiff_t */ +#define NOSKIP 0x00200 /* [ or c: do not skip blanks */ +#define SUPPRESS 0x00400 /* *: suppress assignment */ +#define UNSIGNED 0x00800 /* %[oupxX] conversions */ /* * The following are used in numeric conversions only: * SIGNOK, HAVESIGN, NDIGITS, DPTOK, and EXPOK are for floating point; * SIGNOK, HAVESIGN, NDIGITS, PFXOK, and NZDIGITS are for integral. */ -#define SIGNOK 0x01000 /* +/- is (still) legal */ -#define HAVESIGN 0x02000 /* sign detected */ -#define NDIGITS 0x04000 /* no digits detected */ +#define SIGNOK 0x01000 /* +/- is (still) legal */ +#define HAVESIGN 0x02000 /* sign detected */ +#define NDIGITS 0x04000 /* no digits detected */ -#define DPTOK 0x08000 /* (float) decimal point is still legal */ -#define EXPOK 0x10000 /* (float) exponent (e+3, etc) still legal */ +#define DPTOK 0x08000 /* (float) decimal point is still legal */ +#define EXPOK 0x10000 /* (float) exponent (e+3, etc) still legal */ -#define PFXOK 0x08000 /* 0x prefix is (still) legal */ -#define NZDIGITS 0x10000 /* no zero digits detected */ +#define PFXOK 0x08000 /* 0x prefix is (still) legal */ +#define NZDIGITS 0x10000 /* no zero digits detected */ /* * Conversion types. */ -#define CT_CHAR 0 /* %c conversion */ -#define CT_CCL 1 /* %[...] conversion */ -#define CT_STRING 2 /* %s conversion */ -#define CT_INT 3 /* integer, i.e., strtoimax or strtoumax */ -#define CT_FLOAT 4 /* floating, i.e., strtod */ +#define CT_CHAR 0 /* %c conversion */ +#define CT_CCL 1 /* %[...] conversion */ +#define CT_STRING 2 /* %s conversion */ +#define CT_INT 3 /* integer, i.e., strtoimax or strtoumax */ +#define CT_FLOAT 4 /* floating, i.e., strtod */ #define u_char unsigned char #define u_long unsigned long -#define INCCL(_c) \ - (cclcompl ? (wmemchr(ccls, (_c), ccle - ccls) == NULL) : \ - (wmemchr(ccls, (_c), ccle - ccls) != NULL)) +#define INCCL(_c) \ + (cclcompl ? (wmemchr(ccls, (_c), ccle - ccls) == NULL) \ + : (wmemchr(ccls, (_c), ccle - ccls) != NULL)) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wframe-larger-than=" @@ -99,623 +99,569 @@ /* * vfwscanf */ -int -__vfwscanf(FILE * __restrict fp, const wchar_t * __restrict fmt, __va_list ap) -{ - wint_t c; /* character from format, or conversion */ - size_t width; /* field width, or 0 */ - wchar_t *p; /* points into all kinds of strings */ - int n; /* handy integer */ - int flags; /* flags as defined above */ - wchar_t *p0; /* saves original value of p when necessary */ - int nassigned; /* number of fields assigned */ - int nconversions; /* number of conversions */ - int nread; /* number of characters consumed from fp */ - int base; /* base argument to strtoimax/strtouimax */ - wchar_t buf[BUF]; /* buffer for numeric conversions */ - const wchar_t *ccls; /* character class start */ - const wchar_t *ccle; /* character class end */ - int cclcompl; /* ccl is complemented? */ - wint_t wi; /* handy wint_t */ - char *mbp; /* multibyte string pointer for %c %s %[ */ - size_t nconv; /* number of bytes in mb. conversion */ - char mbbuf[MB_LEN_MAX]; /* temporary mb. character buffer */ - mbstate_t mbs; - - /* `basefix' is used to avoid `if' tests in the integer scanner */ - static short basefix[17] = - { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; - - _SET_ORIENTATION(fp, 1); - - nassigned = 0; - nconversions = 0; - nread = 0; - base = 0; /* XXX just to keep gcc happy */ - ccls = ccle = NULL; - for (;;) { - c = *fmt++; - if (c == 0) { - return (nassigned); - } - if (iswspace(c)) { - while ((c = __fgetwc_unlock(fp)) != WEOF && - iswspace(c)) - ; - if (c != WEOF) - __ungetwc(c, fp); - continue; - } - if (c != '%') - goto literal; - width = 0; - flags = 0; - /* - * switch on the format. continue if done; - * break once format type is derived. - */ -again: c = *fmt++; - switch (c) { - case '%': -literal: - if ((wi = __fgetwc_unlock(fp)) == WEOF) - goto input_failure; - if (wi != c) { - __ungetwc(wi, fp); - goto input_failure; - } - nread++; - continue; - - case '*': - flags |= SUPPRESS; - goto again; - case 'j': - flags |= MAXINT; - goto again; - case 'L': - flags |= LONGDBL; - goto again; - case 'h': - if (*fmt == 'h') { - fmt++; - flags |= SHORTSHORT; - } else { - flags |= SHORT; - } - goto again; - case 'l': - if (*fmt == 'l') { - fmt++; - flags |= LLONG; - } else { - flags |= LONG; - } - goto again; - case 'q': - flags |= LLONG; /* deprecated */ - goto again; - case 't': - flags |= PTRINT; - goto again; - case 'z': - flags |= SIZEINT; - goto again; - - case '0': case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - width = width * 10 + c - '0'; - goto again; - - /* - * Conversions. - * Those marked `compat' are for 4.[123]BSD compatibility. - * - * (According to ANSI, E and X formats are supposed - * to the same as e and x. Sorry about that.) - */ - case 'D': /* compat */ - flags |= LONG; - /* FALLTHROUGH */ - case 'd': - c = CT_INT; - base = 10; - break; - - case 'i': - c = CT_INT; - base = 0; - break; - - case 'O': /* compat */ - flags |= LONG; - /* FALLTHROUGH */ - case 'o': - c = CT_INT; - flags |= UNSIGNED; - base = 8; - break; - - case 'u': - c = CT_INT; - flags |= UNSIGNED; - base = 10; - break; - - case 'X': - case 'x': - flags |= PFXOK; /* enable 0x prefixing */ - c = CT_INT; - flags |= UNSIGNED; - base = 16; - break; - - case 'e': case 'E': - case 'f': case 'F': - case 'g': case 'G': - case 'a': case 'A': - c = CT_FLOAT; - break; - - case 's': - c = CT_STRING; - break; - - case '[': - ccls = fmt; - if (*fmt == '^') { - cclcompl = 1; - fmt++; - } else - cclcompl = 0; - if (*fmt == ']') - fmt++; - while (*fmt != '\0' && *fmt != ']') - fmt++; - ccle = fmt; - fmt++; - flags |= NOSKIP; - c = CT_CCL; - break; - - case 'c': - flags |= NOSKIP; - c = CT_CHAR; - break; - - case 'p': /* pointer format is like hex */ - flags |= POINTER | PFXOK; - c = CT_INT; - flags |= UNSIGNED; - base = 16; - break; - - case 'n': - nconversions++; - if (flags & SUPPRESS) - continue; - if (flags & SHORTSHORT) - *va_arg(ap, signed char *) = nread; - else if (flags & SHORT) - *va_arg(ap, short *) = nread; - else if (flags & LONG) - *va_arg(ap, long *) = nread; - else if (flags & SIZEINT) - *va_arg(ap, ssize_t *) = nread; - else if (flags & PTRINT) - *va_arg(ap, ptrdiff_t *) = nread; - else if (flags & LLONG) - *va_arg(ap, long long *) = nread; - else if (flags & MAXINT) - *va_arg(ap, intmax_t *) = nread; - else - *va_arg(ap, int *) = nread; - continue; - - /* - * Disgusting backwards compatibility hacks. XXX - */ - case '\0': /* compat */ - return (EOF); - - default: /* compat */ - if (iswupper(c)) - flags |= LONG; - c = CT_INT; - base = 10; - break; - } - - /* - * Consume leading white space, except for formats - * that suppress this. - */ - if ((flags & NOSKIP) == 0) { - while ((wi = __fgetwc_unlock(fp)) != WEOF && - iswspace(wi)) - nread++; - if (wi == WEOF) - goto input_failure; - __ungetwc(wi, fp); - } - - /* - * Do the conversion. - */ - switch (c) { - - case CT_CHAR: - /* scan arbitrary characters (sets NOSKIP) */ - if (width == 0) - width = 1; - if (flags & LONG) { - if (!(flags & SUPPRESS)) - p = va_arg(ap, wchar_t *); - n = 0; - while (width-- != 0 && - (wi = __fgetwc_unlock(fp)) != WEOF) { - if (!(flags & SUPPRESS)) - *p++ = (wchar_t)wi; - n++; - } - if (n == 0) - goto input_failure; - nread += n; - if (!(flags & SUPPRESS)) - nassigned++; - } else { - if (!(flags & SUPPRESS)) - mbp = va_arg(ap, char *); - n = 0; - memset(&mbs, 0, sizeof(mbs)); - while (width != 0 && - (wi = __fgetwc_unlock(fp)) != WEOF) { - if (width >= MB_CUR_MAX && - !(flags & SUPPRESS)) { - nconv = wcrtomb(mbp, wi, &mbs); - if (nconv == (size_t)-1) - goto input_failure; - } else { - nconv = wcrtomb(mbbuf, wi, - &mbs); - if (nconv == (size_t)-1) - goto input_failure; - if (nconv > width) { - __ungetwc(wi, fp); - break; - } - if (!(flags & SUPPRESS)) - memcpy(mbp, mbbuf, - nconv); - } - if (!(flags & SUPPRESS)) - mbp += nconv; - width -= nconv; - n++; - } - if (n == 0) - goto input_failure; - nread += n; - if (!(flags & SUPPRESS)) - nassigned++; - } - nconversions++; - break; - - case CT_CCL: - /* scan a (nonempty) character class (sets NOSKIP) */ - if (width == 0) - width = (size_t)~0; /* `infinity' */ - /* take only those things in the class */ - if ((flags & SUPPRESS) && (flags & LONG)) { - n = 0; - while ((wi = __fgetwc_unlock(fp)) != WEOF && - width-- != 0 && INCCL(wi)) - n++; - if (wi != WEOF) - __ungetwc(wi, fp); - if (n == 0) - goto match_failure; - } else if (flags & LONG) { - p0 = p = va_arg(ap, wchar_t *); - while ((wi = __fgetwc_unlock(fp)) != WEOF && - width-- != 0 && INCCL(wi)) - *p++ = (wchar_t)wi; - if (wi != WEOF) - __ungetwc(wi, fp); - n = p - p0; - if (n == 0) - goto match_failure; - *p = 0; - nassigned++; - } else { - if (!(flags & SUPPRESS)) - mbp = va_arg(ap, char *); - n = 0; - memset(&mbs, 0, sizeof(mbs)); - while ((wi = __fgetwc_unlock(fp)) != WEOF && - width != 0 && INCCL(wi)) { - if (width >= MB_CUR_MAX && - !(flags & SUPPRESS)) { - nconv = wcrtomb(mbp, wi, &mbs); - if (nconv == (size_t)-1) - goto input_failure; - } else { - nconv = wcrtomb(mbbuf, wi, - &mbs); - if (nconv == (size_t)-1) - goto input_failure; - if (nconv > width) - break; - if (!(flags & SUPPRESS)) - memcpy(mbp, mbbuf, - nconv); - } - if (!(flags & SUPPRESS)) - mbp += nconv; - width -= nconv; - n++; - } - if (wi != WEOF) - __ungetwc(wi, fp); - if (!(flags & SUPPRESS)) { - *mbp = 0; - nassigned++; - } - } - nread += n; - nconversions++; - break; - - case CT_STRING: - /* like CCL, but zero-length string OK, & no NOSKIP */ - if (width == 0) - width = (size_t)~0; - if ((flags & SUPPRESS) && (flags & LONG)) { - while ((wi = __fgetwc_unlock(fp)) != WEOF && - width-- != 0 && - !iswspace(wi)) - nread++; - if (wi != WEOF) - __ungetwc(wi, fp); - } else if (flags & LONG) { - p0 = p = va_arg(ap, wchar_t *); - while ((wi = __fgetwc_unlock(fp)) != WEOF && - width-- != 0 && - !iswspace(wi)) { - *p++ = (wchar_t)wi; - nread++; - } - if (wi != WEOF) - __ungetwc(wi, fp); - *p = 0; - nassigned++; - } else { - if (!(flags & SUPPRESS)) - mbp = va_arg(ap, char *); - memset(&mbs, 0, sizeof(mbs)); - while ((wi = __fgetwc_unlock(fp)) != WEOF && - width != 0 && - !iswspace(wi)) { - if (width >= MB_CUR_MAX && - !(flags & SUPPRESS)) { - nconv = wcrtomb(mbp, wi, &mbs); - if (nconv == (size_t)-1) - goto input_failure; - } else { - nconv = wcrtomb(mbbuf, wi, - &mbs); - if (nconv == (size_t)-1) - goto input_failure; - if (nconv > width) - break; - if (!(flags & SUPPRESS)) - memcpy(mbp, mbbuf, - nconv); - } - if (!(flags & SUPPRESS)) - mbp += nconv; - width -= nconv; - nread++; - } - if (wi != WEOF) - __ungetwc(wi, fp); - if (!(flags & SUPPRESS)) { - *mbp = 0; - nassigned++; - } - } - nconversions++; - continue; - - case CT_INT: - /* scan an integer as if by strtoimax/strtoumax */ - if (width == 0 || width > sizeof(buf) / - sizeof(*buf) - 1) - width = sizeof(buf) / sizeof(*buf) - 1; - flags |= SIGNOK | NDIGITS | NZDIGITS; - for (p = buf; width; width--) { - c = __fgetwc_unlock(fp); - /* - * Switch on the character; `goto ok' - * if we accept it as a part of number. - */ - switch (c) { - - /* - * The digit 0 is always legal, but is - * special. For %i conversions, if no - * digits (zero or nonzero) have been - * scanned (only signs), we will have - * base==0. In that case, we should set - * it to 8 and enable 0x prefixing. - * Also, if we have not scanned zero digits - * before this, do not turn off prefixing - * (someone else will turn it off if we - * have scanned any nonzero digits). - */ - case '0': - if (base == 0) { - base = 8; - flags |= PFXOK; - } - if (flags & NZDIGITS) - flags &= ~(SIGNOK|NZDIGITS|NDIGITS); - else - flags &= ~(SIGNOK|PFXOK|NDIGITS); - goto ok; - - /* 1 through 7 always legal */ - case '1': case '2': case '3': - case '4': case '5': case '6': case '7': - base = basefix[base]; - flags &= ~(SIGNOK | PFXOK | NDIGITS); - goto ok; - - /* digits 8 and 9 ok iff decimal or hex */ - case '8': case '9': - base = basefix[base]; - if (base <= 8) - break; /* not legal here */ - flags &= ~(SIGNOK | PFXOK | NDIGITS); - goto ok; - - /* letters ok iff hex */ - case 'A': case 'B': case 'C': - case 'D': case 'E': case 'F': - case 'a': case 'b': case 'c': - case 'd': case 'e': case 'f': - /* no need to fix base here */ - if (base <= 10) - break; /* not legal here */ - flags &= ~(SIGNOK | PFXOK | NDIGITS); - goto ok; - - /* sign ok only as first character */ - case '+': case '-': - if (flags & SIGNOK) { - flags &= ~SIGNOK; - flags |= HAVESIGN; - goto ok; - } - break; - - /* - * x ok iff flag still set and 2nd char (or - * 3rd char if we have a sign). - */ - case 'x': case 'X': - if ((flags & PFXOK) && p == - buf + 1 + !!(flags & HAVESIGN)) { - base = 16; /* if %i */ - flags &= ~PFXOK; - goto ok; - } - break; - } - - /* - * If we got here, c is not a legal character - * for a number. Stop accumulating digits. - */ - if (c != WEOF) - __ungetwc(c, fp); - break; - ok: - /* - * c is legal: store it and look at the next. - */ - *p++ = (wchar_t)c; - } - /* - * If we had only a sign, it is no good; push - * back the sign. If the number ends in `x', - * it was [sign] '0' 'x', so push back the x - * and treat it as [sign] '0'. - */ - if (flags & NDIGITS) { - if (p > buf) - __ungetwc(*--p, fp); - goto match_failure; - } - c = p[-1]; - if (c == 'x' || c == 'X') { - --p; - __ungetwc(c, fp); - } - if ((flags & SUPPRESS) == 0) { - uintmax_t res; - - *p = '\0'; - if (flags & UNSIGNED) - res = wcstoimax(buf, NULL, base); - else - res = wcstoumax(buf, NULL, base); - if (flags & POINTER) - *va_arg(ap, void **) = - (void *)(uintptr_t)res; - else if (flags & MAXINT) - *va_arg(ap, intmax_t *) = res; - else if (flags & LLONG) - *va_arg(ap, long long *) = res; - else if (flags & SIZEINT) - *va_arg(ap, ssize_t *) = res; - else if (flags & PTRINT) - *va_arg(ap, ptrdiff_t *) = res; - else if (flags & LONG) - *va_arg(ap, long *) = res; - else if (flags & SHORT) - *va_arg(ap, short *) = res; - else if (flags & SHORTSHORT) - *va_arg(ap, signed char *) = res; - else - *va_arg(ap, int *) = res; - nassigned++; - } - nread += p - buf; - nconversions++; - break; - - case CT_FLOAT: - /* scan a floating point number as if by strtod */ - if (width == 0 || width > sizeof(buf) / - sizeof(*buf) - 1) - width = sizeof(buf) / sizeof(*buf) - 1; - if ((width = wparsefloat(fp, buf, buf + width)) == 0) - goto match_failure; - if ((flags & SUPPRESS) == 0) { - if (flags & LONGDBL) { - long double res = wcstold(buf, &p); - *va_arg(ap, long double *) = res; - } else if (flags & LONG) { - double res = wcstod(buf, &p); - *va_arg(ap, double *) = res; - } else { - float res = wcstof(buf, &p); - *va_arg(ap, float *) = res; - } - if (p - buf != (ptrdiff_t)width) abort(); - nassigned++; - } - nread += width; - nconversions++; - break; - } - } +int __vfwscanf(FILE* __restrict fp, const wchar_t* __restrict fmt, __va_list ap) { + wint_t c; /* character from format, or conversion */ + size_t width; /* field width, or 0 */ + wchar_t* p; /* points into all kinds of strings */ + int n; /* handy integer */ + int flags; /* flags as defined above */ + wchar_t* p0; /* saves original value of p when necessary */ + int nassigned; /* number of fields assigned */ + int nconversions; /* number of conversions */ + int nread; /* number of characters consumed from fp */ + int base; /* base argument to strtoimax/strtouimax */ + wchar_t buf[BUF]; /* buffer for numeric conversions */ + const wchar_t* ccls; /* character class start */ + const wchar_t* ccle; /* character class end */ + int cclcompl; /* ccl is complemented? */ + wint_t wi; /* handy wint_t */ + char* mbp; /* multibyte string pointer for %c %s %[ */ + size_t nconv; /* number of bytes in mb. conversion */ + char mbbuf[MB_LEN_MAX]; /* temporary mb. character buffer */ + mbstate_t mbs; + + /* `basefix' is used to avoid `if' tests in the integer scanner */ + static short basefix[17] = { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; + + _SET_ORIENTATION(fp, 1); + + nassigned = 0; + nconversions = 0; + nread = 0; + base = 0; /* XXX just to keep gcc happy */ + ccls = ccle = NULL; + for (;;) { + c = *fmt++; + if (c == 0) { + return (nassigned); + } + if (iswspace(c)) { + while ((c = __fgetwc_unlock(fp)) != WEOF && iswspace(c)) + ; + if (c != WEOF) __ungetwc(c, fp); + continue; + } + if (c != '%') goto literal; + width = 0; + flags = 0; + /* + * switch on the format. continue if done; + * break once format type is derived. + */ + again: + c = *fmt++; + switch (c) { + case '%': + literal: + if ((wi = __fgetwc_unlock(fp)) == WEOF) goto input_failure; + if (wi != c) { + __ungetwc(wi, fp); + goto input_failure; + } + nread++; + continue; + + case '*': + flags |= SUPPRESS; + goto again; + case 'j': + flags |= MAXINT; + goto again; + case 'L': + flags |= LONGDBL; + goto again; + case 'h': + if (*fmt == 'h') { + fmt++; + flags |= SHORTSHORT; + } else { + flags |= SHORT; + } + goto again; + case 'l': + if (*fmt == 'l') { + fmt++; + flags |= LLONG; + } else { + flags |= LONG; + } + goto again; + case 'q': + flags |= LLONG; /* deprecated */ + goto again; + case 't': + flags |= PTRINT; + goto again; + case 'z': + flags |= SIZEINT; + goto again; + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + width = width * 10 + c - '0'; + goto again; + + /* + * Conversions. + * Those marked `compat' are for 4.[123]BSD compatibility. + * + * (According to ANSI, E and X formats are supposed + * to the same as e and x. Sorry about that.) + */ + case 'D': /* compat */ + flags |= LONG; + /* FALLTHROUGH */ + case 'd': + c = CT_INT; + base = 10; + break; + + case 'i': + c = CT_INT; + base = 0; + break; + + case 'O': /* compat */ + flags |= LONG; + /* FALLTHROUGH */ + case 'o': + c = CT_INT; + flags |= UNSIGNED; + base = 8; + break; + + case 'u': + c = CT_INT; + flags |= UNSIGNED; + base = 10; + break; + + case 'X': + case 'x': + flags |= PFXOK; /* enable 0x prefixing */ + c = CT_INT; + flags |= UNSIGNED; + base = 16; + break; + + case 'e': + case 'E': + case 'f': + case 'F': + case 'g': + case 'G': + case 'a': + case 'A': + c = CT_FLOAT; + break; + + case 's': + c = CT_STRING; + break; + + case '[': + ccls = fmt; + if (*fmt == '^') { + cclcompl = 1; + fmt++; + } else + cclcompl = 0; + if (*fmt == ']') fmt++; + while (*fmt != '\0' && *fmt != ']') fmt++; + ccle = fmt; + fmt++; + flags |= NOSKIP; + c = CT_CCL; + break; + + case 'c': + flags |= NOSKIP; + c = CT_CHAR; + break; + + case 'p': /* pointer format is like hex */ + flags |= POINTER | PFXOK; + c = CT_INT; + flags |= UNSIGNED; + base = 16; + break; + + case 'n': + nconversions++; + if (flags & SUPPRESS) continue; + if (flags & SHORTSHORT) + *va_arg(ap, signed char*) = nread; + else if (flags & SHORT) + *va_arg(ap, short*) = nread; + else if (flags & LONG) + *va_arg(ap, long*) = nread; + else if (flags & SIZEINT) + *va_arg(ap, ssize_t*) = nread; + else if (flags & PTRINT) + *va_arg(ap, ptrdiff_t*) = nread; + else if (flags & LLONG) + *va_arg(ap, long long*) = nread; + else if (flags & MAXINT) + *va_arg(ap, intmax_t*) = nread; + else + *va_arg(ap, int*) = nread; + continue; + + /* + * Disgusting backwards compatibility hacks. XXX + */ + case '\0': /* compat */ + return (EOF); + + default: /* compat */ + if (iswupper(c)) flags |= LONG; + c = CT_INT; + base = 10; + break; + } + + /* + * Consume leading white space, except for formats + * that suppress this. + */ + if ((flags & NOSKIP) == 0) { + while ((wi = __fgetwc_unlock(fp)) != WEOF && iswspace(wi)) nread++; + if (wi == WEOF) goto input_failure; + __ungetwc(wi, fp); + } + + /* + * Do the conversion. + */ + switch (c) { + case CT_CHAR: + /* scan arbitrary characters (sets NOSKIP) */ + if (width == 0) width = 1; + if (flags & LONG) { + if (!(flags & SUPPRESS)) p = va_arg(ap, wchar_t*); + n = 0; + while (width-- != 0 && (wi = __fgetwc_unlock(fp)) != WEOF) { + if (!(flags & SUPPRESS)) *p++ = (wchar_t)wi; + n++; + } + if (n == 0) goto input_failure; + nread += n; + if (!(flags & SUPPRESS)) nassigned++; + } else { + if (!(flags & SUPPRESS)) mbp = va_arg(ap, char*); + n = 0; + memset(&mbs, 0, sizeof(mbs)); + while (width != 0 && (wi = __fgetwc_unlock(fp)) != WEOF) { + if (width >= MB_CUR_MAX && !(flags & SUPPRESS)) { + nconv = wcrtomb(mbp, wi, &mbs); + if (nconv == (size_t)-1) goto input_failure; + } else { + nconv = wcrtomb(mbbuf, wi, &mbs); + if (nconv == (size_t)-1) goto input_failure; + if (nconv > width) { + __ungetwc(wi, fp); + break; + } + if (!(flags & SUPPRESS)) memcpy(mbp, mbbuf, nconv); + } + if (!(flags & SUPPRESS)) mbp += nconv; + width -= nconv; + n++; + } + if (n == 0) goto input_failure; + nread += n; + if (!(flags & SUPPRESS)) nassigned++; + } + nconversions++; + break; + + case CT_CCL: + /* scan a (nonempty) character class (sets NOSKIP) */ + if (width == 0) width = (size_t)~0; /* `infinity' */ + /* take only those things in the class */ + if ((flags & SUPPRESS) && (flags & LONG)) { + n = 0; + while ((wi = __fgetwc_unlock(fp)) != WEOF && width-- != 0 && INCCL(wi)) n++; + if (wi != WEOF) __ungetwc(wi, fp); + if (n == 0) goto match_failure; + } else if (flags & LONG) { + p0 = p = va_arg(ap, wchar_t*); + while ((wi = __fgetwc_unlock(fp)) != WEOF && width-- != 0 && INCCL(wi)) + *p++ = (wchar_t)wi; + if (wi != WEOF) __ungetwc(wi, fp); + n = p - p0; + if (n == 0) goto match_failure; + *p = 0; + nassigned++; + } else { + if (!(flags & SUPPRESS)) mbp = va_arg(ap, char*); + n = 0; + memset(&mbs, 0, sizeof(mbs)); + while ((wi = __fgetwc_unlock(fp)) != WEOF && width != 0 && INCCL(wi)) { + if (width >= MB_CUR_MAX && !(flags & SUPPRESS)) { + nconv = wcrtomb(mbp, wi, &mbs); + if (nconv == (size_t)-1) goto input_failure; + } else { + nconv = wcrtomb(mbbuf, wi, &mbs); + if (nconv == (size_t)-1) goto input_failure; + if (nconv > width) break; + if (!(flags & SUPPRESS)) memcpy(mbp, mbbuf, nconv); + } + if (!(flags & SUPPRESS)) mbp += nconv; + width -= nconv; + n++; + } + if (wi != WEOF) __ungetwc(wi, fp); + if (!(flags & SUPPRESS)) { + *mbp = 0; + nassigned++; + } + } + nread += n; + nconversions++; + break; + + case CT_STRING: + /* like CCL, but zero-length string OK, & no NOSKIP */ + if (width == 0) width = (size_t)~0; + if ((flags & SUPPRESS) && (flags & LONG)) { + while ((wi = __fgetwc_unlock(fp)) != WEOF && width-- != 0 && !iswspace(wi)) nread++; + if (wi != WEOF) __ungetwc(wi, fp); + } else if (flags & LONG) { + p0 = p = va_arg(ap, wchar_t*); + while ((wi = __fgetwc_unlock(fp)) != WEOF && width-- != 0 && !iswspace(wi)) { + *p++ = (wchar_t)wi; + nread++; + } + if (wi != WEOF) __ungetwc(wi, fp); + *p = 0; + nassigned++; + } else { + if (!(flags & SUPPRESS)) mbp = va_arg(ap, char*); + memset(&mbs, 0, sizeof(mbs)); + while ((wi = __fgetwc_unlock(fp)) != WEOF && width != 0 && !iswspace(wi)) { + if (width >= MB_CUR_MAX && !(flags & SUPPRESS)) { + nconv = wcrtomb(mbp, wi, &mbs); + if (nconv == (size_t)-1) goto input_failure; + } else { + nconv = wcrtomb(mbbuf, wi, &mbs); + if (nconv == (size_t)-1) goto input_failure; + if (nconv > width) break; + if (!(flags & SUPPRESS)) memcpy(mbp, mbbuf, nconv); + } + if (!(flags & SUPPRESS)) mbp += nconv; + width -= nconv; + nread++; + } + if (wi != WEOF) __ungetwc(wi, fp); + if (!(flags & SUPPRESS)) { + *mbp = 0; + nassigned++; + } + } + nconversions++; + continue; + + case CT_INT: + /* scan an integer as if by strtoimax/strtoumax */ + if (width == 0 || width > sizeof(buf) / sizeof(*buf) - 1) + width = sizeof(buf) / sizeof(*buf) - 1; + flags |= SIGNOK | NDIGITS | NZDIGITS; + for (p = buf; width; width--) { + c = __fgetwc_unlock(fp); + /* + * Switch on the character; `goto ok' + * if we accept it as a part of number. + */ + switch (c) { + /* + * The digit 0 is always legal, but is + * special. For %i conversions, if no + * digits (zero or nonzero) have been + * scanned (only signs), we will have + * base==0. In that case, we should set + * it to 8 and enable 0x prefixing. + * Also, if we have not scanned zero digits + * before this, do not turn off prefixing + * (someone else will turn it off if we + * have scanned any nonzero digits). + */ + case '0': + if (base == 0) { + base = 8; + flags |= PFXOK; + } + if (flags & NZDIGITS) + flags &= ~(SIGNOK | NZDIGITS | NDIGITS); + else + flags &= ~(SIGNOK | PFXOK | NDIGITS); + goto ok; + + /* 1 through 7 always legal */ + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + base = basefix[base]; + flags &= ~(SIGNOK | PFXOK | NDIGITS); + goto ok; + + /* digits 8 and 9 ok iff decimal or hex */ + case '8': + case '9': + base = basefix[base]; + if (base <= 8) break; /* not legal here */ + flags &= ~(SIGNOK | PFXOK | NDIGITS); + goto ok; + + /* letters ok iff hex */ + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + /* no need to fix base here */ + if (base <= 10) break; /* not legal here */ + flags &= ~(SIGNOK | PFXOK | NDIGITS); + goto ok; + + /* sign ok only as first character */ + case '+': + case '-': + if (flags & SIGNOK) { + flags &= ~SIGNOK; + flags |= HAVESIGN; + goto ok; + } + break; + + /* + * x ok iff flag still set and 2nd char (or + * 3rd char if we have a sign). + */ + case 'x': + case 'X': + if ((flags & PFXOK) && p == buf + 1 + !!(flags & HAVESIGN)) { + base = 16; /* if %i */ + flags &= ~PFXOK; + goto ok; + } + break; + } + + /* + * If we got here, c is not a legal character + * for a number. Stop accumulating digits. + */ + if (c != WEOF) __ungetwc(c, fp); + break; + ok: + /* + * c is legal: store it and look at the next. + */ + *p++ = (wchar_t)c; + } + /* + * If we had only a sign, it is no good; push + * back the sign. If the number ends in `x', + * it was [sign] '0' 'x', so push back the x + * and treat it as [sign] '0'. + */ + if (flags & NDIGITS) { + if (p > buf) __ungetwc(*--p, fp); + goto match_failure; + } + c = p[-1]; + if (c == 'x' || c == 'X') { + --p; + __ungetwc(c, fp); + } + if ((flags & SUPPRESS) == 0) { + uintmax_t res; + + *p = '\0'; + if (flags & UNSIGNED) + res = wcstoimax(buf, NULL, base); + else + res = wcstoumax(buf, NULL, base); + if (flags & POINTER) + *va_arg(ap, void**) = (void*)(uintptr_t)res; + else if (flags & MAXINT) + *va_arg(ap, intmax_t*) = res; + else if (flags & LLONG) + *va_arg(ap, long long*) = res; + else if (flags & SIZEINT) + *va_arg(ap, ssize_t*) = res; + else if (flags & PTRINT) + *va_arg(ap, ptrdiff_t*) = res; + else if (flags & LONG) + *va_arg(ap, long*) = res; + else if (flags & SHORT) + *va_arg(ap, short*) = res; + else if (flags & SHORTSHORT) + *va_arg(ap, signed char*) = res; + else + *va_arg(ap, int*) = res; + nassigned++; + } + nread += p - buf; + nconversions++; + break; + + case CT_FLOAT: + /* scan a floating point number as if by strtod */ + if (width == 0 || width > sizeof(buf) / sizeof(*buf) - 1) + width = sizeof(buf) / sizeof(*buf) - 1; + if ((width = wparsefloat(fp, buf, buf + width)) == 0) goto match_failure; + if ((flags & SUPPRESS) == 0) { + if (flags & LONGDBL) { + long double res = wcstold(buf, &p); + *va_arg(ap, long double*) = res; + } else if (flags & LONG) { + double res = wcstod(buf, &p); + *va_arg(ap, double*) = res; + } else { + float res = wcstof(buf, &p); + *va_arg(ap, float*) = res; + } + if (p - buf != (ptrdiff_t)width) abort(); + nassigned++; + } + nread += width; + nconversions++; + break; + } + } input_failure: - return (nconversions != 0 ? nassigned : EOF); + return (nconversions != 0 ? nassigned : EOF); match_failure: - return (nassigned); + return (nassigned); } #pragma GCC diagnostic pop -int -vfwscanf(FILE * __restrict fp, const wchar_t * __restrict fmt, __va_list ap) -{ - int r; +int vfwscanf(FILE* __restrict fp, const wchar_t* __restrict fmt, __va_list ap) { + int r; - FLOCKFILE(fp); - r = __vfwscanf(fp, fmt, ap); - FUNLOCKFILE(fp); - return (r); + FLOCKFILE(fp); + r = __vfwscanf(fp, fmt, ap); + FUNLOCKFILE(fp); + return (r); } |