/* Copyright (c) 2002,2004,2005 Joerg Wunsch
   Copyright (c) 2008  Dmitry Xmelkov
   All rights reserved.

   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions are met:

   * Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.

   * Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution.

   * Neither the name of the copyright holders nor the names of
     contributors may be used to endorse or promote products derived
     from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  POSSIBILITY OF SUCH DAMAGE.
*/

/* $Id: vfscanf.c 2191 2010-11-05 13:45:57Z arcanum $ */

#include "stdio_private.h"
#include <wctype.h>
#include "scanf_private.h"

/*
 * Compute which features are required
 */

#ifdef _NEED_IO_LONG_LONG
typedef unsigned long long uint_scanf_t;
typedef long long int_scanf_t;
#else
typedef unsigned long uint_scanf_t;
typedef long int_scanf_t;
#endif

/* Figure out which multi-byte char support we need */
#if defined(_NEED_IO_WCHAR) && defined(_MB_CAPABLE)
# ifdef WIDE_CHARS
/* need to convert wide chars to multi-byte chars */
#  define _NEED_IO_WIDETOMB
# else
/* need to convert multi-byte chars to wide chars */
#  define _NEED_IO_MBTOWIDE
# endif
#endif

#ifdef WIDE_CHARS
# define INT wint_t
# define MY_EOF          WEOF
# define CHAR wchar_t
# define UCHAR wchar_t
# define GETC(s) getwc(s)
# define UNGETC(c,s) ungetwc(c,s)
# define ISSPACE(c) iswspace(c)
# undef vfscanf
# define vfscanf vfwscanf
# define IS_EOF(c)       ((c) == WEOF)
# define WINT            wint_t
# define IS_WEOF(c)      ((c) == WEOF)
# define ISWSPACE(c)     iswspace(c)
#else
# define INT int
# define MY_EOF          EOF
# define IS_EOF(c)       ((c) < 0)
# define CHAR char
# define UCHAR unsigned char
# define GETC(s) getc(s)
# define UNGETC(c,s) ungetc(c,s)
# define ISSPACE(c) isspace(c)
# ifdef _NEED_IO_MBTOWIDE
#  define WINT            wint_t
#  define MY_WEOF         WEOF
#  define IS_WEOF(c)      ((c) == WEOF)
#  define ISWSPACE(c)     iswspace(c)
# else
#  define WINT            int
#  define IS_WEOF(c)      IS_EOF(c)
#  define MY_WEOF         MY_EOF
#  define ISWSPACE(c)     ISSPACE(c)
# endif
#endif

#ifdef WIDE_CHARS
typedef struct {
    int         len;
    INT         unget;
} scanf_context_t;
#define SCANF_CONTEXT_INIT { .len = 0, .unget = MY_EOF }
#define scanf_len(context) ((context)->len)
#else
typedef int scanf_context_t;
#define SCANF_CONTEXT_INIT 0
#define scanf_len(context) (*(context))
#endif

static INT
scanf_getc(FILE *stream, scanf_context_t *context)
{
    INT c;
#ifdef WIDE_CHARS
    c = context->unget;
    context->unget = MY_EOF;
    if (IS_EOF(c))
#endif
        c = GETC(stream);
    if (!IS_EOF(c))
        ++scanf_len(context);
    return c;
}

static void
scanf_ungetc(INT c, FILE *stream, scanf_context_t *context)
{
    if (!IS_EOF(c))
        --scanf_len(context);
#ifdef WIDE_CHARS
    (void) stream;
    context->unget = c;
#else
    UNGETC(c, stream);
#endif
}

#ifdef _NEED_IO_MBTOWIDE
static WINT
getmb(FILE *stream, scanf_context_t *context, mbstate_t *ps, uint16_t flags)
{
    INT         i;

    if (flags & FL_LONG) {
        wchar_t     ch;
        char        mb[MB_LEN_MAX];
        size_t      n = 0;
        size_t      s;
        mbstate_t   save;

        while (n < MB_LEN_MAX) {
            i = scanf_getc (stream, context);
            if (IS_EOF(i))
                return WEOF;
            mb[n++] = (char) i;
            save = *ps;
            s = mbrtowc(&ch, mb, n, ps);
            switch (s) {
            case (size_t) -1:
                return WEOF;
            case (size_t) -2:
                *ps = save;
                break;
            default:
                return (wint_t) ch;
            }
        }
        return WEOF;
    } else {
        i = scanf_getc(stream, context);
        if (IS_EOF(i))
            return MY_WEOF;
        return (WINT) i;
    }
}
#else
#define getmb(s,c,p,f) scanf_getc(s,c)
#endif

