API tools faq
paste
Advertisement
NaZaRa

vfscanf -- glibc-2.13

NaZaRa
Apr 2nd, 2013
155
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 70.50 KB | None | 0 0
raw download clone embed print report
  1. /* Copyright (C) 1991-2006, 2007, 2010 Free Software Foundation, Inc.
  2.    This file is part of the GNU C Library.
  3.  
  4.    The GNU C Library is free software; you can redistribute it and/or
  5.    modify it under the terms of the GNU Lesser General Public
  6.    License as published by the Free Software Foundation; either
  7.    version 2.1 of the License, or (at your option) any later version.
  8.  
  9.    The GNU C Library is distributed in the hope that it will be useful,
  10.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.    Lesser General Public License for more details.
  13.  
  14.    You should have received a copy of the GNU Lesser General Public
  15.    License along with the GNU C Library; if not, write to the Free
  16.    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  17.    02111-1307 USA.  */
  18.  
  19. #include <assert.h>
  20. #include <errno.h>
  21. #include <limits.h>
  22. #include <ctype.h>
  23. #include <stdarg.h>
  24. #include <stdio.h>
  25. #include <stdint.h>
  26. #include <stdlib.h>
  27. #include <string.h>
  28. #include <wchar.h>
  29. #include <wctype.h>
  30. #include <bits/libc-lock.h>
  31. #include <locale/localeinfo.h>
  32.  
  33. #ifdef  __GNUC__
  34. # define HAVE_LONGLONG
  35. # define LONGLONG   long long
  36. #else
  37. # define LONGLONG   long
  38. #endif
  39.  
  40. /* Determine whether we have to handle `long long' at all.  */
  41. #if LONG_MAX == LONG_LONG_MAX
  42. # define need_longlong  0
  43. #else
  44. # define need_longlong  1
  45. #endif
  46.  
  47. /* Determine whether we have to handle `long'.  */
  48. #if INT_MAX == LONG_MAX
  49. # define need_long  0
  50. #else
  51. # define need_long  1
  52. #endif
  53.  
  54. /* Those are flags in the conversion format. */
  55. #define LONG        0x0001  /* l: long or double */
  56. #define LONGDBL     0x0002  /* L: long long or long double */
  57. #define SHORT       0x0004  /* h: short */
  58. #define SUPPRESS    0x0008  /* *: suppress assignment */
  59. #define POINTER     0x0010  /* weird %p pointer (`fake hex') */
  60. #define NOSKIP      0x0020  /* do not skip blanks */
  61. #define NUMBER_SIGNED   0x0040  /* signed integer */
  62. #define GROUP       0x0080  /* ': group numbers */
  63. #define GNU_MALLOC  0x0100  /* a: malloc strings */
  64. #define CHAR        0x0200  /* hh: char */
  65. #define I18N        0x0400  /* I: use locale's digits */
  66. #define HEXA_FLOAT  0x0800  /* hexadecimal float */
  67. #define READ_POINTER    0x1000  /* this is a pointer value */
  68. #define POSIX_MALLOC    0x2000  /* m: malloc strings */
  69. #define MALLOC      (GNU_MALLOC | POSIX_MALLOC)
  70.  
  71. #include <locale/localeinfo.h>
  72. #include <libioP.h>
  73. #include <libio.h>
  74.  
  75. #undef va_list
  76. #define va_list _IO_va_list
  77.  
  78. #ifdef COMPILE_WSCANF
  79. # define ungetc(c, s)   ((void) (c == WEOF                    \
  80.                  || (--read_in,                   \
  81.                      INTUSE(_IO_sputbackwc) (s, c))))
  82. # define ungetc_not_eof(c, s)   ((void) (--read_in,               \
  83.                      INTUSE(_IO_sputbackwc) (s, c)))
  84. # define inchar()   (c == WEOF ? ((errno = inchar_errno), WEOF)       \
  85.              : ((c = _IO_getwc_unlocked (s)),             \
  86.                 (void) (c != WEOF                     \
  87.                     ? ++read_in                   \
  88.                     : (size_t) (inchar_errno = errno)), c))
  89.  
  90. # define MEMCPY(d, s, n) __wmemcpy (d, s, n)
  91. # define ISSPACE(Ch)      iswspace (Ch)
  92. # define ISDIGIT(Ch)      iswdigit (Ch)
  93. # define ISXDIGIT(Ch)     iswxdigit (Ch)
  94. # define TOLOWER(Ch)      towlower (Ch)
  95. # define ORIENT   if (_IO_fwide (s, 1) != 1) return WEOF
  96. # define __strtoll_internal __wcstoll_internal
  97. # define __strtoull_internal    __wcstoull_internal
  98. # define __strtol_internal  __wcstol_internal
  99. # define __strtoul_internal __wcstoul_internal
  100. # define __strtold_internal __wcstold_internal
  101. # define __strtod_internal  __wcstod_internal
  102. # define __strtof_internal  __wcstof_internal
  103.  
  104. # define L_(Str)    L##Str
  105. # define CHAR_T     wchar_t
  106. # define UCHAR_T    unsigned int
  107. # define WINT_T     wint_t
  108. # undef EOF
  109. # define EOF        WEOF
  110. #else
  111. # define ungetc(c, s)   ((void) ((int) c == EOF                   \
  112.                  || (--read_in,                   \
  113.                      INTUSE(_IO_sputbackc) (s, (unsigned char) c))))
  114. # define ungetc_not_eof(c, s)   ((void) (--read_in,               \
  115.                      INTUSE(_IO_sputbackc) (s, (unsigned char) c)))
  116. # define inchar()   (c == EOF ? ((errno = inchar_errno), EOF)         \
  117.              : ((c = _IO_getc_unlocked (s)),              \
  118.                 (void) (c != EOF                      \
  119.                     ? ++read_in                   \
  120.                     : (size_t) (inchar_errno = errno)), c))
  121. # define MEMCPY(d, s, n) memcpy (d, s, n)
  122. # define ISSPACE(Ch)      __isspace_l (Ch, loc)
  123. # define ISDIGIT(Ch)      __isdigit_l (Ch, loc)
  124. # define ISXDIGIT(Ch)     __isxdigit_l (Ch, loc)
  125. # define TOLOWER(Ch)      __tolower_l ((unsigned char) (Ch), loc)
  126. # define ORIENT   if (_IO_vtable_offset (s) == 0                  \
  127.                   && _IO_fwide (s, -1) != -1)             \
  128.                 return EOF
  129.  
  130. # define L_(Str)    Str
  131. # define CHAR_T     char
  132. # define UCHAR_T    unsigned char
  133. # define WINT_T     int
  134. #endif
  135.  
  136. #define encode_error() do {                           \
  137.               errval = 4;                         \
  138.               __set_errno (EILSEQ);                   \
  139.               goto errout;                        \
  140.             } while (0)
  141. #define conv_error()    do {                              \
  142.               errval = 2;                         \
  143.               goto errout;                        \
  144.             } while (0)
  145. #define input_error()   do {                              \
  146.               errval = 1;                         \
  147.               if (done == 0) done = EOF;                  \
  148.               goto errout;                        \
  149.             } while (0)
  150. #define add_ptr_to_free(ptr)                              \
  151.   do                                          \
  152.     {                                         \
  153.       if (ptrs_to_free == NULL                            \
  154.       || ptrs_to_free->count == (sizeof (ptrs_to_free->ptrs)          \
  155.                      / sizeof (ptrs_to_free->ptrs[0])))       \
  156.     {                                     \
  157.       struct ptrs_to_free *new_ptrs = alloca (sizeof (*ptrs_to_free));    \
  158.       new_ptrs->count = 0;                            \
  159.       new_ptrs->next = ptrs_to_free;                      \
  160.       ptrs_to_free = new_ptrs;                        \
  161.     }                                     \
  162.       ptrs_to_free->ptrs[ptrs_to_free->count++] = (ptr);              \
  163.     }                                         \
  164.   while (0)
  165. #define ARGCHECK(s, format)                           \
  166.   do                                          \
  167.     {                                         \
  168.       /* Check file argument for consistence.  */                 \
  169.       CHECK_FILE (s, EOF);                            \
  170.       if (s->_flags & _IO_NO_READS)                       \
  171.     {                                     \
  172.       __set_errno (EBADF);                            \
  173.       return EOF;                                 \
  174.     }                                     \
  175.       else if (format == NULL)                            \
  176.     {                                     \
  177.       MAYBE_SET_EINVAL;                           \
  178.       return EOF;                                 \
  179.     }                                     \
  180.     } while (0)
  181. #define LOCK_STREAM(S)                                \
  182.   __libc_cleanup_region_start (1, (void (*) (void *)) &_IO_funlockfile, (S)); \
  183.   _IO_flockfile (S)
  184. #define UNLOCK_STREAM(S)                              \
  185.   _IO_funlockfile (S);                                \
  186.   __libc_cleanup_region_end (0)
  187.  
  188. struct ptrs_to_free
  189. {
  190.   size_t count;
  191.   struct ptrs_to_free *next;
  192.   char **ptrs[32];
  193. };
  194.  
  195. /* Read formatted input from S according to the format string
  196.    FORMAT, using the argument list in ARG.
  197.    Return the number of assignments made, or -1 for an input error.  */
  198. #ifdef COMPILE_WSCANF
  199. int
  200. _IO_vfwscanf (_IO_FILE *s, const wchar_t *format, _IO_va_list argptr,
  201.           int *errp)
  202. #else
  203. int
  204. _IO_vfscanf_internal (_IO_FILE *s, const char *format, _IO_va_list argptr,
  205.               int *errp)
  206. #endif
  207. {
  208.   va_list arg;
  209.   register const CHAR_T *f = format;
  210.   register UCHAR_T fc;  /* Current character of the format.  */
  211.   register WINT_T done = 0; /* Assignments done.  */
  212.   register size_t read_in = 0;  /* Chars read in.  */
  213.   register WINT_T c = 0;    /* Last char read.  */
  214.   register int width;       /* Maximum field width.  */
  215.   register int flags;       /* Modifiers for current format element.  */
  216.   int errval = 0;
  217. #ifndef COMPILE_WSCANF
  218.   __locale_t loc = _NL_CURRENT_LOCALE;
  219.   struct __locale_data *const curctype = loc->__locales[LC_CTYPE];
  220. #endif
  221.  
  222.   /* Errno of last failed inchar call.  */
  223.   int inchar_errno = 0;
  224.   /* Status for reading F-P nums.  */
  225.   char got_dot, got_e, negative;
  226.   /* If a [...] is a [^...].  */
  227.   CHAR_T not_in;
  228. #define exp_char not_in
  229.   /* Base for integral numbers.  */
  230.   int base;
  231.   /* Decimal point character.  */
  232. #ifdef COMPILE_WSCANF
  233.   wint_t decimal;
  234. #else
  235.   const char *decimal;
  236. #endif
  237.   /* The thousands character of the current locale.  */
  238. #ifdef COMPILE_WSCANF
  239.   wint_t thousands;
  240. #else
  241.   const char *thousands;
  242. #endif
  243.   struct ptrs_to_free *ptrs_to_free = NULL;
  244.   /* State for the conversions.  */
  245.   mbstate_t state;
  246.   /* Integral holding variables.  */
  247.   union
  248.     {
  249.       long long int q;
  250.       unsigned long long int uq;
  251.       long int l;
  252.       unsigned long int ul;
  253.     } num;
  254.   /* Character-buffer pointer.  */
  255.   char *str = NULL;
  256.   wchar_t *wstr = NULL;
  257.   char **strptr = NULL;
  258.   ssize_t strsize = 0;
  259.   /* We must not react on white spaces immediately because they can
  260.      possibly be matched even if in the input stream no character is
  261.      available anymore.  */
  262.   int skip_space = 0;
  263.   /* Workspace.  */
  264.   CHAR_T *tw;           /* Temporary pointer.  */
  265.   CHAR_T *wp = NULL;        /* Workspace.  */
  266.   size_t wpmax = 0;     /* Maximal size of workspace.  */
  267.   size_t wpsize;        /* Currently used bytes in workspace.  */
  268. #define ADDW(Ch)                                \
  269.   do                                        \
  270.     {                                       \
  271.       if (wpsize == wpmax)                          \
  272.     {                                   \
  273.       CHAR_T *old = wp;                         \
  274.       wpmax = (UCHAR_MAX + 1 > 2 * wpmax ? UCHAR_MAX + 1 : 2 * wpmax);  \
  275.       wp = (CHAR_T *) alloca (wpmax * sizeof (CHAR_T));         \
  276.       if (old != NULL)                          \
  277.         MEMCPY (wp, old, wpsize);                       \
  278.     }                                   \
  279.       wp[wpsize++] = (Ch);                          \
  280.     }                                       \
  281.   while (0)
  282.  
  283. #ifdef __va_copy
  284.   __va_copy (arg, argptr);
  285. #else
  286.   arg = (va_list) argptr;
  287. #endif
  288.  
  289. #ifdef ORIENT
  290.   ORIENT;
  291. #endif
  292.  
  293.   ARGCHECK (s, format);
  294.  
  295.  {
  296. #ifndef COMPILE_WSCANF
  297.    struct __locale_data *const curnumeric = loc->__locales[LC_NUMERIC];
  298. #endif
  299.  
  300.    /* Figure out the decimal point character.  */
  301. #ifdef COMPILE_WSCANF
  302.    decimal = _NL_CURRENT_WORD (LC_NUMERIC, _NL_NUMERIC_DECIMAL_POINT_WC);
  303. #else
  304.    decimal = curnumeric->values[_NL_ITEM_INDEX (DECIMAL_POINT)].string;
  305. #endif
  306.    /* Figure out the thousands separator character.  */
  307. #ifdef COMPILE_WSCANF
  308.    thousands = _NL_CURRENT_WORD (LC_NUMERIC, _NL_NUMERIC_THOUSANDS_SEP_WC);
  309. #else
  310.    thousands = curnumeric->values[_NL_ITEM_INDEX (THOUSANDS_SEP)].string;
  311.    if (*thousands == '\0')
  312.      thousands = NULL;
  313. #endif
  314.  }
  315.  
  316.   /* Lock the stream.  */
  317.   LOCK_STREAM (s);
  318.  
  319.  
  320. #ifndef COMPILE_WSCANF
  321.   /* From now on we use `state' to convert the format string.  */
  322.   memset (&state, '\0', sizeof (state));
  323. #endif
  324.  
  325.   /* Run through the format string.  */
  326.   while (*f != '\0')
  327.     {
  328.       unsigned int argpos;
  329.       /* Extract the next argument, which is of type TYPE.
  330.      For a %N$... spec, this is the Nth argument from the beginning;
  331.      otherwise it is the next argument after the state now in ARG.  */
  332. #ifdef __va_copy
  333. # define ARG(type)  (argpos == 0 ? va_arg (arg, type) :           \
  334.              ({ unsigned int pos = argpos;                \
  335.                 va_list arg;                      \
  336.                 __va_copy (arg, argptr);                  \
  337.                 while (--pos > 0)                     \
  338.                   (void) va_arg (arg, void *);            \
  339.                 va_arg (arg, type);                   \
  340.               }))
  341. #else
  342. # if 0
  343.       /* XXX Possible optimization.  */
  344. #  define ARG(type) (argpos == 0 ? va_arg (arg, type) :           \
  345.              ({ va_list arg = (va_list) argptr;           \
  346.                 arg = (va_list) ((char *) arg             \
  347.                          + (argpos - 1)           \
  348.                          * __va_rounded_size (void *));   \
  349.                 va_arg (arg, type);                   \
  350.              }))
  351. # else
  352. #  define ARG(type) (argpos == 0 ? va_arg (arg, type) :           \
  353.              ({ unsigned int pos = argpos;                \
  354.                 va_list arg = (va_list) argptr;           \
  355.                 while (--pos > 0)                     \
  356.                   (void) va_arg (arg, void *);            \
  357.                 va_arg (arg, type);                   \
  358.               }))
  359. # endif
  360. #endif
  361.  
  362. #ifndef COMPILE_WSCANF
  363.       if (!isascii ((unsigned char) *f))
  364.     {
  365.       /* Non-ASCII, may be a multibyte.  */
  366.       int len = __mbrlen (f, strlen (f), &state);
  367.       if (len > 0)
  368.         {
  369.           do
  370.         {
  371.           c = inchar ();
  372.           if (__builtin_expect (c == EOF, 0))
  373.             input_error ();
  374.           else if (c != (unsigned char) *f++)
  375.             {
  376.               ungetc_not_eof (c, s);
  377.               conv_error ();
  378.             }
  379.         }
  380.           while (--len > 0);
  381.           continue;
  382.         }
  383.     }
  384. #endif
  385.  
  386.       fc = *f++;
  387.       if (fc != '%')
  388.     {
  389.       /* Remember to skip spaces.  */
  390.       if (ISSPACE (fc))
  391.         {
  392.           skip_space = 1;
  393.           continue;
  394.         }
  395.  
  396.       /* Read a character.  */
  397.       c = inchar ();
  398.  
  399.       /* Characters other than format specs must just match.  */
  400.       if (__builtin_expect (c == EOF, 0))
  401.         input_error ();
  402.  
  403.       /* We saw white space char as the last character in the format
  404.          string.  Now it's time to skip all leading white space.  */
  405.       if (skip_space)
  406.         {
  407.           while (ISSPACE (c))
  408.         if (__builtin_expect (inchar () == EOF, 0))
  409.           input_error ();
  410.           skip_space = 0;
  411.         }
  412.  
  413.       if (__builtin_expect (c != fc, 0))
  414.         {
  415.           ungetc (c, s);
  416.           conv_error ();
  417.         }
  418.  
  419.       continue;
  420.     }
  421.  
  422.       /* This is the start of the conversion string. */
  423.       flags = 0;
  424.  
  425.       /* Initialize state of modifiers.  */
  426.       argpos = 0;
  427.  
  428.       /* Prepare temporary buffer.  */
  429.       wpsize = 0;
  430.  
  431.       /* Check for a positional parameter specification.  */
  432.       if (ISDIGIT ((UCHAR_T) *f))
  433.     {
  434.       argpos = (UCHAR_T) *f++ - L_('0');
  435.       while (ISDIGIT ((UCHAR_T) *f))
  436.         argpos = argpos * 10 + ((UCHAR_T) *f++ - L_('0'));
  437.       if (*f == L_('$'))
  438.         ++f;
  439.       else
  440.         {
  441.           /* Oops; that was actually the field width.  */
  442.           width = argpos;
  443.           argpos = 0;
  444.           goto got_width;
  445.         }
  446.     }
  447.  
  448.       /* Check for the assignment-suppressing, the number grouping flag,
  449.      and the signal to use the locale's digit representation.  */
  450.       while (*f == L_('*') || *f == L_('\'') || *f == L_('I'))
  451.     switch (*f++)
  452.       {
  453.       case L_('*'):
  454.         flags |= SUPPRESS;
  455.         break;
  456.       case L_('\''):
  457. #ifdef COMPILE_WSCANF
  458.         if (thousands != L'\0')
  459. #else
  460.         if (thousands != NULL)
  461. #endif
  462.           flags |= GROUP;
  463.         break;
  464.       case L_('I'):
  465.         flags |= I18N;
  466.         break;
  467.       }
  468.  
  469.       /* Find the maximum field width.  */
  470.       width = 0;
  471.       while (ISDIGIT ((UCHAR_T) *f))
  472.     {
  473.       width *= 10;
  474.       width += (UCHAR_T) *f++ - L_('0');
  475.     }
  476.     got_width:
  477.       if (width == 0)
  478.     width = -1;
  479.  
  480.       /* Check for type modifiers.  */
  481.       switch (*f++)
  482.     {
  483.     case L_('h'):
  484.       /* ints are short ints or chars.  */
  485.       if (*f == L_('h'))
  486.         {
  487.           ++f;
  488.           flags |= CHAR;
  489.         }
  490.       else
  491.         flags |= SHORT;
  492.       break;
  493.     case L_('l'):
  494.       if (*f == L_('l'))
  495.         {
  496.           /* A double `l' is equivalent to an `L'.  */
  497.           ++f;
  498.           flags |= LONGDBL | LONG;
  499.         }
  500.       else
  501.         /* ints are long ints.  */
  502.         flags |= LONG;
  503.       break;
  504.     case L_('q'):
  505.     case L_('L'):
  506.       /* doubles are long doubles, and ints are long long ints.  */
  507.       flags |= LONGDBL | LONG;
  508.       break;
  509.     case L_('a'):
  510.       /* The `a' is used as a flag only if followed by `s', `S' or
  511.          `['.  */
  512.       if (*f != L_('s') && *f != L_('S') && *f != L_('['))
  513.         {
  514.           --f;
  515.           break;
  516.         }
  517.       /* In __isoc99_*scanf %as, %aS and %a[ extension is not
  518.          supported at all.  */
  519.       if (s->_flags2 & _IO_FLAGS2_SCANF_STD)
  520.         {
  521.           --f;
  522.           break;
  523.         }
  524.       /* String conversions (%s, %[) take a `char **'
  525.          arg and fill it in with a malloc'd pointer.  */
  526.       flags |= GNU_MALLOC;
  527.       break;
  528.     case L_('m'):
  529.       flags |= POSIX_MALLOC;
  530.       if (*f == L_('l'))
  531.         {
  532.           ++f;
  533.           flags |= LONG;
  534.         }
  535.       break;
  536.     case L_('z'):
  537.       if (need_longlong && sizeof (size_t) > sizeof (unsigned long int))
  538.         flags |= LONGDBL;
  539.       else if (sizeof (size_t) > sizeof (unsigned int))
  540.         flags |= LONG;
  541.       break;
  542.     case L_('j'):
  543.       if (need_longlong && sizeof (uintmax_t) > sizeof (unsigned long int))
  544.         flags |= LONGDBL;
  545.       else if (sizeof (uintmax_t) > sizeof (unsigned int))
  546.         flags |= LONG;
  547.       break;
  548.     case L_('t'):
  549.       if (need_longlong && sizeof (ptrdiff_t) > sizeof (long int))
  550.         flags |= LONGDBL;
  551.       else if (sizeof (ptrdiff_t) > sizeof (int))
  552.         flags |= LONG;
  553.       break;
  554.     default:
  555.       /* Not a recognized modifier.  Backup.  */
  556.       --f;
  557.       break;
  558.     }
  559.  
  560.       /* End of the format string?  */
  561.       if (__builtin_expect (*f == L_('\0'), 0))
  562.     conv_error ();
  563.  
  564.       /* Find the conversion specifier.  */
  565.       fc = *f++;
  566.       if (skip_space || (fc != L_('[') && fc != L_('c')
  567.              && fc != L_('C') && fc != L_('n')))
  568.     {
  569.       /* Eat whitespace.  */
  570.       int save_errno = errno;
  571.       __set_errno (0);
  572.       do
  573.         /* We add the additional test for EOF here since otherwise
  574.            inchar will restore the old errno value which might be
  575.            EINTR but does not indicate an interrupt since nothing
  576.            was read at this time.  */
  577.         if (__builtin_expect ((c == EOF || inchar () == EOF)
  578.                   && errno == EINTR, 0))
  579.           input_error ();
  580.       while (ISSPACE (c));
  581.       __set_errno (save_errno);
  582.       ungetc (c, s);
  583.       skip_space = 0;
  584.     }
  585.  
  586.       switch (fc)
  587.     {
  588.     case L_('%'):   /* Must match a literal '%'.  */
  589.       c = inchar ();
  590.       if (__builtin_expect (c == EOF, 0))
  591.         input_error ();
  592.       if (__builtin_expect (c != fc, 0))
  593.         {
  594.           ungetc_not_eof (c, s);
  595.           conv_error ();
  596.         }
  597.       break;
  598.  
  599.     case L_('n'):   /* Answer number of assignments done.  */
  600.       /* Corrigendum 1 to ISO C 1990 describes the allowed flags
  601.          with the 'n' conversion specifier.  */
  602.       if (!(flags & SUPPRESS))
  603.         {
  604.           /* Don't count the read-ahead.  */
  605.           if (need_longlong && (flags & LONGDBL))
  606.         *ARG (long long int *) = read_in;
  607.           else if (need_long && (flags & LONG))
  608.         *ARG (long int *) = read_in;
  609.           else if (flags & SHORT)
  610.         *ARG (short int *) = read_in;
  611.           else if (!(flags & CHAR))
  612.         *ARG (int *) = read_in;
  613.           else
  614.         *ARG (char *) = read_in;
  615.  
  616. #ifdef NO_BUG_IN_ISO_C_CORRIGENDUM_1
  617.           /* We have a severe problem here.  The ISO C standard
  618.          contradicts itself in explaining the effect of the %n
  619.          format in `scanf'.  While in ISO C:1990 and the ISO C
  620.          Amendement 1:1995 the result is described as
  621.  
  622.            Execution of a %n directive does not effect the
  623.            assignment count returned at the completion of
  624.            execution of the f(w)scanf function.
  625.  
  626.          in ISO C Corrigendum 1:1994 the following was added:
  627.  
  628.            Subclause 7.9.6.2
  629.            Add the following fourth example:
  630.              In:
  631.                #include <stdio.h>
  632.                int d1, d2, n1, n2, i;
  633.                i = sscanf("123", "%d%n%n%d", &d1, &n1, &n2, &d2);
  634.              the value 123 is assigned to d1 and the value3 to n1.
  635.              Because %n can never get an input failure the value
  636.              of 3 is also assigned to n2.  The value of d2 is not
  637.              affected.  The value 3 is assigned to i.
  638.  
  639.          We go for now with the historically correct code from ISO C,
  640.          i.e., we don't count the %n assignments.  When it ever
  641.          should proof to be wrong just remove the #ifdef above.  */
  642.           ++done;
  643. #endif
  644.         }
  645.       break;
  646.  
  647.     case L_('c'):   /* Match characters.  */
  648.       if ((flags & LONG) == 0)
  649.         {
  650.           if (width == -1)
  651.         width = 1;
  652.  
  653. #define STRING_ARG(Str, Type, Width)                          \
  654.           do if (!(flags & SUPPRESS))                     \
  655.         {                                 \
  656.           if (flags & MALLOC)                         \
  657.             {                                 \
  658.               /* The string is to be stored in a malloc'd buffer.  */ \
  659.               /* For %mS using char ** is actually wrong, but         \
  660.              shouldn't make a difference on any arch glibc        \
  661.              supports and would unnecessarily complicate          \
  662.              things. */                       \
  663.               strptr = ARG (char **);                     \
  664.               if (strptr == NULL)                     \
  665.             conv_error ();                        \
  666.               /* Allocate an initial buffer.  */              \
  667.               strsize = Width;                        \
  668.               *strptr = (char *) malloc (strsize * sizeof (Type));    \
  669.               Str = (Type *) *strptr;                     \
  670.               if (Str != NULL)                        \
  671.             add_ptr_to_free (strptr);                 \
  672.               else if (flags & POSIX_MALLOC)                  \
  673.             goto reteof;                          \
  674.             }                                 \
  675.           else                                \
  676.             Str = ARG (Type *);                       \
  677.           if (Str == NULL)                        \
  678.             conv_error ();                        \
  679.         } while (0)
  680. #ifdef COMPILE_WSCANF
  681.           STRING_ARG (str, char, 100);
  682. #else
  683.           STRING_ARG (str, char, (width > 1024 ? 1024 : width));
  684. #endif
  685.  
  686.           c = inchar ();
  687.           if (__builtin_expect (c == EOF, 0))
  688.         input_error ();
  689.  
  690. #ifdef COMPILE_WSCANF
  691.           /* We have to convert the wide character(s) into multibyte
  692.          characters and store the result.  */
  693.           memset (&state, '\0', sizeof (state));
  694.  
  695.           do
  696.         {
  697.           size_t n;
  698.  
  699.           if (!(flags & SUPPRESS) && (flags & POSIX_MALLOC)
  700.               && str + MB_CUR_MAX >= *strptr + strsize)
  701.             {
  702.               /* We have to enlarge the buffer if the `m' flag
  703.              was given.  */
  704.               size_t strleng = str - *strptr;
  705.               char *newstr;
  706.  
  707.               newstr = (char *) realloc (*strptr, strsize * 2);
  708.               if (newstr == NULL)
  709.             {
  710.               /* Can't allocate that much.  Last-ditch effort.  */
  711.               newstr = (char *) realloc (*strptr,
  712.                              strleng + MB_CUR_MAX);
  713.               if (newstr == NULL)
  714.                 /* c can't have `a' flag, only `m'.  */
  715.                 goto reteof;
  716.               else
  717.                 {
  718.                   *strptr = newstr;
  719.                   str = newstr + strleng;
  720.                   strsize = strleng + MB_CUR_MAX;
  721.                 }
  722.             }
  723.               else
  724.             {
  725.               *strptr = newstr;
  726.               str = newstr + strleng;
  727.               strsize *= 2;
  728.             }
  729.             }
  730.  
  731.           n = __wcrtomb (!(flags & SUPPRESS) ? str : NULL, c, &state);
  732.           if (__builtin_expect (n == (size_t) -1, 0))
  733.             /* No valid wide character.  */
  734.             input_error ();
  735.  
  736.           /* Increment the output pointer.  Even if we don't
  737.              write anything.  */
  738.           str += n;
  739.         }
  740.           while (--width > 0 && inchar () != EOF);
  741. #else
  742.           if (!(flags & SUPPRESS))
  743.         {
  744.           do
  745.             {
  746.               if ((flags & MALLOC)
  747.               && (char *) str == *strptr + strsize)
  748.             {
  749.               /* Enlarge the buffer.  */
  750.               size_t newsize
  751.                 = strsize
  752.                   + (strsize >= width ? width - 1 : strsize);
  753.  
  754.               str = (char *) realloc (*strptr, newsize);
  755.               if (str == NULL)
  756.                 {
  757.                   /* Can't allocate that much.  Last-ditch
  758.                  effort.  */
  759.                   str = (char *) realloc (*strptr, strsize + 1);
  760.                   if (str == NULL)
  761.                 /* c can't have `a' flag, only `m'.  */
  762.                 goto reteof;
  763.                   else
  764.                 {
  765.                   *strptr = (char *) str;
  766.                   str += strsize;
  767.                   ++strsize;
  768.                 }
  769.                 }
  770.               else
  771.                 {
  772.                   *strptr = (char *) str;
  773.                   str += strsize;
  774.                   strsize = newsize;
  775.                 }
  776.             }
  777.               *str++ = c;
  778.             }
  779.           while (--width > 0 && inchar () != EOF);
  780.         }
  781.           else
  782.         while (--width > 0 && inchar () != EOF);
  783. #endif
  784.  
  785.           if (!(flags & SUPPRESS))
  786.         {
  787.           if ((flags & MALLOC) && str - *strptr != strsize)
  788.             {
  789.               char *cp = (char *) realloc (*strptr, str - *strptr);
  790.               if (cp != NULL)
  791.             *strptr = cp;
  792.             }
  793.           strptr = NULL;
  794.           ++done;
  795.         }
  796.  
  797.           break;
  798.         }
  799.       /* FALLTHROUGH */
  800.     case L_('C'):
  801.       if (width == -1)
  802.         width = 1;
  803.  
  804.       STRING_ARG (wstr, wchar_t, (width > 1024 ? 1024 : width));
  805.  
  806.       c = inchar ();
  807.       if (__builtin_expect (c == EOF, 0))
  808.         input_error ();
  809.  
  810. #ifdef COMPILE_WSCANF
  811.       /* Just store the incoming wide characters.  */
  812.       if (!(flags & SUPPRESS))
  813.         {
  814.           do
  815.         {
  816.           if ((flags & MALLOC)
  817.               && wstr == (wchar_t *) *strptr + strsize)
  818.             {
  819.               size_t newsize
  820.             = strsize + (strsize > width ? width - 1 : strsize);
  821.               /* Enlarge the buffer.  */
  822.               wstr = (wchar_t *) realloc (*strptr,
  823.                           newsize * sizeof (wchar_t));
  824.               if (wstr == NULL)
  825.             {
  826.               /* Can't allocate that much.  Last-ditch effort.  */
  827.               wstr = (wchar_t *) realloc (*strptr,
  828.                               (strsize + 1)
  829.                               * sizeof (wchar_t));
  830.               if (wstr == NULL)
  831.                 /* C or lc can't have `a' flag, only `m' flag.  */
  832.                 goto reteof;
  833.               else
  834.                 {
  835.                   *strptr = (char *) wstr;
  836.                   wstr += strsize;
  837.                   ++strsize;
  838.                 }
  839.             }
  840.               else
  841.             {
  842.               *strptr = (char *) wstr;
  843.               wstr += strsize;
  844.               strsize = newsize;
  845.             }
  846.             }
  847.           *wstr++ = c;
  848.         }
  849.           while (--width > 0 && inchar () != EOF);
  850.         }
  851.       else
  852.         while (--width > 0 && inchar () != EOF);
  853. #else
  854.       {
  855.         /* We have to convert the multibyte input sequence to wide
  856.            characters.  */
  857.         char buf[1];
  858.         mbstate_t cstate;
  859.  
  860.         memset (&cstate, '\0', sizeof (cstate));
  861.  
  862.         do
  863.           {
  864.         /* This is what we present the mbrtowc function first.  */
  865.         buf[0] = c;
  866.  
  867.         if (!(flags & SUPPRESS) && (flags & MALLOC)
  868.             && wstr == (wchar_t *) *strptr + strsize)
  869.           {
  870.             size_t newsize
  871.               = strsize + (strsize > width ? width - 1 : strsize);
  872.             /* Enlarge the buffer.  */
  873.             wstr = (wchar_t *) realloc (*strptr,
  874.                         newsize * sizeof (wchar_t));
  875.             if (wstr == NULL)
  876.               {
  877.             /* Can't allocate that much.  Last-ditch effort.  */
  878.             wstr = (wchar_t *) realloc (*strptr,
  879.                             ((strsize + 1)
  880.                              * sizeof (wchar_t)));
  881.             if (wstr == NULL)
  882.               /* C or lc can't have `a' flag, only `m' flag.  */
  883.               goto reteof;
  884.             else
  885.               {
  886.                 *strptr = (char *) wstr;
  887.                 wstr += strsize;
  888.                 ++strsize;
  889.               }
  890.               }
  891.             else
  892.               {
  893.             *strptr = (char *) wstr;
  894.             wstr += strsize;
  895.             strsize = newsize;
  896.               }
  897.           }
  898.  
  899.         while (1)
  900.           {
  901.             size_t n;
  902.  
  903.             n = __mbrtowc (!(flags & SUPPRESS) ? wstr : NULL,
  904.                    buf, 1, &cstate);
  905.  
  906.             if (n == (size_t) -2)
  907.               {
  908.             /* Possibly correct character, just not enough
  909.                input.  */
  910.             if (__builtin_expect (inchar () == EOF, 0))
  911.               encode_error ();
  912.  
  913.             buf[0] = c;
  914.             continue;
  915.               }
  916.  
  917.             if (__builtin_expect (n != 1, 0))
  918.               encode_error ();
  919.  
  920.             /* We have a match.  */
  921.             break;
  922.           }
  923.  
  924.         /* Advance the result pointer.  */
  925.         ++wstr;
  926.           }
  927.         while (--width > 0 && inchar () != EOF);
  928.       }
  929. #endif
  930.  
  931.       if (!(flags & SUPPRESS))
  932.         {
  933.           if ((flags & MALLOC) && wstr - (wchar_t *) *strptr != strsize)
  934.         {
  935.           wchar_t *cp = (wchar_t *) realloc (*strptr,
  936.                              ((wstr
  937.                                - (wchar_t *) *strptr)
  938.                               * sizeof (wchar_t)));
  939.           if (cp != NULL)
  940.             *strptr = (char *) cp;
  941.         }
  942.           strptr = NULL;
  943.  
  944.           ++done;
  945.         }
  946.  
  947.       break;
  948.  
  949.     case L_('s'):       /* Read a string.  */
  950.       if (!(flags & LONG))
  951.         {
  952.           STRING_ARG (str, char, 100);
  953.  
  954.           c = inchar ();
  955.           if (__builtin_expect (c == EOF, 0))
  956.         input_error ();
  957.  
  958. #ifdef COMPILE_WSCANF
  959.           memset (&state, '\0', sizeof (state));
  960. #endif
  961.  
  962.           do
  963.         {
  964.           if (ISSPACE (c))
  965.             {
  966.               ungetc_not_eof (c, s);
  967.               break;
  968.             }
  969.  
  970. #ifdef COMPILE_WSCANF
  971.           /* This is quite complicated.  We have to convert the
  972.              wide characters into multibyte characters and then
  973.              store them.  */
  974.           {
  975.             size_t n;
  976.  
  977.             if (!(flags & SUPPRESS) && (flags & MALLOC)
  978.             && str + MB_CUR_MAX >= *strptr + strsize)
  979.               {
  980.             /* We have to enlarge the buffer if the `a' or `m'
  981.                flag was given.  */
  982.             size_t strleng = str - *strptr;
  983.             char *newstr;
  984.  
  985.             newstr = (char *) realloc (*strptr, strsize * 2);
  986.             if (newstr == NULL)
  987.               {
  988.                 /* Can't allocate that much.  Last-ditch
  989.                    effort.  */
  990.                 newstr = (char *) realloc (*strptr,
  991.                                strleng + MB_CUR_MAX);
  992.                 if (newstr == NULL)
  993.                   {
  994.                 if (flags & POSIX_MALLOC)
  995.                   goto reteof;
  996.                 /* We lose.  Oh well.  Terminate the
  997.                    string and stop converting,
  998.                    so at least we don't skip any input.  */
  999.                 ((char *) (*strptr))[strleng] = '\0';
  1000.                 strptr = NULL;
  1001.                 ++done;
  1002.                 conv_error ();
  1003.                   }
  1004.                 else
  1005.                   {
  1006.                 *strptr = newstr;
  1007.                 str = newstr + strleng;
  1008.                 strsize = strleng + MB_CUR_MAX;
  1009.                   }
  1010.               }
  1011.             else
  1012.               {
  1013.                 *strptr = newstr;
  1014.                 str = newstr + strleng;
  1015.                 strsize *= 2;
  1016.               }
  1017.               }
  1018.  
  1019.             n = __wcrtomb (!(flags & SUPPRESS) ? str : NULL, c,
  1020.                    &state);
  1021.             if (__builtin_expect (n == (size_t) -1, 0))
  1022.               encode_error ();
  1023.  
  1024.             assert (n <= MB_CUR_MAX);
  1025.             str += n;
  1026.           }
  1027. #else
  1028.           /* This is easy.  */
  1029.           if (!(flags & SUPPRESS))
  1030.             {
  1031.               *str++ = c;
  1032.               if ((flags & MALLOC)
  1033.               && (char *) str == *strptr + strsize)
  1034.             {
  1035.               /* Enlarge the buffer.  */
  1036.               str = (char *) realloc (*strptr, 2 * strsize);
  1037.               if (str == NULL)
  1038.                 {
  1039.                   /* Can't allocate that much.  Last-ditch
  1040.                  effort.  */
  1041.                   str = (char *) realloc (*strptr, strsize + 1);
  1042.                   if (str == NULL)
  1043.                 {
  1044.                   if (flags & POSIX_MALLOC)
  1045.                     goto reteof;
  1046.                   /* We lose.  Oh well.  Terminate the
  1047.                      string and stop converting,
  1048.                      so at least we don't skip any input.  */
  1049.                   ((char *) (*strptr))[strsize - 1] = '\0';
  1050.                   strptr = NULL;
  1051.                   ++done;
  1052.                   conv_error ();
  1053.                 }
  1054.                   else
  1055.                 {
  1056.                   *strptr = (char *) str;
  1057.                   str += strsize;
  1058.                   ++strsize;
  1059.                 }
  1060.                 }
  1061.               else
  1062.                 {
  1063.                   *strptr = (char *) str;
  1064.                   str += strsize;
  1065.                   strsize *= 2;
  1066.                 }
  1067.             }
  1068.             }
  1069. #endif
  1070.         }
  1071.           while ((width <= 0 || --width > 0) && inchar () != EOF);
  1072.  
  1073.           if (!(flags & SUPPRESS))
  1074.         {
  1075. #ifdef COMPILE_WSCANF
  1076.           /* We have to emit the code to get into the initial
  1077.              state.  */
  1078.           char buf[MB_LEN_MAX];
  1079.           size_t n = __wcrtomb (buf, L'\0', &state);
  1080.           if (n > 0 && (flags & MALLOC)
  1081.               && str + n >= *strptr + strsize)
  1082.             {
  1083.               /* Enlarge the buffer.  */
  1084.               size_t strleng = str - *strptr;
  1085.               char *newstr;
  1086.  
  1087.               newstr = (char *) realloc (*strptr, strleng + n + 1);
  1088.               if (newstr == NULL)
  1089.             {
  1090.               if (flags & POSIX_MALLOC)
  1091.                 goto reteof;
  1092.               /* We lose.  Oh well.  Terminate the string
  1093.                  and stop converting, so at least we don't
  1094.                  skip any input.  */
  1095.               ((char *) (*strptr))[strleng] = '\0';
  1096.               strptr = NULL;
  1097.               ++done;
  1098.               conv_error ();
  1099.             }
  1100.               else
  1101.             {
  1102.               *strptr = newstr;
  1103.               str = newstr + strleng;
  1104.               strsize = strleng + n + 1;
  1105.             }
  1106.             }
  1107.  
  1108.           str = __mempcpy (str, buf, n);
  1109. #endif
  1110.           *str++ = '\0';
  1111.  
  1112.           if ((flags & MALLOC) && str - *strptr != strsize)
  1113.             {
  1114.               char *cp = (char *) realloc (*strptr, str - *strptr);
  1115.               if (cp != NULL)
  1116.             *strptr = cp;
  1117.             }
  1118.           strptr = NULL;
  1119.  
  1120.           ++done;
  1121.         }
  1122.           break;
  1123.         }
  1124.       /* FALLTHROUGH */
  1125.  
  1126.     case L_('S'):
  1127.       {
  1128. #ifndef COMPILE_WSCANF
  1129.         mbstate_t cstate;
  1130. #endif
  1131.  
  1132.         /* Wide character string.  */
  1133.         STRING_ARG (wstr, wchar_t, 100);
  1134.  
  1135.         c = inchar ();
  1136.         if (__builtin_expect (c == EOF,  0))
  1137.           input_error ();
  1138.  
  1139. #ifndef COMPILE_WSCANF
  1140.         memset (&cstate, '\0', sizeof (cstate));
  1141. #endif
  1142.  
  1143.         do
  1144.           {
  1145.         if (ISSPACE (c))
  1146.           {
  1147.             ungetc_not_eof (c, s);
  1148.             break;
  1149.           }
  1150.  
  1151. #ifdef COMPILE_WSCANF
  1152.         /* This is easy.  */
  1153.         if (!(flags & SUPPRESS))
  1154.           {
  1155.             *wstr++ = c;
  1156.             if ((flags & MALLOC)
  1157.             && wstr == (wchar_t *) *strptr + strsize)
  1158.               {
  1159.             /* Enlarge the buffer.  */
  1160.             wstr = (wchar_t *) realloc (*strptr,
  1161.                             (2 * strsize)
  1162.                             * sizeof (wchar_t));
  1163.             if (wstr == NULL)
  1164.               {
  1165.                 /* Can't allocate that much.  Last-ditch
  1166.                    effort.  */
  1167.                 wstr = (wchar_t *) realloc (*strptr,
  1168.                             (strsize + 1)
  1169.                             * sizeof (wchar_t));
  1170.                 if (wstr == NULL)
  1171.                   {
  1172.                 if (flags & POSIX_MALLOC)
  1173.                   goto reteof;
  1174.                 /* We lose.  Oh well.  Terminate the string
  1175.                    and stop converting, so at least we don't
  1176.                    skip any input.  */
  1177.                 ((wchar_t *) (*strptr))[strsize - 1] = L'\0';
  1178.                 strptr = NULL;
  1179.                 ++done;
  1180.                 conv_error ();
  1181.                   }
  1182.                 else
  1183.                   {
  1184.                 *strptr = (char *) wstr;
  1185.                 wstr += strsize;
  1186.                 ++strsize;
  1187.                   }
  1188.               }
  1189.             else
  1190.               {
  1191.                 *strptr = (char *) wstr;
  1192.                 wstr += strsize;
  1193.                 strsize *= 2;
  1194.               }
  1195.               }
  1196.           }
  1197. #else
  1198.         {
  1199.           char buf[1];
  1200.  
  1201.           buf[0] = c;
  1202.  
  1203.           while (1)
  1204.             {
  1205.               size_t n;
  1206.  
  1207.               n = __mbrtowc (!(flags & SUPPRESS) ? wstr : NULL,
  1208.                      buf, 1, &cstate);
  1209.  
  1210.               if (n == (size_t) -2)
  1211.             {
  1212.               /* Possibly correct character, just not enough
  1213.                  input.  */
  1214.               if (__builtin_expect (inchar () == EOF, 0))
  1215.                 encode_error ();
  1216.  
  1217.               buf[0] = c;
  1218.               continue;
  1219.             }
  1220.  
  1221.               if (__builtin_expect (n != 1, 0))
  1222.             encode_error ();
  1223.  
  1224.               /* We have a match.  */
  1225.               ++wstr;
  1226.               break;
  1227.             }
  1228.  
  1229.           if (!(flags & SUPPRESS) && (flags & MALLOC)
  1230.               && wstr == (wchar_t *) *strptr + strsize)
  1231.             {
  1232.               /* Enlarge the buffer.  */
  1233.               wstr = (wchar_t *) realloc (*strptr,
  1234.                           (2 * strsize
  1235.                            * sizeof (wchar_t)));
  1236.               if (wstr == NULL)
  1237.             {
  1238.               /* Can't allocate that much.  Last-ditch effort.  */
  1239.               wstr = (wchar_t *) realloc (*strptr,
  1240.                               ((strsize + 1)
  1241.                                * sizeof (wchar_t)));
  1242.               if (wstr == NULL)
  1243.                 {
  1244.                   if (flags & POSIX_MALLOC)
  1245.                 goto reteof;
  1246.                   /* We lose.  Oh well.  Terminate the
  1247.                  string and stop converting, so at
  1248.                  least we don't skip any input.  */
  1249.                   ((wchar_t *) (*strptr))[strsize - 1] = L'\0';
  1250.                   strptr = NULL;
  1251.                   ++done;
  1252.                   conv_error ();
  1253.                 }
  1254.               else
  1255.                 {
  1256.                   *strptr = (char *) wstr;
  1257.                   wstr += strsize;
  1258.                   ++strsize;
  1259.                 }
  1260.             }
  1261.               else
  1262.             {
  1263.               *strptr = (char *) wstr;
  1264.               wstr += strsize;
  1265.               strsize *= 2;
  1266.             }
  1267.             }
  1268.         }
  1269. #endif
  1270.           }
  1271.         while ((width <= 0 || --width > 0) && inchar () != EOF);
  1272.  
  1273.         if (!(flags & SUPPRESS))
  1274.           {
  1275.         *wstr++ = L'\0';
  1276.  
  1277.         if ((flags & MALLOC) && wstr - (wchar_t *) *strptr != strsize)
  1278.           {
  1279.             wchar_t *cp = (wchar_t *) realloc (*strptr,
  1280.                                ((wstr
  1281.                              - (wchar_t *) *strptr)
  1282.                             * sizeof(wchar_t)));
  1283.             if (cp != NULL)
  1284.               *strptr = (char *) cp;
  1285.           }
  1286.         strptr = NULL;
  1287.  
  1288.         ++done;
  1289.           }
  1290.       }
  1291.       break;
  1292.  
  1293.     case L_('x'):   /* Hexadecimal integer.  */
  1294.     case L_('X'):   /* Ditto.  */
  1295.       base = 16;
  1296.       goto number;
  1297.  
  1298.     case L_('o'):   /* Octal integer.  */
  1299.       base = 8;
  1300.       goto number;
  1301.  
  1302.     case L_('u'):   /* Unsigned decimal integer.  */
  1303.       base = 10;
  1304.       goto number;
  1305.  
  1306.     case L_('d'):   /* Signed decimal integer.  */
  1307.       base = 10;
  1308.       flags |= NUMBER_SIGNED;
  1309.       goto number;
  1310.  
  1311.     case L_('i'):   /* Generic number.  */
  1312.       base = 0;
  1313.       flags |= NUMBER_SIGNED;
  1314.  
  1315.     number:
  1316.       c = inchar ();
  1317.       if (__builtin_expect (c == EOF, 0))
  1318.         input_error ();
  1319.  
  1320.       /* Check for a sign.  */
  1321.       if (c == L_('-') || c == L_('+'))
  1322.         {
  1323.           ADDW (c);
  1324.           if (width > 0)
  1325.         --width;
  1326.           c = inchar ();
  1327.         }
  1328.  
  1329.       /* Look for a leading indication of base.  */
  1330.       if (width != 0 && c == L_('0'))
  1331.         {
  1332.           if (width > 0)
  1333.         --width;
  1334.  
  1335.           ADDW (c);
  1336.           c = inchar ();
  1337.  
  1338.           if (width != 0 && TOLOWER (c) == L_('x'))
  1339.         {
  1340.           if (base == 0)
  1341.             base = 16;
  1342.           if (base == 16)
  1343.             {
  1344.               if (width > 0)
  1345.             --width;
  1346.               c = inchar ();
  1347.             }
  1348.         }
  1349.           else if (base == 0)
  1350.         base = 8;
  1351.         }
  1352.  
  1353.       if (base == 0)
  1354.         base = 10;
  1355.  
  1356.       if (base == 10 && __builtin_expect ((flags & I18N) != 0, 0))
  1357.         {
  1358.           int from_level;
  1359.           int to_level;
  1360.           int level;
  1361. #ifdef COMPILE_WSCANF
  1362.           const wchar_t *wcdigits[10];
  1363.           const wchar_t *wcdigits_extended[10];
  1364. #else
  1365.           const char *mbdigits[10];
  1366.           const char *mbdigits_extended[10];
  1367. #endif
  1368.           /*  "to_inpunct" is a map from ASCII digits to their
  1369.           equivalent in locale. This is defined for locales
  1370.           which use an extra digits set.  */
  1371.           wctrans_t map = __wctrans ("to_inpunct");
  1372.           int n;
  1373.  
  1374.           from_level = 0;
  1375. #ifdef COMPILE_WSCANF
  1376.           to_level = _NL_CURRENT_WORD (LC_CTYPE,
  1377.                        _NL_CTYPE_INDIGITS_WC_LEN) - 1;
  1378. #else
  1379.           to_level = (uint32_t) curctype->values[_NL_ITEM_INDEX (_NL_CTYPE_INDIGITS_MB_LEN)].word - 1;
  1380. #endif
  1381.  
  1382.           /* Get the alternative digit forms if there are any.  */
  1383.           if (__builtin_expect (map != NULL, 0))
  1384.         {
  1385.           /*  Adding new level for extra digits set in locale file.  */
  1386.           ++to_level;
  1387.  
  1388.           for (n = 0; n < 10; ++n)
  1389.             {
  1390. #ifdef COMPILE_WSCANF
  1391.               wcdigits[n] = (const wchar_t *)
  1392.             _NL_CURRENT (LC_CTYPE, _NL_CTYPE_INDIGITS0_WC + n);
  1393.  
  1394.               wchar_t *wc_extended = (wchar_t *)
  1395.             alloca ((to_level + 2) * sizeof (wchar_t));
  1396.               __wmemcpy (wc_extended, wcdigits[n], to_level);
  1397.               wc_extended[to_level] = __towctrans (L'0' + n, map);
  1398.               wc_extended[to_level + 1] = '\0';
  1399.               wcdigits_extended[n] = wc_extended;
  1400. #else
  1401.               mbdigits[n]
  1402.             = curctype->values[_NL_CTYPE_INDIGITS0_MB + n].string;
  1403.  
  1404.               /*  Get the equivalent wide char in map.  */
  1405.               wint_t extra_wcdigit = __towctrans (L'0' + n, map);
  1406.  
  1407.               /*  Convert it to multibyte representation.  */
  1408.               mbstate_t state;
  1409.               memset (&state, '\0', sizeof (state));
  1410.  
  1411.               char extra_mbdigit[MB_LEN_MAX];
  1412.               size_t mblen
  1413.             = __wcrtomb (extra_mbdigit, extra_wcdigit, &state);
  1414.  
  1415.               if (mblen == (size_t) -1)
  1416.             {
  1417.               /*  Ignore this new level.  */
  1418.               map = NULL;
  1419.               break;
  1420.             }
  1421.  
  1422.               /*  Calculate the length of mbdigits[n].  */
  1423.               const char *last_char = mbdigits[n];
  1424.               for (level = 0; level < to_level; ++level)
  1425.             last_char = strchr (last_char, '\0') + 1;
  1426.  
  1427.               size_t mbdigits_len = last_char - mbdigits[n];
  1428.  
  1429.               /*  Allocate memory for extended multibyte digit.  */
  1430.               char *mb_extended;
  1431.               mb_extended = (char *) alloca (mbdigits_len + mblen + 1);
  1432.  
  1433.               /*  And get the mbdigits + extra_digit string.  */
  1434.               *(char *) __mempcpy (__mempcpy (mb_extended, mbdigits[n],
  1435.                               mbdigits_len),
  1436.                        extra_mbdigit, mblen) = '\0';
  1437.               mbdigits_extended[n] = mb_extended;
  1438. #endif
  1439.             }
  1440.         }
  1441.  
  1442.           /* Read the number into workspace.  */
  1443.           while (c != EOF && width != 0)
  1444.         {
  1445.           /* In this round we get the pointer to the digit strings
  1446.              and also perform the first round of comparisons.  */
  1447.           for (n = 0; n < 10; ++n)
  1448.             {
  1449.               /* Get the string for the digits with value N.  */
  1450. #ifdef COMPILE_WSCANF
  1451.               if (__builtin_expect (map != NULL, 0))
  1452.             wcdigits[n] = wcdigits_extended[n];
  1453.               else
  1454.             wcdigits[n] = (const wchar_t *)
  1455.               _NL_CURRENT (LC_CTYPE, _NL_CTYPE_INDIGITS0_WC + n);
  1456.               wcdigits[n] += from_level;
  1457.  
  1458.               if (c == (wint_t) *wcdigits[n])
  1459.             {
  1460.               to_level = from_level;
  1461.               break;
  1462.             }
  1463.  
  1464.               /* Advance the pointer to the next string.  */
  1465.               ++wcdigits[n];
  1466. #else
  1467.               const char *cmpp;
  1468.               int avail = width > 0 ? width : INT_MAX;
  1469.  
  1470.               if (__builtin_expect (map != NULL, 0))
  1471.             mbdigits[n] = mbdigits_extended[n];
  1472.               else
  1473.             mbdigits[n]
  1474.               = curctype->values[_NL_CTYPE_INDIGITS0_MB + n].string;
  1475.  
  1476.               for (level = 0; level < from_level; level++)
  1477.             mbdigits[n] = strchr (mbdigits[n], '\0') + 1;
  1478.  
  1479.               cmpp = mbdigits[n];
  1480.               while ((unsigned char) *cmpp == c && avail >= 0)
  1481.             {
  1482.               if (*++cmpp == '\0')
  1483.                 break;
  1484.               else
  1485.                 {
  1486.                   if (avail == 0 || inchar () == EOF)
  1487.                 break;
  1488.                   --avail;
  1489.                 }
  1490.             }
  1491.  
  1492.               if (*cmpp == '\0')
  1493.             {
  1494.               if (width > 0)
  1495.                 width = avail;
  1496.               to_level = from_level;
  1497.               break;
  1498.             }
  1499.  
  1500.               /* We are pushing all read characters back.  */
  1501.               if (cmpp > mbdigits[n])
  1502.             {
  1503.               ungetc (c, s);
  1504.               while (--cmpp > mbdigits[n])
  1505.                 ungetc_not_eof ((unsigned char) *cmpp, s);
  1506.               c = (unsigned char) *cmpp;
  1507.             }
  1508.  
  1509.               /* Advance the pointer to the next string.  */
  1510.               mbdigits[n] = strchr (mbdigits[n], '\0') + 1;
  1511. #endif
  1512.             }
  1513.  
  1514.           if (n == 10)
  1515.             {
  1516.               /* Have not yet found the digit.  */
  1517.               for (level = from_level + 1; level <= to_level; ++level)
  1518.             {
  1519.               /* Search all ten digits of this level.  */
  1520.               for (n = 0; n < 10; ++n)
  1521.                 {
  1522. #ifdef COMPILE_WSCANF
  1523.                   if (c == (wint_t) *wcdigits[n])
  1524.                 break;
  1525.  
  1526.                   /* Advance the pointer to the next string.  */
  1527.                   ++wcdigits[n];
  1528. #else
  1529.                   const char *cmpp;
  1530.                   int avail = width > 0 ? width : INT_MAX;
  1531.  
  1532.                   cmpp = mbdigits[n];
  1533.                   while ((unsigned char) *cmpp == c && avail >= 0)
  1534.                 {
  1535.                   if (*++cmpp == '\0')
  1536.                     break;
  1537.                   else
  1538.                     {
  1539.                       if (avail == 0 || inchar () == EOF)
  1540.                     break;
  1541.                       --avail;
  1542.                     }
  1543.                 }
  1544.  
  1545.                   if (*cmpp == '\0')
  1546.                 {
  1547.                   if (width > 0)
  1548.                     width = avail;
  1549.                   break;
  1550.                 }
  1551.  
  1552.                   /* We are pushing all read characters back.  */
  1553.                   if (cmpp > mbdigits[n])
  1554.                 {
  1555.                   ungetc (c, s);
  1556.                   while (--cmpp > mbdigits[n])
  1557.                     ungetc_not_eof ((unsigned char) *cmpp, s);
  1558.                   c = (unsigned char) *cmpp;
  1559.                 }
  1560.  
  1561.                   /* Advance the pointer to the next string.  */
  1562.                   mbdigits[n] = strchr (mbdigits[n], '\0') + 1;
  1563. #endif
  1564.                 }
  1565.  
  1566.               if (n < 10)
  1567.                 {
  1568.                   /* Found it.  */
  1569.                   from_level = level;
  1570.                   to_level = level;
  1571.                   break;
  1572.                 }
  1573.             }
  1574.             }
  1575.  
  1576.           if (n < 10)
  1577.             c = L_('0') + n;
  1578.           else if (flags & GROUP)
  1579.             {
  1580.               /* Try matching against the thousands separator.  */
  1581. #ifdef COMPILE_WSCANF
  1582.               if (c != thousands)
  1583.               break;
  1584. #else
  1585.               const char *cmpp = thousands;
  1586.               int avail = width > 0 ? width : INT_MAX;
  1587.  
  1588.               while ((unsigned char) *cmpp == c && avail >= 0)
  1589.             {
  1590.               ADDW (c);
  1591.               if (*++cmpp == '\0')
  1592.                 break;
  1593.               else
  1594.                 {
  1595.                   if (avail == 0 || inchar () == EOF)
  1596.                 break;
  1597.                   --avail;
  1598.                 }
  1599.             }
  1600.  
  1601.               if (*cmpp != '\0')
  1602.             {
  1603.               /* We are pushing all read characters back.  */
  1604.               if (cmpp > thousands)
  1605.                 {
  1606.                   wpsize -= cmpp - thousands;
  1607.                   ungetc (c, s);
  1608.                   while (--cmpp > thousands)
  1609.                 ungetc_not_eof ((unsigned char) *cmpp, s);
  1610.                   c = (unsigned char) *cmpp;
  1611.                 }
  1612.               break;
  1613.             }
  1614.  
  1615.               if (width > 0)
  1616.             width = avail;
  1617.  
  1618.               /* The last thousands character will be added back by
  1619.              the ADDW below.  */
  1620.             --wpsize;
  1621. #endif
  1622.             }
  1623.           else
  1624.             break;
  1625.  
  1626.           ADDW (c);
  1627.           if (width > 0)
  1628.             --width;
  1629.  
  1630.           c = inchar ();
  1631.         }
  1632.         }
  1633.       else
  1634.         /* Read the number into workspace.  */
  1635.         while (c != EOF && width != 0)
  1636.           {
  1637.         if (base == 16)
  1638.           {
  1639.             if (!ISXDIGIT (c))
  1640.               break;
  1641.           }
  1642.         else if (!ISDIGIT (c) || (int) (c - L_('0')) >= base)
  1643.           {
  1644.             if (base == 10 && (flags & GROUP))
  1645.               {
  1646.             /* Try matching against the thousands separator.  */
  1647. #ifdef COMPILE_WSCANF
  1648.             if (c != thousands)
  1649.               break;
  1650. #else
  1651.             const char *cmpp = thousands;
  1652.             int avail = width > 0 ? width : INT_MAX;
  1653.  
  1654.             while ((unsigned char) *cmpp == c && avail >= 0)
  1655.               {
  1656.                 ADDW (c);
  1657.                 if (*++cmpp == '\0')
  1658.                   break;
  1659.                 else
  1660.                   {
  1661.                 if (avail == 0 || inchar () == EOF)
  1662.                   break;
  1663.                 --avail;
  1664.                   }
  1665.               }
  1666.  
  1667.             if (*cmpp != '\0')
  1668.               {
  1669.                 /* We are pushing all read characters back.  */
  1670.                 if (cmpp > thousands)
  1671.                   {
  1672.                 wpsize -= cmpp - thousands;
  1673.                 ungetc (c, s);
  1674.                 while (--cmpp > thousands)
  1675.                   ungetc_not_eof ((unsigned char) *cmpp, s);
  1676.                 c = (unsigned char) *cmpp;
  1677.                   }
  1678.                 break;
  1679.               }
  1680.  
  1681.             if (width > 0)
  1682.               width = avail;
  1683.  
  1684.             /* The last thousands character will be added back by
  1685.                the ADDW below.  */
  1686.             --wpsize;
  1687. #endif
  1688.               }
  1689.             else
  1690.               break;
  1691.           }
  1692.         ADDW (c);
  1693.         if (width > 0)
  1694.           --width;
  1695.  
  1696.         c = inchar ();
  1697.           }
  1698.  
  1699.       if (wpsize == 0
  1700.           || (wpsize == 1 && (wp[0] == L_('+') || wp[0] == L_('-'))))
  1701.         {
  1702.           /* There was no number.  If we are supposed to read a pointer
  1703.          we must recognize "(nil)" as well.  */
  1704.           if (__builtin_expect (wpsize == 0
  1705.                     && (flags & READ_POINTER)
  1706.                     && (width < 0 || width >= 0)
  1707.                     && c == '('
  1708.                     && TOLOWER (inchar ()) == L_('n')
  1709.                     && TOLOWER (inchar ()) == L_('i')
  1710.                     && TOLOWER (inchar ()) == L_('l')
  1711.                     && inchar () == L_(')'), 1))
  1712.         /* We must produce the value of a NULL pointer.  A single
  1713.            '0' digit is enough.  */
  1714.         ADDW (L_('0'));
  1715.           else
  1716.         {
  1717.           /* The last read character is not part of the number
  1718.              anymore.  */
  1719.           ungetc (c, s);
  1720.  
  1721.           conv_error ();
  1722.         }
  1723.         }
  1724.       else
  1725.         /* The just read character is not part of the number anymore.  */
  1726.         ungetc (c, s);
  1727.  
  1728.       /* Convert the number.  */
  1729.       ADDW (L_('\0'));
  1730.       if (need_longlong && (flags & LONGDBL))
  1731.         {
  1732.           if (flags & NUMBER_SIGNED)
  1733.         num.q = __strtoll_internal (wp, &tw, base, flags & GROUP);
  1734.           else
  1735.         num.uq = __strtoull_internal (wp, &tw, base, flags & GROUP);
  1736.         }
  1737.       else
  1738.         {
  1739.           if (flags & NUMBER_SIGNED)
  1740.         num.l = __strtol_internal (wp, &tw, base, flags & GROUP);
  1741.           else
  1742.         num.ul = __strtoul_internal (wp, &tw, base, flags & GROUP);
  1743.         }
  1744.       if (__builtin_expect (wp == tw, 0))
  1745.         conv_error ();
  1746.  
  1747.       if (!(flags & SUPPRESS))
  1748.         {
  1749.           if (flags & NUMBER_SIGNED)
  1750.         {
  1751.           if (need_longlong && (flags & LONGDBL))
  1752.             *ARG (LONGLONG int *) = num.q;
  1753.           else if (need_long && (flags & LONG))
  1754.             *ARG (long int *) = num.l;
  1755.           else if (flags & SHORT)
  1756.             *ARG (short int *) = (short int) num.l;
  1757.           else if (!(flags & CHAR))
  1758.             *ARG (int *) = (int) num.l;
  1759.           else
  1760.             *ARG (signed char *) = (signed char) num.ul;
  1761.         }
  1762.           else
  1763.         {
  1764.           if (need_longlong && (flags & LONGDBL))
  1765.             *ARG (unsigned LONGLONG int *) = num.uq;
  1766.           else if (need_long && (flags & LONG))
  1767.             *ARG (unsigned long int *) = num.ul;
  1768.           else if (flags & SHORT)
  1769.             *ARG (unsigned short int *)
  1770.               = (unsigned short int) num.ul;
  1771.           else if (!(flags & CHAR))
  1772.             *ARG (unsigned int *) = (unsigned int) num.ul;
  1773.           else
  1774.             *ARG (unsigned char *) = (unsigned char) num.ul;
  1775.         }
  1776.           ++done;
  1777.         }
  1778.       break;
  1779.  
  1780.     case L_('e'):   /* Floating-point numbers.  */
  1781.     case L_('E'):
  1782.     case L_('f'):
  1783.     case L_('F'):
  1784.     case L_('g'):
  1785.     case L_('G'):
  1786.     case L_('a'):
  1787.     case L_('A'):
  1788.       c = inchar ();
  1789.       if (width > 0)
  1790.         --width;
  1791.       if (__builtin_expect (c == EOF, 0))
  1792.         input_error ();
  1793.  
  1794.       got_dot = got_e = 0;
  1795.  
  1796.       /* Check for a sign.  */
  1797.       if (c == L_('-') || c == L_('+'))
  1798.         {
  1799.           negative = c == L_('-');
  1800.           if (__builtin_expect (width == 0 || inchar () == EOF, 0))
  1801.         /* EOF is only an input error before we read any chars.  */
  1802.         conv_error ();
  1803.           if (width > 0)
  1804.         --width;
  1805.         }
  1806.       else
  1807.         negative = 0;
  1808.  
  1809.       /* Take care for the special arguments "nan" and "inf".  */
  1810.       if (TOLOWER (c) == L_('n'))
  1811.         {
  1812.           /* Maybe "nan".  */
  1813.           ADDW (c);
  1814.           if (__builtin_expect (width == 0
  1815.                     || inchar () == EOF
  1816.                     || TOLOWER (c) != L_('a'), 0))
  1817.         conv_error ();
  1818.           if (width > 0)
  1819.         --width;
  1820.           ADDW (c);
  1821.           if (__builtin_expect (width == 0
  1822.                     || inchar () == EOF
  1823.                     || TOLOWER (c) != L_('n'), 0))
  1824.         conv_error ();
  1825.           if (width > 0)
  1826.         --width;
  1827.           ADDW (c);
  1828.           /* It is "nan".  */
  1829.           goto scan_float;
  1830.         }
  1831.       else if (TOLOWER (c) == L_('i'))
  1832.         {
  1833.           /* Maybe "inf" or "infinity".  */
  1834.           ADDW (c);
  1835.           if (__builtin_expect (width == 0
  1836.                     || inchar () == EOF
  1837.                     || TOLOWER (c) != L_('n'), 0))
  1838.         conv_error ();
  1839.           if (width > 0)
  1840.         --width;
  1841.           ADDW (c);
  1842.           if (__builtin_expect (width == 0
  1843.                     || inchar () == EOF
  1844.                     || TOLOWER (c) != L_('f'), 0))
  1845.         conv_error ();
  1846.           if (width > 0)
  1847.         --width;
  1848.           ADDW (c);
  1849.           /* It is as least "inf".  */
  1850.           if (width != 0 && inchar () != EOF)
  1851.         {
  1852.           if (TOLOWER (c) == L_('i'))
  1853.             {
  1854.               if (width > 0)
  1855.             --width;
  1856.               /* Now we have to read the rest as well.  */
  1857.               ADDW (c);
  1858.               if (__builtin_expect (width == 0
  1859.                         || inchar () == EOF
  1860.                         || TOLOWER (c) != L_('n'), 0))
  1861.             conv_error ();
  1862.               if (width > 0)
  1863.             --width;
  1864.               ADDW (c);
  1865.               if (__builtin_expect (width == 0
  1866.                         || inchar () == EOF
  1867.                         || TOLOWER (c) != L_('i'), 0))
  1868.             conv_error ();
  1869.               if (width > 0)
  1870.             --width;
  1871.               ADDW (c);
  1872.               if (__builtin_expect (width == 0
  1873.                         || inchar () == EOF
  1874.                         || TOLOWER (c) != L_('t'), 0))
  1875.             conv_error ();
  1876.               if (width > 0)
  1877.             --width;
  1878.               ADDW (c);
  1879.               if (__builtin_expect (width == 0
  1880.                         || inchar () == EOF
  1881.                         || TOLOWER (c) != L_('y'), 0))
  1882.             conv_error ();
  1883.               if (width > 0)
  1884.             --width;
  1885.               ADDW (c);
  1886.             }
  1887.           else
  1888.             /* Never mind.  */
  1889.             ungetc (c, s);
  1890.         }
  1891.           goto scan_float;
  1892.         }
  1893.  
  1894.       exp_char = L_('e');
  1895.       if (width != 0 && c == L_('0'))
  1896.         {
  1897.           ADDW (c);
  1898.           c = inchar ();
  1899.           if (width > 0)
  1900.         --width;
  1901.           if (width != 0 && TOLOWER (c) == L_('x'))
  1902.         {
  1903.           /* It is a number in hexadecimal format.  */
  1904.           ADDW (c);
  1905.  
  1906.           flags |= HEXA_FLOAT;
  1907.           exp_char = L_('p');
  1908.  
  1909.           /* Grouping is not allowed.  */
  1910.           flags &= ~GROUP;
  1911.           c = inchar ();
  1912.           if (width > 0)
  1913.             --width;
  1914.         }
  1915.         }
  1916.  
  1917.       while (1)
  1918.         {
  1919.           if (ISDIGIT (c))
  1920.         ADDW (c);
  1921.           else if (!got_e && (flags & HEXA_FLOAT) && ISXDIGIT (c))
  1922.         ADDW (c);
  1923.           else if (got_e && wp[wpsize - 1] == exp_char
  1924.                && (c == L_('-') || c == L_('+')))
  1925.         ADDW (c);
  1926.           else if (wpsize > 0 && !got_e
  1927.                && (CHAR_T) TOLOWER (c) == exp_char)
  1928.         {
  1929.           ADDW (exp_char);
  1930.           got_e = got_dot = 1;
  1931.         }
  1932.           else
  1933.         {
  1934. #ifdef COMPILE_WSCANF
  1935.           if (! got_dot && c == decimal)
  1936.             {
  1937.               ADDW (c);
  1938.               got_dot = 1;
  1939.             }
  1940.           else if ((flags & GROUP) != 0 && ! got_dot && c == thousands)
  1941.             ADDW (c);
  1942.           else
  1943.             {
  1944.               /* The last read character is not part of the number
  1945.              anymore.  */
  1946.               ungetc (c, s);
  1947.               break;
  1948.             }
  1949. #else
  1950.           const char *cmpp = decimal;
  1951.           int avail = width > 0 ? width : INT_MAX;
  1952.  
  1953.           if (! got_dot)
  1954.             {
  1955.               while ((unsigned char) *cmpp == c && avail >= 0)
  1956.             if (*++cmpp == '\0')
  1957.               break;
  1958.             else
  1959.               {
  1960.                 if (avail == 0 || inchar () == EOF)
  1961.                   break;
  1962.                 --avail;
  1963.               }
  1964.             }
  1965.  
  1966.           if (*cmpp == '\0')
  1967.             {
  1968.               /* Add all the characters.  */
  1969.               for (cmpp = decimal; *cmpp != '\0'; ++cmpp)
  1970.             ADDW ((unsigned char) *cmpp);
  1971.               if (width > 0)
  1972.             width = avail;
  1973.               got_dot = 1;
  1974.             }
  1975.           else
  1976.             {
  1977.               /* Figure out whether it is a thousands separator.
  1978.              There is one problem: we possibly read more than
  1979.              one character.  We cannot push them back but since
  1980.              we know that parts of the `decimal' string matched,
  1981.              we can compare against it.  */
  1982.               const char *cmp2p = thousands;
  1983.  
  1984.               if ((flags & GROUP) != 0 && ! got_dot)
  1985.             {
  1986.               while (cmp2p - thousands < cmpp - decimal
  1987.                  && *cmp2p == decimal[cmp2p - thousands])
  1988.                 ++cmp2p;
  1989.               if (cmp2p - thousands == cmpp - decimal)
  1990.                 {
  1991.                   while ((unsigned char) *cmp2p == c && avail >= 0)
  1992.                 if (*++cmp2p == '\0')
  1993.                   break;
  1994.                 else
  1995.                   {
  1996.                     if (avail == 0 || inchar () == EOF)
  1997.                       break;
  1998.                     --avail;
  1999.                   }
  2000.                 }
  2001.             }
  2002.  
  2003.               if (cmp2p != NULL && *cmp2p == '\0')
  2004.             {
  2005.               /* Add all the characters.  */
  2006.               for (cmpp = thousands; *cmpp != '\0'; ++cmpp)
  2007.                 ADDW ((unsigned char) *cmpp);
  2008.               if (width > 0)
  2009.                 width = avail;
  2010.             }
  2011.               else
  2012.             {
  2013.               /* The last read character is not part of the number
  2014.                  anymore.  */
  2015.               ungetc (c, s);
  2016.               break;
  2017.             }
  2018.             }
  2019. #endif
  2020.         }
  2021.  
  2022.           if (width == 0 || inchar () == EOF)
  2023.         break;
  2024.  
  2025.           if (width > 0)
  2026.         --width;
  2027.         }
  2028.  
  2029.       wctrans_t map;
  2030.       if (__builtin_expect ((flags & I18N) != 0, 0)
  2031.           /* Hexadecimal floats make no sense, fixing localized
  2032.          digits with ASCII letters.  */
  2033.           && !(flags & HEXA_FLOAT)
  2034.           /* Minimum requirement.  */
  2035.           && (wpsize == 0 || got_dot)
  2036.           && (map = __wctrans ("to_inpunct")) != NULL)
  2037.         {
  2038.           /* Reget the first character.  */
  2039.           inchar ();
  2040.  
  2041.           /* Localized digits, decimal points, and thousands
  2042.          separator.  */
  2043.           wint_t wcdigits[12];
  2044.  
  2045.           /* First get decimal equivalent to check if we read it
  2046.          or not.  */
  2047.           wcdigits[11] = __towctrans (L'.', map);
  2048.  
  2049.           /* If we have not read any character or have just read
  2050.          locale decimal point which matches the decimal point
  2051.          for localized FP numbers, then we may have localized
  2052.          digits.  Note, we test GOT_DOT above.  */
  2053. #ifdef COMPILE_WSCANF
  2054.           if (wpsize == 0 || (wpsize == 1 && wcdigits[11] == decimal))
  2055. #else
  2056.           char mbdigits[12][MB_LEN_MAX + 1];
  2057.  
  2058.           mbstate_t state;
  2059.           memset (&state, '\0', sizeof (state));
  2060.  
  2061.           bool match_so_far = wpsize == 0;
  2062.           size_t mblen = __wcrtomb (mbdigits[11], wcdigits[11], &state);
  2063.           if (mblen != (size_t) -1)
  2064.         {
  2065.           mbdigits[11][mblen] = '\0';
  2066.           match_so_far |= (wpsize == strlen (decimal)
  2067.                    && strcmp (decimal, mbdigits[11]) == 0);
  2068.         }
  2069.           else
  2070.         {
  2071.           size_t decimal_len = strlen (decimal);
  2072.           /* This should always be the case but the data comes
  2073.              from a file.  */
  2074.           if (decimal_len <= MB_LEN_MAX)
  2075.             {
  2076.               match_so_far |= wpsize == decimal_len;
  2077.               memcpy (mbdigits[11], decimal, decimal_len + 1);
  2078.             }
  2079.           else
  2080.             match_so_far = false;
  2081.         }
  2082.  
  2083.           if (match_so_far)
  2084. #endif
  2085.         {
  2086.           bool have_locthousands = (flags & GROUP) != 0;
  2087.  
  2088.           /* Now get the digits and the thousands-sep equivalents.  */
  2089.           for (int n = 0; n < 11; ++n)
  2090.             {
  2091.               if (n < 10)
  2092.             wcdigits[n] = __towctrans (L'0' + n, map);
  2093.               else if (n == 10)
  2094.             {
  2095.               wcdigits[10] = __towctrans (L',', map);
  2096.               have_locthousands &= wcdigits[10] != L'\0';
  2097.             }
  2098.  
  2099. #ifndef COMPILE_WSCANF
  2100.               memset (&state, '\0', sizeof (state));
  2101.  
  2102.               size_t mblen = __wcrtomb (mbdigits[n], wcdigits[n],
  2103.                         &state);
  2104.               if (mblen == (size_t) -1)
  2105.             {
  2106.               if (n == 10)
  2107.                 {
  2108.                   if (have_locthousands)
  2109.                 {
  2110.                   size_t thousands_len = strlen (thousands);
  2111.                   if (thousands_len <= MB_LEN_MAX)
  2112.                     memcpy (mbdigits[10], thousands,
  2113.                         thousands_len + 1);
  2114.                   else
  2115.                     have_locthousands = false;
  2116.                 }
  2117.                 }
  2118.               else
  2119.                 /* Ignore checking against localized digits.  */
  2120.                 goto no_i18nflt;
  2121.             }
  2122.               else
  2123.             mbdigits[n][mblen] = '\0';
  2124. #endif
  2125.             }
  2126.  
  2127.           /* Start checking against localized digits, if
  2128.              convertion is done correctly. */
  2129.           while (1)
  2130.             {
  2131.               if (got_e && wp[wpsize - 1] == exp_char
  2132.               && (c == L_('-') || c == L_('+')))
  2133.             ADDW (c);
  2134.               else if (wpsize > 0 && !got_e
  2135.                    && (CHAR_T) TOLOWER (c) == exp_char)
  2136.             {
  2137.               ADDW (exp_char);
  2138.               got_e = got_dot = 1;
  2139.             }
  2140.               else
  2141.             {
  2142.               /* Check against localized digits, decimal point,
  2143.                  and thousands separator.  */
  2144.               int n;
  2145.               for (n = 0; n < 12; ++n)
  2146.                 {
  2147. #ifdef COMPILE_WSCANF
  2148.                   if (c == wcdigits[n])
  2149.                 {
  2150.                   if (n < 10)
  2151.                     ADDW (L_('0') + n);
  2152.                   else if (n == 11 && !got_dot)
  2153.                     {
  2154.                       ADDW (decimal);
  2155.                       got_dot = 1;
  2156.                     }
  2157.                   else if (n == 10 && have_locthousands
  2158.                        && ! got_dot)
  2159.                     ADDW (thousands);
  2160.                   else
  2161.                     /* The last read character is not part
  2162.                        of the number anymore.  */
  2163.                     n = 12;
  2164.  
  2165.                   break;
  2166.                 }
  2167. #else
  2168.                   const char *cmpp = mbdigits[n];
  2169.                   int avail = width > 0 ? width : INT_MAX;
  2170.  
  2171.                   while ((unsigned char) *cmpp == c && avail >= 0)
  2172.                 if (*++cmpp == '\0')
  2173.                   break;
  2174.                 else
  2175.                   {
  2176.                     if (avail == 0 || inchar () == EOF)
  2177.                       break;
  2178.                     --avail;
  2179.                   }
  2180.                   if (*cmpp == '\0')
  2181.                 {
  2182.                   if (width > 0)
  2183.                     width = avail;
  2184.  
  2185.                   if (n < 10)
  2186.                     ADDW (L_('0') + n);
  2187.                   else if (n == 11 && !got_dot)
  2188.                     {
  2189.                       /* Add all the characters.  */
  2190.                       for (cmpp = decimal; *cmpp != '\0';
  2191.                        ++cmpp)
  2192.                     ADDW ((unsigned char) *cmpp);
  2193.  
  2194.                       got_dot = 1;
  2195.                     }
  2196.                   else if (n == 10 && (flags & GROUP) != 0
  2197.                        && ! got_dot)
  2198.                     {
  2199.                       /* Add all the characters.  */
  2200.                       for (cmpp = thousands; *cmpp != '\0';
  2201.                        ++cmpp)
  2202.                     ADDW ((unsigned char) *cmpp);
  2203.                     }
  2204.                   else
  2205.                     /* The last read character is not part
  2206.                        of the number anymore.  */
  2207.                       n = 12;
  2208.  
  2209.                   break;
  2210.                 }
  2211.  
  2212.                   /* We are pushing all read characters back.  */
  2213.                   if (cmpp > mbdigits[n])
  2214.                 {
  2215.                   ungetc (c, s);
  2216.                   while (--cmpp > mbdigits[n])
  2217.                     ungetc_not_eof ((unsigned char) *cmpp, s);
  2218.                   c = (unsigned char) *cmpp;
  2219.                 }
  2220. #endif
  2221.                 }
  2222.  
  2223.               if (n >= 12)
  2224.                 {
  2225.                   /* The last read character is not part
  2226.                  of the number anymore.  */
  2227.                   ungetc (c, s);
  2228.                   break;
  2229.                 }
  2230.             }
  2231.  
  2232.               if (width == 0 || inchar () == EOF)
  2233.             break;
  2234.  
  2235.               if (width > 0)
  2236.             --width;
  2237.             }
  2238.         }
  2239.  
  2240. #ifndef COMPILE_WSCANF
  2241.         no_i18nflt:
  2242.           ;
  2243. #endif
  2244.         }
  2245.  
  2246.       /* Have we read any character?  If we try to read a number
  2247.          in hexadecimal notation and we have read only the `0x'
  2248.          prefix this is an error.  */
  2249.       if (__builtin_expect (wpsize == 0
  2250.                 || ((flags & HEXA_FLOAT) && wpsize == 2), 0))
  2251.         conv_error ();
  2252.  
  2253.     scan_float:
  2254.       /* Convert the number.  */
  2255.       ADDW (L_('\0'));
  2256.       if ((flags & LONGDBL) && !__ldbl_is_dbl)
  2257.         {
  2258.           long double d = __strtold_internal (wp, &tw, flags & GROUP);
  2259.           if (!(flags & SUPPRESS) && tw != wp)
  2260.         *ARG (long double *) = negative ? -d : d;
  2261.         }
  2262.       else if (flags & (LONG | LONGDBL))
  2263.         {
  2264.           double d = __strtod_internal (wp, &tw, flags & GROUP);
  2265.           if (!(flags & SUPPRESS) && tw != wp)
  2266.         *ARG (double *) = negative ? -d : d;
  2267.         }
  2268.       else
  2269.         {
  2270.           float d = __strtof_internal (wp, &tw, flags & GROUP);
  2271.           if (!(flags & SUPPRESS) && tw != wp)
  2272.         *ARG (float *) = negative ? -d : d;
  2273.         }
  2274.  
  2275.       if (__builtin_expect (tw == wp, 0))
  2276.         conv_error ();
  2277.  
  2278.       if (!(flags & SUPPRESS))
  2279.         ++done;
  2280.       break;
  2281.  
  2282.     case L_('['):   /* Character class.  */
  2283.       if (flags & LONG)
  2284.         STRING_ARG (wstr, wchar_t, 100);
  2285.       else
  2286.         STRING_ARG (str, char, 100);
  2287.  
  2288.       if (*f == L_('^'))
  2289.         {
  2290.           ++f;
  2291.           not_in = 1;
  2292.         }
  2293.       else
  2294.         not_in = 0;
  2295.  
  2296.       if (width < 0)
  2297.         /* There is no width given so there is also no limit on the
  2298.            number of characters we read.  Therefore we set width to
  2299.            a very high value to make the algorithm easier.  */
  2300.         width = INT_MAX;
  2301.  
  2302. #ifdef COMPILE_WSCANF
  2303.       /* Find the beginning and the end of the scanlist.  We are not
  2304.          creating a lookup table since it would have to be too large.
  2305.          Instead we search each time through the string.  This is not
  2306.          a constant lookup time but who uses this feature deserves to
  2307.          be punished.  */
  2308.       tw = (wchar_t *) f;   /* Marks the beginning.  */
  2309.  
  2310.       if (*f == L']')
  2311.         ++f;
  2312.  
  2313.       while ((fc = *f++) != L'\0' && fc != L']');
  2314.  
  2315.       if (__builtin_expect (fc == L'\0', 0))
  2316.         conv_error ();
  2317.       wchar_t *twend = (wchar_t *) f - 1;
  2318. #else
  2319.       /* Fill WP with byte flags indexed by character.
  2320.          We will use this flag map for matching input characters.  */
  2321.       if (wpmax < UCHAR_MAX + 1)
  2322.         {
  2323.           wpmax = UCHAR_MAX + 1;
  2324.           wp = (char *) alloca (wpmax);
  2325.         }
  2326.       memset (wp, '\0', UCHAR_MAX + 1);
  2327.  
  2328.       fc = *f;
  2329.       if (fc == ']' || fc == '-')
  2330.         {
  2331.           /* If ] or - appears before any char in the set, it is not
  2332.          the terminator or separator, but the first char in the
  2333.          set.  */
  2334.           wp[fc] = 1;
  2335.           ++f;
  2336.         }
  2337.  
  2338.       while ((fc = *f++) != '\0' && fc != ']')
  2339.         if (fc == '-' && *f != '\0' && *f != ']'
  2340.         && (unsigned char) f[-2] <= (unsigned char) *f)
  2341.           {
  2342.         /* Add all characters from the one before the '-'
  2343.            up to (but not including) the next format char.  */
  2344.         for (fc = (unsigned char) f[-2]; fc < (unsigned char) *f; ++fc)
  2345.           wp[fc] = 1;
  2346.           }
  2347.         else
  2348.           /* Add the character to the flag map.  */
  2349.           wp[fc] = 1;
  2350.  
  2351.       if (__builtin_expect (fc == '\0', 0))
  2352.         conv_error();
  2353. #endif
  2354.  
  2355.       if (flags & LONG)
  2356.         {
  2357.           size_t now = read_in;
  2358. #ifdef COMPILE_WSCANF
  2359.           if (__builtin_expect (inchar () == WEOF, 0))
  2360.         input_error ();
  2361.  
  2362.           do
  2363.         {
  2364.           wchar_t *runp;
  2365.  
  2366.           /* Test whether it's in the scanlist.  */
  2367.           runp = tw;
  2368.           while (runp < twend)
  2369.             {
  2370.               if (runp[0] == L'-' && runp[1] != '\0'
  2371.               && runp + 1 != twend
  2372.               && runp != tw
  2373.               && (unsigned int) runp[-1] <= (unsigned int) runp[1])
  2374.             {
  2375.               /* Match against all characters in between the
  2376.                  first and last character of the sequence.  */
  2377.               wchar_t wc;
  2378.  
  2379.               for (wc = runp[-1] + 1; wc <= runp[1]; ++wc)
  2380.                 if ((wint_t) wc == c)
  2381.                   break;
  2382.  
  2383.               if (wc <= runp[1] && !not_in)
  2384.                 break;
  2385.               if (wc <= runp[1] && not_in)
  2386.                 {
  2387.                   /* The current character is not in the
  2388.                  scanset.  */
  2389.                   ungetc (c, s);
  2390.                   goto out;
  2391.                 }
  2392.  
  2393.               runp += 2;
  2394.             }
  2395.               else
  2396.             {
  2397.               if ((wint_t) *runp == c && !not_in)
  2398.                 break;
  2399.               if ((wint_t) *runp == c && not_in)
  2400.                 {
  2401.                   ungetc (c, s);
  2402.                   goto out;
  2403.                 }
  2404.  
  2405.               ++runp;
  2406.             }
  2407.             }
  2408.  
  2409.           if (runp == twend && !not_in)
  2410.             {
  2411.               ungetc (c, s);
  2412.               goto out;
  2413.             }
  2414.  
  2415.           if (!(flags & SUPPRESS))
  2416.             {
  2417.               *wstr++ = c;
  2418.  
  2419.               if ((flags & MALLOC)
  2420.               && wstr == (wchar_t *) *strptr + strsize)
  2421.             {
  2422.               /* Enlarge the buffer.  */
  2423.               wstr = (wchar_t *) realloc (*strptr,
  2424.                               (2 * strsize)
  2425.                               * sizeof (wchar_t));
  2426.               if (wstr == NULL)
  2427.                 {
  2428.                   /* Can't allocate that much.  Last-ditch
  2429.                  effort.  */
  2430.                   wstr = (wchar_t *)
  2431.                 realloc (*strptr, (strsize + 1)
  2432.                           * sizeof (wchar_t));
  2433.                   if (wstr == NULL)
  2434.                 {
  2435.                   if (flags & POSIX_MALLOC)
  2436.                     goto reteof;
  2437.                   /* We lose.  Oh well.  Terminate the string
  2438.                      and stop converting, so at least we don't
  2439.                      skip any input.  */
  2440.                   ((wchar_t *) (*strptr))[strsize - 1] = L'\0';
  2441.                   strptr = NULL;
  2442.                   ++done;
  2443.                   conv_error ();
  2444.                 }
  2445.                   else
  2446.                 {
  2447.                   *strptr = (char *) wstr;
  2448.                   wstr += strsize;
  2449.                   ++strsize;
  2450.                 }
  2451.                 }
  2452.               else
  2453.                 {
  2454.                   *strptr = (char *) wstr;
  2455.                   wstr += strsize;
  2456.                   strsize *= 2;
  2457.                 }
  2458.             }
  2459.             }
  2460.         }
  2461.           while (--width > 0 && inchar () != WEOF);
  2462.         out:
  2463. #else
  2464.           char buf[MB_LEN_MAX];
  2465.           size_t cnt = 0;
  2466.           mbstate_t cstate;
  2467.  
  2468.           if (__builtin_expect (inchar () == EOF, 0))
  2469.         input_error ();
  2470.  
  2471.           memset (&cstate, '\0', sizeof (cstate));
  2472.  
  2473.           do
  2474.         {
  2475.           if (wp[c] == not_in)
  2476.             {
  2477.               ungetc_not_eof (c, s);
  2478.               break;
  2479.             }
  2480.  
  2481.           /* This is easy.  */
  2482.           if (!(flags & SUPPRESS))
  2483.             {
  2484.               size_t n;
  2485.  
  2486.               /* Convert it into a wide character.  */
  2487.               buf[0] = c;
  2488.               n = __mbrtowc (wstr, buf, 1, &cstate);
  2489.  
  2490.               if (n == (size_t) -2)
  2491.             {
  2492.               /* Possibly correct character, just not enough
  2493.                  input.  */
  2494.               ++cnt;
  2495.               assert (cnt < MB_CUR_MAX);
  2496.               continue;
  2497.             }
  2498.               cnt = 0;
  2499.  
  2500.               ++wstr;
  2501.               if ((flags & MALLOC)
  2502.               && wstr == (wchar_t *) *strptr + strsize)
  2503.             {
  2504.               /* Enlarge the buffer.  */
  2505.               wstr = (wchar_t *) realloc (*strptr,
  2506.                               (2 * strsize
  2507.                                * sizeof (wchar_t)));
  2508.               if (wstr == NULL)
  2509.                 {
  2510.                   /* Can't allocate that much.  Last-ditch
  2511.                  effort.  */
  2512.                   wstr = (wchar_t *)
  2513.                 realloc (*strptr, ((strsize + 1)
  2514.                            * sizeof (wchar_t)));
  2515.                   if (wstr == NULL)
  2516.                 {
  2517.                   if (flags & POSIX_MALLOC)
  2518.                     goto reteof;
  2519.                   /* We lose.  Oh well.  Terminate the
  2520.                      string and stop converting,
  2521.                      so at least we don't skip any input.  */
  2522.                   ((wchar_t *) (*strptr))[strsize - 1] = L'\0';
  2523.                   strptr = NULL;
  2524.                   ++done;
  2525.                   conv_error ();
  2526.                 }
  2527.                   else
  2528.                 {
  2529.                   *strptr = (char *) wstr;
  2530.                   wstr += strsize;
  2531.                   ++strsize;
  2532.                 }
  2533.                 }
  2534.               else
  2535.                 {
  2536.                   *strptr = (char *) wstr;
  2537.                   wstr += strsize;
  2538.                   strsize *= 2;
  2539.                 }
  2540.             }
  2541.             }
  2542.  
  2543.           if (--width <= 0)
  2544.             break;
  2545.         }
  2546.           while (inchar () != EOF);
  2547.  
  2548.           if (__builtin_expect (cnt != 0, 0))
  2549.         /* We stopped in the middle of recognizing another
  2550.            character.  That's a problem.  */
  2551.         encode_error ();
  2552. #endif
  2553.  
  2554.           if (__builtin_expect (now == read_in, 0))
  2555.         /* We haven't succesfully read any character.  */
  2556.         conv_error ();
  2557.  
  2558.           if (!(flags & SUPPRESS))
  2559.         {
  2560.           *wstr++ = L'\0';
  2561.  
  2562.           if ((flags & MALLOC)
  2563.               && wstr - (wchar_t *) *strptr != strsize)
  2564.             {
  2565.               wchar_t *cp = (wchar_t *)
  2566.             realloc (*strptr, ((wstr - (wchar_t *) *strptr)
  2567.                        * sizeof(wchar_t)));
  2568.               if (cp != NULL)
  2569.             *strptr = (char *) cp;
  2570.             }
  2571.           strptr = NULL;
  2572.  
  2573.           ++done;
  2574.         }
  2575.         }
  2576.       else
  2577.         {
  2578.           size_t now = read_in;
  2579.  
  2580.           if (__builtin_expect (inchar () == EOF, 0))
  2581.         input_error ();
  2582.  
  2583. #ifdef COMPILE_WSCANF
  2584.  
  2585.           memset (&state, '\0', sizeof (state));
  2586.  
  2587.           do
  2588.         {
  2589.           wchar_t *runp;
  2590.           size_t n;
  2591.  
  2592.           /* Test whether it's in the scanlist.  */
  2593.           runp = tw;
  2594.           while (runp < twend)
  2595.             {
  2596.               if (runp[0] == L'-' && runp[1] != '\0'
  2597.               && runp + 1 != twend
  2598.               && runp != tw
  2599.               && (unsigned int) runp[-1] <= (unsigned int) runp[1])
  2600.             {
  2601.               /* Match against all characters in between the
  2602.                  first and last character of the sequence.  */
  2603.               wchar_t wc;
  2604.  
  2605.               for (wc = runp[-1] + 1; wc <= runp[1]; ++wc)
  2606.                 if ((wint_t) wc == c)
  2607.                   break;
  2608.  
  2609.               if (wc <= runp[1] && !not_in)
  2610.                 break;
  2611.               if (wc <= runp[1] && not_in)
  2612.                 {
  2613.                   /* The current character is not in the
  2614.                  scanset.  */
  2615.                   ungetc (c, s);
  2616.                   goto out2;
  2617.                 }
  2618.  
  2619.               runp += 2;
  2620.             }
  2621.               else
  2622.             {
  2623.               if ((wint_t) *runp == c && !not_in)
  2624.                 break;
  2625.               if ((wint_t) *runp == c && not_in)
  2626.                 {
  2627.                   ungetc (c, s);
  2628.                   goto out2;
  2629.                 }
  2630.  
  2631.               ++runp;
  2632.             }
  2633.             }
  2634.  
  2635.           if (runp == twend && !not_in)
  2636.             {
  2637.               ungetc (c, s);
  2638.               goto out2;
  2639.             }
  2640.  
  2641.           if (!(flags & SUPPRESS))
  2642.             {
  2643.               if ((flags & MALLOC)
  2644.               && str + MB_CUR_MAX >= *strptr + strsize)
  2645.             {
  2646.               /* Enlarge the buffer.  */
  2647.               size_t strleng = str - *strptr;
  2648.               char *newstr;
  2649.  
  2650.               newstr = (char *) realloc (*strptr, 2 * strsize);
  2651.               if (newstr == NULL)
  2652.                 {
  2653.                   /* Can't allocate that much.  Last-ditch
  2654.                  effort.  */
  2655.                   newstr = (char *) realloc (*strptr,
  2656.                              strleng + MB_CUR_MAX);
  2657.                   if (newstr == NULL)
  2658.                 {
  2659.                   if (flags & POSIX_MALLOC)
  2660.                     goto reteof;
  2661.                   /* We lose.  Oh well.  Terminate the string
  2662.                      and stop converting, so at least we don't
  2663.                      skip any input.  */
  2664.                   ((char *) (*strptr))[strleng] = '\0';
  2665.                   strptr = NULL;
  2666.                   ++done;
  2667.                   conv_error ();
  2668.                 }
  2669.                   else
  2670.                 {
  2671.                   *strptr = newstr;
  2672.                   str = newstr + strleng;
  2673.                   strsize = strleng + MB_CUR_MAX;
  2674.                 }
  2675.                 }
  2676.               else
  2677.                 {
  2678.                   *strptr = newstr;
  2679.                   str = newstr + strleng;
  2680.                   strsize *= 2;
  2681.                 }
  2682.             }
  2683.             }
  2684.  
  2685.           n = __wcrtomb (!(flags & SUPPRESS) ? str : NULL, c, &state);
  2686.           if (__builtin_expect (n == (size_t) -1, 0))
  2687.             encode_error ();
  2688.  
  2689.           assert (n <= MB_CUR_MAX);
  2690.           str += n;
  2691.         }
  2692.           while (--width > 0 && inchar () != WEOF);
  2693.         out2:
  2694. #else
  2695.           do
  2696.         {
  2697.           if (wp[c] == not_in)
  2698.             {
  2699.               ungetc_not_eof (c, s);
  2700.               break;
  2701.             }
  2702.  
  2703.           /* This is easy.  */
  2704.           if (!(flags & SUPPRESS))
  2705.             {
  2706.               *str++ = c;
  2707.               if ((flags & MALLOC)
  2708.               && (char *) str == *strptr + strsize)
  2709.             {
  2710.               /* Enlarge the buffer.  */
  2711.               size_t newsize = 2 * strsize;
  2712.  
  2713.             allocagain:
  2714.               str = (char *) realloc (*strptr, newsize);
  2715.               if (str == NULL)
  2716.                 {
  2717.                   /* Can't allocate that much.  Last-ditch
  2718.                  effort.  */
  2719.                   if (newsize > strsize + 1)
  2720.                 {
  2721.                   newsize = strsize + 1;
  2722.                   goto allocagain;
  2723.                 }
  2724.                   if (flags & POSIX_MALLOC)
  2725.                 goto reteof;
  2726.                   /* We lose.  Oh well.  Terminate the
  2727.                  string and stop converting,
  2728.                  so at least we don't skip any input.  */
  2729.                   ((char *) (*strptr))[strsize - 1] = '\0';
  2730.                   strptr = NULL;
  2731.                   ++done;
  2732.                   conv_error ();
  2733.                 }
  2734.               else
  2735.                 {
  2736.                   *strptr = (char *) str;
  2737.                   str += strsize;
  2738.                   strsize = newsize;
  2739.                 }
  2740.             }
  2741.             }
  2742.         }
  2743.           while (--width > 0 && inchar () != EOF);
  2744. #endif
  2745.  
  2746.           if (__builtin_expect (now == read_in, 0))
  2747.         /* We haven't succesfully read any character.  */
  2748.         conv_error ();
  2749.  
  2750.           if (!(flags & SUPPRESS))
  2751.         {
  2752. #ifdef COMPILE_WSCANF
  2753.           /* We have to emit the code to get into the initial
  2754.              state.  */
  2755.           char buf[MB_LEN_MAX];
  2756.           size_t n = __wcrtomb (buf, L'\0', &state);
  2757.           if (n > 0 && (flags & MALLOC)
  2758.               && str + n >= *strptr + strsize)
  2759.             {
  2760.               /* Enlarge the buffer.  */
  2761.               size_t strleng = str - *strptr;
  2762.               char *newstr;
  2763.  
  2764.               newstr = (char *) realloc (*strptr, strleng + n + 1);
  2765.               if (newstr == NULL)
  2766.             {
  2767.               if (flags & POSIX_MALLOC)
  2768.                 goto reteof;
  2769.               /* We lose.  Oh well.  Terminate the string
  2770.                  and stop converting, so at least we don't
  2771.                  skip any input.  */
  2772.               ((char *) (*strptr))[strleng] = '\0';
  2773.               strptr = NULL;
  2774.               ++done;
  2775.               conv_error ();
  2776.             }
  2777.               else
  2778.             {
  2779.               *strptr = newstr;
  2780.               str = newstr + strleng;
  2781.               strsize = strleng + n + 1;
  2782.             }
  2783.             }
  2784.  
  2785.           str = __mempcpy (str, buf, n);
  2786. #endif
  2787.           *str++ = '\0';
  2788.  
  2789.           if ((flags & MALLOC) && str - *strptr != strsize)
  2790.             {
  2791.               char *cp = (char *) realloc (*strptr, str - *strptr);
  2792.               if (cp != NULL)
  2793.             *strptr = cp;
  2794.             }
  2795.           strptr = NULL;
  2796.  
  2797.           ++done;
  2798.         }
  2799.         }
  2800.       break;
  2801.  
  2802.     case L_('p'):   /* Generic pointer.  */
  2803.       base = 16;
  2804.       /* A PTR must be the same size as a `long int'.  */
  2805.       flags &= ~(SHORT|LONGDBL);
  2806.       if (need_long)
  2807.         flags |= LONG;
  2808.       flags |= READ_POINTER;
  2809.       goto number;
  2810.  
  2811.     default:
  2812.       /* If this is an unknown format character punt.  */
  2813.       conv_error ();
  2814.     }
  2815.     }
  2816.  
  2817.   /* The last thing we saw int the format string was a white space.
  2818.      Consume the last white spaces.  */
  2819.   if (skip_space)
  2820.     {
  2821.       do
  2822.     c = inchar ();
  2823.       while (ISSPACE (c));
  2824.       ungetc (c, s);
  2825.     }
  2826.  
  2827.  errout:
  2828.   /* Unlock stream.  */
  2829.   UNLOCK_STREAM (s);
  2830.  
  2831.   if (errp != NULL)
  2832.     *errp |= errval;
  2833.  
  2834.   if (done == EOF)
  2835.     {
  2836.   reteof:
  2837.       if (__builtin_expect (ptrs_to_free != NULL, 0))
  2838.     {
  2839.       struct ptrs_to_free *p = ptrs_to_free;
  2840.       while (p != NULL)
  2841.         {
  2842.           for (size_t cnt = 0; cnt < p->count; ++cnt)
  2843.         {
  2844.           free (*p->ptrs[cnt]);
  2845.           *p->ptrs[cnt] = NULL;
  2846.         }
  2847.           p = p->next;
  2848.           ptrs_to_free = p;
  2849.         }
  2850.     }
  2851.       return EOF;
  2852.     }
  2853.   else if (__builtin_expect (strptr != NULL, 0))
  2854.     {
  2855.       free (*strptr);
  2856.       *strptr = NULL;
  2857.     }
  2858.   return done;
  2859. }
  2860.  
  2861. #ifdef COMPILE_WSCANF
  2862. int
  2863. __vfwscanf (FILE *s, const wchar_t *format, va_list argptr)
  2864. {
  2865.   return _IO_vfwscanf (s, format, argptr, NULL);
  2866. }
  2867. ldbl_weak_alias (__vfwscanf, vfwscanf)
  2868. #else
  2869. int
  2870. ___vfscanf (FILE *s, const char *format, va_list argptr)
  2871. {
  2872.   return _IO_vfscanf_internal (s, format, argptr, NULL);
  2873. }
  2874. ldbl_strong_alias (_IO_vfscanf_internal, _IO_vfscanf)
  2875. ldbl_strong_alias (___vfscanf, __vfscanf)
  2876. ldbl_hidden_def (___vfscanf, __vfscanf)
  2877. ldbl_weak_alias (___vfscanf, vfscanf)
  2878. #endif
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!