#ifdef _NEED_IO_WIDETOMB
static void *
_putmb(void *addr, wint_t wi, mbstate_t *ps, uint16_t flags)
{
    if (flags & FL_LONG) {
        *(wchar_t *) addr = (wchar_t) wi;
        addr = (wchar_t *) addr + 1;
    } else {
        size_t  s;
        s = wcrtomb((char *) addr, (wchar_t) wi, ps);
        if (s == (size_t) -1)
            return NULL;
        addr = (char *) addr + s;
    }
    return addr;
}
#define putmb(addr, wi, ps, flags, fail) do {   \
        if (addr) {                             \
            addr = _putmb(addr, wi, ps, flags); \
            if (!addr) fail;                    \
        }                                       \
    } while(0);
#else
#ifdef _NEED_IO_WCHAR
static void *
_putmb(void *addr, wint_t wi, uint16_t flags)
{
    if (flags & FL_LONG) {
        *(wchar_t *) addr = (wchar_t) wi;
        addr = (wchar_t *) addr + 1;
    } else {
        *(char *) addr = (char) wi;
        addr = (char *) addr + 1;
    }
    return addr;
}
#define putmb(addr, wi, ps, flags, fail) do {   \
        if (addr) {                             \
            addr = _putmb(addr, wi, flags);     \
            if (!addr) fail;                    \
        }                                       \
    } while(0)
#else
#define putmb(addr, wi, ps, flags, fail) do {           \
        if (addr) {                                     \
            *(char *) addr = (char) wi;                 \
            addr = (char *) addr + 1;                   \
        }                                               \
    } while(0)
#endif
#endif

static void
putval (void *addr, int_scanf_t val, uint16_t flags)
{
    if (addr) {
	if (flags & FL_CHAR)
	    *(char *)addr = val;
#ifdef _NEED_IO_LONG_LONG
        else if (flags & FL_LONGLONG)
            *(long long *)addr = val;
#endif
	else if (flags & FL_LONG)
	    *(long *)addr = val;
	else if (flags & FL_SHORT)
	    *(short *)addr = val;
	else
	    *(int *)addr = val;
    }
}

static unsigned char
conv_int (FILE *stream, scanf_context_t *context, width_t width, void *addr, uint16_t flags, unsigned int base)
{
    uint_scanf_t val;
    INT i;

    i = scanf_getc (stream, context);			/* after scanf_ungetc()	*/

    switch (i) {
      case '-':
        flags |= FL_MINUS;
	__PICOLIBC_FALLTHROUGH;
      case '+':
        if (!--width || IS_EOF(i = scanf_getc(stream, context)))
	    goto err;
    }

    val = 0;

    /* Leading '0' digit -- check for base indication */
    if (i == '0') {
	if (!--width || IS_EOF(i = scanf_getc (stream, context)))
	    goto putval;

        flags |= FL_ANY;

        if (TOLOWER(i) == 'x' && (base == 0 || base == 16)) {
            base = 16;
            if (!--width || IS_EOF(i = scanf_getc (stream, context)))
		goto putval;
#ifdef _NEED_IO_PERCENT_B
        } else if (i == 'b' && base <= 2) {
            base = 2;
            if (!--width || IS_EOF(i = scanf_getc (stream, context)))
		goto putval;
#endif
	} else if (base == 0 || base == 8) {
            base = 8;
        }
    } else if (base == 0)
        base = 10;

    do {
	unsigned int c = digit_to_val(i);
        if (c >= base) {
            scanf_ungetc (i, stream, context);
            break;
	}
        flags |= FL_ANY;
        val = val * base + c;
	if (!--width) goto putval;
    } while (!IS_EOF(i = scanf_getc(stream, context)));
    if (!(flags & FL_ANY))
        goto err;

  putval:
    if (flags & FL_MINUS) val = -val;
    putval (addr, val, flags);
    return 1;

  err:
    return 0;
}

#ifdef _NEED_IO_BRACKET
static const CHAR *
conv_brk (FILE *stream, scanf_context_t *context, width_t width, void *addr, const CHAR *_fmt, uint16_t flags)
{
#if defined(_NEED_IO_MBTOWIDE) || defined(_NEED_IO_WIDETOMB)
    mbstate_t ps = {0};
#endif
    const CHAR  *fmt;
    UCHAR       f;
    bool        fnegate = false;
    bool        fany = false;

    (void) flags;
    if (*_fmt == '^') {
        fnegate = true;
        _fmt++;
    }
    do {
        WINT    wi = getmb (stream, context, &ps, flags);
        UCHAR   cbelow;
        UCHAR   cabove = 0;
        bool    fmatch = false;
        bool    frange = false;

        /*
         * This is comically inefficient when matching a long string
         * as we re-scan the format string for every input
         * character. However, converting the specified scanset to a
         * more efficient data structure would require an allocation.
         */
        fmt = _fmt;
        for (;;) {
            /*
             * POSIX is very clear that the format string contains
             * bytes, not multi-byte characters. Hence all that we can
             * match are wide characters which happen to fall in a range
             * which can be specified by byte values.
             *
             * glibc appears to parse the format string as multi-byte
             * characters, which makes sense, but appears to violate the
             * spec.
             */
            f = *fmt++;
            if (!f)
                return NULL;
            if (fmt != _fmt + 1) {
                if (f == ']')
                    break;
                if (f == '-' && !frange) {
                    frange = true;
                    continue;
                }
            }
            cbelow = f;
            if (frange) {
                cbelow = cabove;
                frange = false;
            }
            cabove = f;
            if ((WINT) cbelow <= wi && wi <= (WINT) cabove)
                fmatch = true;
        }

        if (IS_WEOF(wi))
            break;

        if (fmatch == fnegate) {
	    scanf_ungetc (wi, stream, context);
            break;
        }

        fany = true;
        putmb(addr, wi, &ps, flags, return NULL);
        width--;
    } while (width);

    if (!fany)
        return NULL;
    putmb(addr, 0, &ps, flags, return NULL);
    return fmt;
}
#endif	/* _NEED_IO_BRACKET */

#if defined(_NEED_IO_FLOAT) || defined(_NEED_IO_DOUBLE)
#include "conv_flt.c"
#endif

static INT skip_spaces (FILE *stream, scanf_context_t *context)
{
    INT i;
    do {
	if (IS_EOF(i = scanf_getc (stream, context)))
	    return i;
    } while (ISSPACE (i));
    scanf_ungetc (i, stream, context);
    return i;
}

#ifdef _NEED_IO_POS_ARGS

typedef struct {
    va_list     ap;
} my_va_list;

static void
skip_to_arg(my_va_list *ap, int target_argno)
{
    int current_argno = 1;

    /*
     * Fortunately, all scanf args are pointers,
     * and so are the same size as void *
     */
    while (current_argno < target_argno) {
        (void) va_arg(ap->ap, void *);
        current_argno++;
    }
}

#endif

/**
   Formatted input.  This function is the heart of the \b scanf family of
   functions.

   Characters are read from \a stream and processed in a way described by
   \a fmt.  Conversion results will be assigned to the parameters passed
   via \a ap.

   The format string \a fmt is scanned for conversion specifications.
   Anything that doesn't comprise a conversion specification is taken as
   text that is matched literally against the input.  White space in the
   format string will match any white space in the data (including none),
   all other characters match only itself. Processing is aborted as soon
   as the data and format string no longer match, or there is an error or
   end-of-file condition on \a stream.

   Most conversions skip leading white space before starting the actual
   conversion.

   Conversions are introduced with the character \b %.  Possible options
   can follow the \b %:

   - a \c * indicating that the conversion should be performed but
     the conversion result is to be discarded; no parameters will
     be processed from \c ap,
   - the character \c h indicating that the argument is a pointer
     to <tt>short int</tt> (rather than <tt>int</tt>),
   - the 2 characters \c hh indicating that the argument is a pointer
     to <tt>char</tt> (rather than <tt>int</tt>).
   - the character \c l indicating that the argument is a pointer
     to <tt>long int</tt> (rather than <tt>int</tt>, for integer
     type conversions), or a pointer to \c double (for floating
     point conversions),

   In addition, a maximal field width may be specified as a nonzero
   positive decimal integer, which will restrict the conversion to at
   most this many characters from the input stream.  This field width is
   limited to at most 255 characters which is also the default value
   (except for the <tt>%c</tt> conversion that defaults to 1).

   The following conversion flags are supported:

   - \c % Matches a literal \c % character.  This is not a conversion.
   - \c d Matches an optionally signed decimal integer; the next
     pointer must be a pointer to \c int.
   - \c i Matches an optionally signed integer; the next pointer must
     be a pointer to \c int.  The integer is read in base 16 if it
     begins with \b 0x or \b 0X, in base 8 if it begins with \b 0, and
     in base 10 otherwise.  Only characters that correspond to the
     base are used.
   - \c o Matches an octal integer; the next pointer must be a pointer to
     <tt>unsigned int</tt>.
   - \c u Matches an optionally signed decimal integer; the next
     pointer must be a pointer to <tt>unsigned int</tt>.
   - \c x Matches an optionally signed hexadecimal integer; the next
     pointer must be a pointer to <tt>unsigned int</tt>.
   - \c f Matches an optionally signed floating-point number; the next
     pointer must be a pointer to \c float.
   - <tt>e, g, F, E, G</tt> Equivalent to \c f.
   - \c s
     Matches a sequence of non-white-space characters; the next pointer
     must be a pointer to \c char, and the array must be large enough to
     accept all the sequence and the terminating \c NUL character.  The
     input string stops at white space or at the maximum field width,
     whichever occurs first.
   - \c c
     Matches a sequence of width count characters (default 1); the next
     pointer must be a pointer to \c char, and there must be enough room
     for all the characters (no terminating \c NUL is added).  The usual
     skip of leading white space is suppressed.  To skip white space
     first, use an explicit space in the format.
   - \c [
     Matches a nonempty sequence of characters from the specified set
     of accepted characters; the next pointer must be a pointer to \c
     char, and there must be enough room for all the characters in the
     string, plus a terminating \c NUL character.  The usual skip of
     leading white space is suppressed.  The string is to be made up
     of characters in (or not in) a particular set; the set is defined
     by the characters between the open bracket \c [ character and a
     close bracket \c ] character.  The set excludes those characters
     if the first character after the open bracket is a circumflex
     \c ^.  To include a close bracket in the set, make it the first
     character after the open bracket or the circumflex; any other
     position will end the set.  The hyphen character \c - is also
     special; when placed between two other characters, it adds all
     intervening characters to the set.  To include a hyphen, make it
     the last character before the final close bracket.  For instance,
     <tt>[^]0-9-]</tt> means the set of <em>everything except close
     bracket, zero through nine, and hyphen</em>.  The string ends
     with the appearance of a character not in the (or, with a
     circumflex, in) set or when the field width runs out.  Note that
     usage of this conversion enlarges the stack expense.
   - \c p
     Matches a pointer value (as printed by <tt>%p</tt> in printf()); the
     next pointer must be a pointer to \c void.
   - \c n
     Nothing is expected; instead, the number of characters consumed
     thus far from the input is stored through the next pointer, which
     must be a pointer to \c int.  This is not a conversion, although it
     can be suppressed with the \c * flag.

     These functions return the number of input items assigned, which can
     be fewer than provided for, or even zero, in the event of a matching
     failure.  Zero indicates that, while there was input available, no
     conversions were assigned; typically this is due to an invalid input
     character, such as an alphabetic character for a <tt>%d</tt>
     conversion.  The value \c EOF is returned if an input failure occurs
     before any conversion such as an end-of-file occurs.  If an error or
     end-of-file occurs after conversion has begun, the number of
     conversions which were successfully completed is returned.

     By default, all the conversions described above are available except
     the floating-point conversions and the width is limited to 255
     characters.  The float-point conversion will be available in the
     extended version provided by the library \c libscanf_flt.a.  Also in
     this case the width is not limited (exactly, it is limited to 65535
     characters).  To link a program against the extended version, use the
     following compiler flags in the link stage:

     \code
     -Wl,-u,vfscanf -lscanf_flt -lm
     \endcode

     A third version is available for environments that are tight on
     space.  In addition to the restrictions of the standard one, this
     version implements no <tt>%[</tt> specification.  This version is
     provided in the library \c libscanf_min.a, and can be requested using
     the following options in the link stage:

     \code
     -Wl,-u,vfscanf -lscanf_min -lm
     \endcode
*/
int vfscanf (FILE * stream, const CHAR *fmt, va_list ap_orig)
{
    unsigned char nconvs;
    UCHAR c;
    width_t width;
    void *addr;
#ifdef _NEED_IO_POS_ARGS
    my_va_list my_ap;
#define ap my_ap.ap
    va_copy(ap, ap_orig);
#else
#define ap ap_orig
#endif
    uint16_t flags;
    INT i;
    scanf_context_t context = SCANF_CONTEXT_INIT;

    nconvs = 0;

    /* Initialization of stream_flags at each pass simplifies the register
       allocation with GCC 3.3 - 4.2.  Only the GCC 4.3 is good to move it
       to the begin.	*/
    while ((c = *fmt++) != 0) {

	if (ISSPACE (c)) {
	    skip_spaces (stream, &context);

	} else if (c != '%'
		   || (c = *fmt++) == '%')
	{
	    /* Ordinary character.	*/
	    if (IS_EOF(i = scanf_getc (stream, &context)))
		goto eof;
	    if ((UCHAR)i != c) {
		scanf_ungetc (i, stream, &context);
		break;
	    }

	} else {
	    flags = 0;

	    if (c == '*') {
		flags = FL_STAR;
		c = *fmt++;
	    }

            for (;;) {
                width = 0;
                while ((c -= '0') < 10) {
                    flags |= FL_WIDTH;
                    width = width * 10 + c;
                    c = *fmt++;
                }
                c += '0';
                if (flags & FL_WIDTH) {
#ifdef _NEED_IO_POS_ARGS
                    if (c == '$') {
                        flags &= ~FL_WIDTH;
                        va_end(ap);
                        va_copy(ap, ap_orig);
                        skip_to_arg(&my_ap, width);
                        c = *fmt++;
                        continue;
                    }
#endif
                    /* C99 says that width must be greater than zero.
                       To simplify program do treat 0 as error in format.	*/
                    if (!width) break;
                } else {
                    width = ~0;
                }
                break;
            }

	    switch (c) {
	      case 'h':
                flags |= FL_SHORT;
		c = *fmt++;
                if (c == 'h') {
                    flags |= FL_CHAR;
                    c = *fmt++;
                }
		break;
	      case 'l':
		flags |= FL_LONG;
		c = *fmt++;
                if (c == 'l') {
                    flags |= FL_LONGLONG;
                    c = *fmt++;
                }
		break;
              case 'L':
                flags |= FL_LONG|FL_LONGLONG;
                c = *fmt++;
                break;
#ifdef _NEED_IO_C99_FORMATS
#ifdef _NEED_IO_LONG_LONG
#define CHECK_LONGLONG(type)                                    \
                else if (sizeof(type) == sizeof(long long))     \
                    flags |= FL_LONGLONG
#else
#define CHECK_LONGLONG(type)
#endif

#define CHECK_INT_SIZE(letter, type)				\
	    case letter:					\
		if (sizeof(type) != sizeof(int)) {		\
		    if (sizeof(type) == sizeof(long))		\
			flags |= FL_LONG;                       \
		    else if (sizeof(type) == sizeof(short))     \
			flags |= FL_SHORT;                      \
                    CHECK_LONGLONG(type);                       \
		}						\
		c = *fmt++;					\
		break;

	    CHECK_INT_SIZE('j', intmax_t);
	    CHECK_INT_SIZE('z', size_t);
	    CHECK_INT_SIZE('t', ptrdiff_t);
#endif
	    }

#ifdef _NEED_IO_PERCENT_B
#define CNV_BASE	"cdinopsuxXb"
#else
#define CNV_BASE	"cdinopsuxX"
#endif

#ifdef _NEED_IO_BRACKET
# define CNV_BRACKET	"["
#else
# define CNV_BRACKET	""
#endif
#if defined(_NEED_IO_FLOAT) || defined(_NEED_IO_DOUBLE)
# define CNV_FLOAT	"aefgAEFG"
#else
# define CNV_FLOAT	""
#endif
#define CNV_LIST	CNV_BASE CNV_BRACKET CNV_FLOAT
	    if (!c || !strchr (CNV_LIST, c))
		break;

	    addr = (flags & FL_STAR) ? 0 : va_arg (ap, void *);

	    if (c == 'n') {
		putval (addr, (unsigned)scanf_len(&context), flags);
		continue;
	    }

	    if (c == 'c') {
		if (!(flags & FL_WIDTH)) width = 1;
#if defined(_NEED_IO_MBTOWIDE) || defined(_NEED_IO_WIDETOMB)
                mbstate_t ps = {0};
#endif
		do {
                    WINT        wi = getmb (stream, &context, &ps, flags);
                    if(IS_WEOF(wi))
                        goto eof;
                    putmb(addr, wi, &ps, flags, goto eof);
		} while (--width);
		c = 1;			/* no matter with smart GCC	*/

#ifdef _NEED_IO_BRACKET
	    } else if (c == '[') {
		fmt = conv_brk (stream, &context, width, addr, fmt, flags);
		c = (fmt != 0);
#endif

	    } else {

                unsigned int base = 0;

		if (IS_EOF(skip_spaces (stream, &context)))
		    goto eof;

		switch (c) {

                case 's': {
#if defined(_NEED_IO_MBTOWIDE) || defined(_NEED_IO_WIDETOMB)
                    mbstate_t ps = {0};
#endif
		    /* Now we have 1 nospace symbol.	*/
		    do {
                        WINT wi = getmb(stream, &context, &ps, flags);
			if (IS_WEOF(wi))
			    break;
			if (ISWSPACE (wi)) {
			    scanf_ungetc (wi, stream, &context);
			    break;
			}
                        putmb(addr, wi, &ps, flags, goto eof);
		    } while (--width);
                    putmb(addr, 0, &ps, flags, goto eof);
		    c = 1;		/* no matter with smart GCC	*/
		    break;
                }

#if defined(_NEED_IO_FLOAT) || defined(_NEED_IO_DOUBLE)
	          case 'p':
                      if (sizeof(void *) > sizeof(int))
                          flags |= FL_LONG;
                      __PICOLIBC_FALLTHROUGH;
		  case 'x':
	          case 'X':
                    base = 16;
		    goto conv_int;

#ifdef _NEED_IO_PERCENT_B
                  case 'b':
                    base = 2;
                    goto conv_int;
#endif

	          case 'd':
		  case 'u':
                    base = 10;
		    goto conv_int;

	          case 'o':
                    base = 8;
		    __PICOLIBC_FALLTHROUGH;
		  case 'i':
		  conv_int:
                    c = conv_int (stream, &context, width, addr, flags, base);
		    break;

	          default:		/* a,A,e,E,f,F,g,G */
		      c = conv_flt (stream, &context, width, addr, flags);
#else
	          case 'd':
		  case 'u':
                    base = 10;
		    goto conv_int;

#ifdef _NEED_IO_PERCENT_B
                  case 'b':
                    base = 2;
                    goto conv_int;
#endif

	          case 'o':
                    base = 8;
		    __PICOLIBC_FALLTHROUGH;
		  case 'i':
		    goto conv_int;

                  case 'p':
                      if (sizeof(void *) > sizeof(int))
                          flags |= FL_LONG;
                      __PICOLIBC_FALLTHROUGH;
		  default:			/* p,x,X	*/
                    base = 16;
		  conv_int:
		    c = conv_int (stream, &context, width, addr, flags, base);
#endif
		}
	    } /* else */

	    if (!c) {
		if (stream->flags & (__SERR | __SEOF))
		    goto eof;
		break;
	    }
	    if (!(flags & FL_STAR)) nconvs += 1;
	} /* else */
    } /* while */
#ifdef _NEED_IO_POS_ARGS
    va_end(ap);
#endif
#ifdef WIDE_CHARS
    if (!IS_EOF(context.unget))
        UNGETC(context.unget, stream);
#endif
    return nconvs;

  eof:
#ifdef _NEED_IO_POS_ARGS
    va_end(ap);
#endif
#ifdef WIDE_CHARS
    if (!IS_EOF(context.unget))
        UNGETC(context.unget, stream);
#endif
    return nconvs ? nconvs : EOF;
}

#undef ap

#if defined(_FORMAT_DEFAULT_DOUBLE) && !defined(vfscanf)
#ifdef _HAVE_ALIAS_ATTRIBUTE
__strong_reference(vfscanf, __d_vfscanf);
#else
int __d_vfscanf (FILE * stream, const char *fmt, va_list ap) { return vfscanf(stream, fmt, ap); }
#endif
#endif
