update from main archive 970304
[kopensolaris-gnu/glibc.git] / stdio-common / vfscanf.c
1 /* Copyright (C) 1991, 92, 93, 94, 95, 96, 97 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 Library General Public License as
6    published by the Free Software Foundation; either version 2 of the
7    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    Library General Public License for more details.
13
14    You should have received a copy of the GNU Library General Public
15    License along with the GNU C Library; see the file COPYING.LIB.  If not,
16    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17    Boston, MA 02111-1307, USA.  */
18
19 #include "../locale/localeinfo.h"
20 #include <errno.h>
21 #include <limits.h>
22 #include <ctype.h>
23 #include <stdarg.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <wctype.h>
28 #include <libc-lock.h>
29
30 #ifdef  __GNUC__
31 #define HAVE_LONGLONG
32 #define LONGLONG        long long
33 #else
34 #define LONGLONG        long
35 #endif
36
37 /* Those are flags in the conversion format. */
38 # define LONG           0x001   /* l: long or double */
39 # define LONGDBL        0x002   /* L: long long or long double */
40 # define SHORT          0x004   /* h: short */
41 # define SUPPRESS       0x008   /* *: suppress assignment */
42 # define POINTER        0x010   /* weird %p pointer (`fake hex') */
43 # define NOSKIP         0x020   /* do not skip blanks */
44 # define WIDTH          0x040   /* width was given */
45 # define GROUP          0x080   /* ': group numbers */
46 # define MALLOC         0x100   /* a: malloc strings */
47
48 # define TYPEMOD        (LONG|LONGDBL|SHORT)
49
50
51 #ifdef USE_IN_LIBIO
52 # include <libioP.h>
53 # include <libio.h>
54
55 # undef va_list
56 # define va_list        _IO_va_list
57 # define ungetc(c, s)   (--read_in, _IO_ungetc (c, s))
58 # define inchar()       ((c = _IO_getc_unlocked (s)), (void) ++read_in, c)
59 # define encode_error() do {                                                  \
60                           if (errp != NULL) *errp |= 4;                       \
61                           _IO_funlockfile (s);                                \
62                           __set_errno (EILSEQ);                               \
63                           return done;                                        \
64                         } while (0)
65 # define conv_error()   do {                                                  \
66                           if (errp != NULL) *errp |= 2;                       \
67                           _IO_funlockfile (s);                                \
68                           return done;                                        \
69                         } while (0)
70 # define input_error()  do {                                                  \
71                           _IO_funlockfile (s);                                \
72                           if (errp != NULL) *errp |= 1;                       \
73                           return done ?: EOF;                                 \
74                         } while (0)
75 # define memory_error() do {                                                  \
76                           _IO_funlockfile (s);                                \
77                           __set_errno (ENOMEM);                               \
78                           return EOF;                                         \
79                         } while (0)
80 # define ARGCHECK(s, format)                                                  \
81   do                                                                          \
82     {                                                                         \
83       /* Check file argument for consistence.  */                             \
84       CHECK_FILE (s, EOF);                                                    \
85       if (s->_flags & _IO_NO_READS)                                           \
86         {                                                                     \
87           __set_errno (EBADF);                                                \
88           return EOF;                                                         \
89         }                                                                     \
90       else if (format == NULL)                                                \
91         {                                                                     \
92           MAYBE_SET_EINVAL;                                                   \
93           return EOF;                                                         \
94         }                                                                     \
95     } while (0)
96 # define LOCK_STREAM(S)                                                       \
97   __libc_cleanup_region_start ((void (*) (void *)) &_IO_funlockfile, (S));    \
98   _IO_flockfile (S)
99 # define UNLOCK_STREAM __libc_cleanup_region_end (1)
100 #else
101 # define ungetc(c, s)   (--read_in, ungetc (c, s))
102 # define inchar()       ((c = getc (s)), (void) ++read_in, c)
103 # define encode_error() do {                                                  \
104                           funlockfile (s);                                    \
105                           __set_errno (EILSEQ);                               \
106                           return done;                                        \
107                         } while (0)
108 # define conv_error()   do {                                                  \
109                           funlockfile (s);                                    \
110                           return done;                                        \
111                         } while (0)
112 # define input_error()  do {                                                  \
113                           funlockfile (s);                                    \
114                           return done ?: EOF;                                 \
115                         } while (0)
116 # define memory_error() do {                                                  \
117                           funlockfile (s);                                    \
118                           __set_errno (ENOMEM);                               \
119                           return EOF;                                         \
120                         } while (0)
121 # define ARGCHECK(s, format)                                                  \
122   do                                                                          \
123     {                                                                         \
124       /* Check file argument for consistence.  */                             \
125       if (!__validfp (s) || !s->__mode.__read)                                \
126         {                                                                     \
127           __set_errno (EBADF);                                                \
128           return EOF;                                                         \
129         }                                                                     \
130       else if (format == NULL)                                                \
131         {                                                                     \
132           __set_errno (EINVAL);                                               \
133           return EOF;                                                         \
134         }                                                                     \
135     } while (0)
136 #if 1
137       /* XXX For now !!! */
138 # define flockfile(S) /* nothing */
139 # define funlockfile(S) /* nothing */
140 # define LOCK_STREAM(S)
141 # define UNLOCK_STREAM
142 #else
143 # define LOCK_STREAM(S)                                                       \
144   __libc_cleanup_region_start (&__funlockfile, (S));                          \
145   __flockfile (S)
146 # define UNLOCK_STREAM __libc_cleanup_region_end (1)
147 #endif
148 #endif
149
150
151 /* Read formatted input from S according to the format string
152    FORMAT, using the argument list in ARG.
153    Return the number of assignments made, or -1 for an input error.  */
154 #ifdef USE_IN_LIBIO
155 int
156 _IO_vfscanf (s, format, argptr, errp)
157      _IO_FILE *s;
158      const char *format;
159      _IO_va_list argptr;
160      int *errp;
161 #else
162 int
163 __vfscanf (FILE *s, const char *format, va_list argptr)
164 #endif
165 {
166   va_list arg = (va_list) argptr;
167
168   register const char *f = format;
169   register unsigned char fc;    /* Current character of the format.  */
170   register size_t done = 0;     /* Assignments done.  */
171   register size_t read_in = 0;  /* Chars read in.  */
172   register int c = 0;           /* Last char read.  */
173   register int width;           /* Maximum field width.  */
174   register int flags;           /* Modifiers for current format element.  */
175
176   /* Status for reading F-P nums.  */
177   char got_dot, got_e, negative;
178   /* If a [...] is a [^...].  */
179   char not_in;
180 #define exp_char not_in
181   /* Base for integral numbers.  */
182   int base;
183   /* Signedness for integral numbers.  */
184   int number_signed;
185 #define is_hexa number_signed
186   /* Decimal point character.  */
187   wchar_t decimal;
188   /* The thousands character of the current locale.  */
189   wchar_t thousands;
190   /* Integral holding variables.  */
191   union
192     {
193       long long int q;
194       unsigned long long int uq;
195       long int l;
196       unsigned long int ul;
197     } num;
198   /* Character-buffer pointer.  */
199   char *str = NULL;
200   wchar_t *wstr = NULL;
201   char **strptr = NULL;
202   size_t strsize = 0;
203   /* We must not react on white spaces immediately because they can
204      possibly be matched even if in the input stream no character is
205      available anymore.  */
206   int skip_space = 0;
207   /* Workspace.  */
208   char *tw;                     /* Temporary pointer.  */
209   char *wp = NULL;              /* Workspace.  */
210   size_t wpmax = 0;             /* Maximal size of workspace.  */
211   size_t wpsize;                /* Currently used bytes in workspace.  */
212 #define ADDW(Ch)                                                            \
213   do                                                                        \
214     {                                                                       \
215       if (wpsize == wpmax)                                                  \
216         {                                                                   \
217           char *old = wp;                                                   \
218           wpmax = UCHAR_MAX > 2 * wpmax ? UCHAR_MAX : 2 * wpmax;            \
219           wp = (char *) alloca (wpmax);                                     \
220           if (old != NULL)                                                  \
221             memcpy (wp, old, wpsize);                                       \
222         }                                                                   \
223       wp[wpsize++] = (Ch);                                                  \
224     }                                                                       \
225   while (0)
226
227   ARGCHECK (s, format);
228
229   /* Figure out the decimal point character.  */
230   if (mbtowc (&decimal, _NL_CURRENT (LC_NUMERIC, DECIMAL_POINT),
231               strlen (_NL_CURRENT (LC_NUMERIC, DECIMAL_POINT))) <= 0)
232     decimal = (wchar_t) *_NL_CURRENT (LC_NUMERIC, DECIMAL_POINT);
233   /* Figure out the thousands separator character.  */
234   if (mbtowc (&thousands, _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP),
235               strlen (_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP))) <= 0)
236     thousands = (wchar_t) *_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
237
238   /* Lock the stream.  */
239   LOCK_STREAM (s);
240
241   /* Run through the format string.  */
242   while (*f != '\0')
243     {
244       unsigned int argpos;
245       /* Extract the next argument, which is of type TYPE.
246          For a %N$... spec, this is the Nth argument from the beginning;
247          otherwise it is the next argument after the state now in ARG.  */
248 #if 0
249       /* XXX Possible optimization.  */
250 # define ARG(type)      (argpos == 0 ? va_arg (arg, type) :                   \
251                          ({ va_list arg = (va_list) argptr;                   \
252                             arg = (va_list) ((char *) arg                     \
253                                              + (argpos - 1)                   \
254                                              * __va_rounded_size (void *));   \
255                             va_arg (arg, type);                               \
256                          }))
257 #else
258 # define ARG(type)      (argpos == 0 ? va_arg (arg, type) :                   \
259                          ({ unsigned int pos = argpos;                        \
260                             va_list arg = (va_list) argptr;                   \
261                             while (--pos > 0)                                 \
262                               (void) va_arg (arg, void *);                    \
263                             va_arg (arg, type);                               \
264                           }))
265 #endif
266
267       if (!isascii (*f))
268         {
269           /* Non-ASCII, may be a multibyte.  */
270           int len = mblen (f, strlen (f));
271           if (len > 0)
272             {
273               do
274                 {
275                   c = inchar ();
276                   if (c == EOF)
277                     input_error ();
278                   else if (c != *f++)
279                     {
280                       ungetc (c, s);
281                       conv_error ();
282                     }
283                 }
284               while (--len > 0);
285               continue;
286             }
287         }
288
289       fc = *f++;
290       if (fc != '%')
291         {
292           /* Remember to skip spaces.  */
293           if (isspace (fc))
294             {
295               skip_space = 1;
296               continue;
297             }
298
299           /* Read a character.  */
300           c = inchar ();
301
302           /* Characters other than format specs must just match.  */
303           if (c == EOF)
304             input_error ();
305
306           /* We saw white space char as the last character in the format
307              string.  Now it's time to skip all leading white space.  */
308           if (skip_space)
309             {
310               while (isspace (c))
311                 if (inchar () == EOF && errno == EINTR)
312                   conv_error ();
313               skip_space = 0;
314             }
315
316           if (c != fc)
317             {
318               ungetc (c, s);
319               conv_error ();
320             }
321
322           continue;
323         }
324
325       /* This is the start of the conversion string. */
326       flags = 0;
327
328       /* Initialize state of modifiers.  */
329       argpos = 0;
330
331       /* Prepare temporary buffer.  */
332       wpsize = 0;
333
334       /* Check for a positional parameter specification.  */
335       if (isdigit (*f))
336         {
337           argpos = *f++ - '0';
338           while (isdigit (*f))
339             argpos = argpos * 10 + (*f++ - '0');
340           if (*f == '$')
341             ++f;
342           else
343             {
344               /* Oops; that was actually the field width.  */
345               width = argpos;
346               flags |= WIDTH;
347               argpos = 0;
348               goto got_width;
349             }
350         }
351
352       /* Check for the assignment-suppressing and the number grouping flag.  */
353       while (*f == '*' || *f == '\'')
354         switch (*f++)
355           {
356           case '*':
357             flags |= SUPPRESS;
358             break;
359           case '\'':
360             flags |= GROUP;
361             break;
362           }
363
364       /* We have seen width. */
365       if (isdigit (*f))
366         flags |= WIDTH;
367
368       /* Find the maximum field width.  */
369       width = 0;
370       while (isdigit (*f))
371         {
372           width *= 10;
373           width += *f++ - '0';
374         }
375     got_width:
376       if (width == 0)
377         width = -1;
378
379       /* Check for type modifiers.  */
380       while (*f == 'h' || *f == 'l' || *f == 'L' || *f == 'a' || *f == 'q')
381         switch (*f++)
382           {
383           case 'h':
384             /* int's are short int's.  */
385             if (flags & TYPEMOD)
386               /* Signal illegal format element.  */
387               conv_error ();
388             flags |= SHORT;
389             break;
390           case 'l':
391             if (flags & (SHORT|LONGDBL))
392               conv_error ();
393             else if (flags & LONG)
394               {
395                 /* A double `l' is equivalent to an `L'.  */
396                 flags &= ~LONG;
397                 flags |= LONGDBL;
398               }
399             else
400               /* int's are long int's.  */
401               flags |= LONG;
402             break;
403           case 'q':
404           case 'L':
405             /* double's are long double's, and int's are long long int's.  */
406             if (flags & TYPEMOD)
407               /* Signal illegal format element.  */
408               conv_error ();
409             flags |= LONGDBL;
410             break;
411           case 'a':
412             if (flags & TYPEMOD)
413               /* Signal illegal format element.  */
414               conv_error ();
415             /* String conversions (%s, %[) take a `char **'
416                arg and fill it in with a malloc'd pointer.  */
417             flags |= MALLOC;
418             break;
419           }
420
421       /* End of the format string?  */
422       if (*f == '\0')
423         conv_error ();
424
425       /* We must take care for EINTR errors.  */
426       if (c == EOF && errno == EINTR)
427         input_error ();
428
429       /* Find the conversion specifier.  */
430       fc = *f++;
431       if (skip_space || (fc != '[' && fc != 'c' && fc != 'C' && fc != 'n'))
432         {
433           /* Eat whitespace.  */
434           do
435             if (inchar () == EOF && errno == EINTR)
436               input_error ();
437           while (isspace (c));
438           ungetc (c, s);
439           skip_space = 0;
440         }
441
442       switch (fc)
443         {
444         case '%':       /* Must match a literal '%'.  */
445           c = inchar ();
446           if (c != fc)
447             {
448               ungetc (c, s);
449               conv_error ();
450             }
451           break;
452
453         case 'n':       /* Answer number of assignments done.  */
454           /* Corrigendum 1 to ISO C 1990 describes the allowed flags
455              with the 'n' conversion specifier.  */
456           if (!(flags & SUPPRESS))
457             {
458               /* Don't count the read-ahead.  */
459               if (flags & LONGDBL)
460                 *ARG (long long int *) = read_in;
461               else if (flags & LONG)
462                 *ARG (long int *) = read_in;
463               else if (flags & SHORT)
464                 *ARG (short int *) = read_in;
465               else
466                 *ARG (int *) = read_in;
467
468 #ifdef NO_BUG_IN_ISO_C_CORRIGENDUM_1
469               /* We have a severe problem here.  The ISO C standard
470                  contradicts itself in explaining the effect of the %n
471                  format in `scanf'.  While in ISO C:1990 and the ISO C
472                  Amendement 1:1995 the result is described as
473
474                    Execution of a %n directive does not effect the
475                    assignment count returned at the completion of
476                    execution of the f(w)scanf function.
477
478                  in ISO C Corrigendum 1:1994 the following was added:
479
480                    Subclause 7.9.6.2
481                    Add the following fourth example:
482                      In:
483                        #include <stdio.h>
484                        int d1, d2, n1, n2, i;
485                        i = sscanf("123", "%d%n%n%d", &d1, &n1, &n2, &d2);
486                      the value 123 is assigned to d1 and the value3 to n1.
487                      Because %n can never get an input failure the value
488                      of 3 is also assigned to n2.  The value of d2 is not
489                      affected.  The value 3 is assigned to i.
490
491                  We go for now with the historically correct code fro ISO C,
492                  i.e., we don't count the %n assignments.  When it ever
493                  should proof to be wrong just remove the #ifdef above.  */
494               ++done;
495 #endif
496             }
497           break;
498
499         case 'c':       /* Match characters.  */
500           if ((flags & LONG) == 0)
501             {
502               if (!(flags & SUPPRESS))
503                 {
504                   str = ARG (char *);
505                   if (str == NULL)
506                     conv_error ();
507                 }
508
509               c = inchar ();
510               if (c == EOF)
511                 input_error ();
512
513               if (width == -1)
514                 width = 1;
515
516               if (!(flags & SUPPRESS))
517                 {
518                   do
519                     *str++ = c;
520                   while (--width > 0 && inchar () != EOF);
521                 }
522               else
523                 while (--width > 0 && inchar () != EOF);
524
525               if (width > 0)
526                 /* I.e., EOF was read.  */
527                 --read_in;
528
529               if (!(flags & SUPPRESS))
530                 ++done;
531
532               break;
533             }
534           /* FALLTHROUGH */
535         case 'C':
536           /* Get UTF-8 encoded wide character.  Here we assume (as in
537              other parts of the libc) that we only have to handle
538              UTF-8.  */
539           {
540             wint_t val;
541             size_t cnt = 0;
542             int first = 1;
543
544             if (!(flags & SUPPRESS))
545               {
546                 wstr = ARG (wchar_t *);
547                 if (str == NULL)
548                   conv_error ();
549               }
550
551             do
552               {
553 #define NEXT_WIDE_CHAR(First)                                                 \
554                 c = inchar ();                                                \
555                 if (c == EOF)                                                 \
556                   /* EOF is only an error for the first character.  */        \
557                   if (First)                                                  \
558                     input_error ();                                           \
559                   else                                                        \
560                     {                                                         \
561                       --read_in;                                              \
562                       break;                                                  \
563                     }                                                         \
564                 val = c;                                                      \
565                 if (val >= 0x80)                                              \
566                   {                                                           \
567                     if ((c & 0xc0) == 0x80 || (c & 0xfe) == 0xfe)             \
568                       encode_error ();                                        \
569                     if ((c & 0xe0) == 0xc0)                                   \
570                       {                                                       \
571                         /* We expect two bytes.  */                           \
572                         cnt = 1;                                              \
573                         val &= 0x1f;                                          \
574                       }                                                       \
575                     else if ((c & 0xf0) == 0xe0)                              \
576                       {                                                       \
577                         /* We expect three bytes.  */                         \
578                         cnt = 2;                                              \
579                         val &= 0x0f;                                          \
580                       }                                                       \
581                     else if ((c & 0xf8) == 0xf0)                              \
582                       {                                                       \
583                         /* We expect four bytes.  */                          \
584                         cnt = 3;                                              \
585                         val &= 0x07;                                          \
586                       }                                                       \
587                     else if ((c & 0xfc) == 0xf8)                              \
588                       {                                                       \
589                         /* We expect five bytes.  */                          \
590                         cnt = 4;                                              \
591                         val &= 0x03;                                          \
592                       }                                                       \
593                     else                                                      \
594                       {                                                       \
595                         /* We expect six bytes.  */                           \
596                         cnt = 5;                                              \
597                         val &= 0x01;                                          \
598                       }                                                       \
599                                                                               \
600                     do                                                        \
601                       {                                                       \
602                         c = inchar ();                                        \
603                         if (c == EOF                                          \
604                             || (c & 0xc0) == 0x80 || (c & 0xfe) == 0xfe)      \
605                           encode_error ();                                    \
606                         val <<= 6;                                            \
607                         val |= c & 0x3f;                                      \
608                       }                                                       \
609                     while (--cnt > 0);                                        \
610                   }                                                           \
611                                                                               \
612                 if (!(flags & SUPPRESS))                                      \
613                   *wstr++ = val;                                              \
614                 first = 0
615
616                 NEXT_WIDE_CHAR (first);
617               }
618             while (--width > 0);
619
620             if (width > 0)
621               /* I.e., EOF was read.  */
622               --read_in;
623
624             if (!(flags & SUPPRESS))
625               ++done;
626           }
627           break;
628
629         case 's':               /* Read a string.  */
630           if (flags & LONG)
631             /* We have to process a wide character string.  */
632             goto wide_char_string;
633
634 #define STRING_ARG(Str, Type)                                                 \
635           if (!(flags & SUPPRESS))                                            \
636             {                                                                 \
637               if (flags & MALLOC)                                             \
638                 {                                                             \
639                   /* The string is to be stored in a malloc'd buffer.  */     \
640                   strptr = ARG (char **);                                     \
641                   if (strptr == NULL)                                         \
642                     conv_error ();                                            \
643                   /* Allocate an initial buffer.  */                          \
644                   strsize = 100;                                              \
645                   *strptr = malloc (strsize * sizeof (Type));                 \
646                   Str = (Type *) *strptr;                                     \
647                 }                                                             \
648               else                                                            \
649                 Str = ARG (Type *);                                           \
650               if (Str == NULL)                                                \
651                 conv_error ();                                                \
652             }
653           STRING_ARG (str, char);
654
655           c = inchar ();
656           if (c == EOF)
657             input_error ();
658
659           do
660             {
661               if (isspace (c))
662                 {
663                   ungetc (c, s);
664                   break;
665                 }
666 #define STRING_ADD_CHAR(Str, c, Type)                                         \
667               if (!(flags & SUPPRESS))                                        \
668                 {                                                             \
669                   *Str++ = c;                                                 \
670                   if ((flags & MALLOC) && (char *) Str == *strptr + strsize)  \
671                     {                                                         \
672                       /* Enlarge the buffer.  */                              \
673                       Str = realloc (*strptr, strsize * 2 * sizeof (Type));   \
674                       if (Str == NULL)                                        \
675                         {                                                     \
676                           /* Can't allocate that much.  Last-ditch effort.  */\
677                           Str = realloc (*strptr,                             \
678                                          (strsize + 1) * sizeof (Type));      \
679                           if (Str == NULL)                                    \
680                             {                                                 \
681                               /* We lose.  Oh well.                           \
682                                  Terminate the string and stop converting,    \
683                                  so at least we don't skip any input.  */     \
684                               ((Type *) (*strptr))[strsize] = '\0';           \
685                               ++done;                                         \
686                               conv_error ();                                  \
687                             }                                                 \
688                           else                                                \
689                             {                                                 \
690                               *strptr = (char *) Str;                         \
691                               Str = ((Type *) *strptr) + strsize;             \
692                               ++strsize;                                      \
693                             }                                                 \
694                         }                                                     \
695                       else                                                    \
696                         {                                                     \
697                           *strptr = (char *) Str;                             \
698                           Str = ((Type *) *strptr) + strsize;                 \
699                           strsize *= 2;                                       \
700                         }                                                     \
701                     }                                                         \
702                 }
703               STRING_ADD_CHAR (str, c, char);
704             } while ((width <= 0 || --width > 0) && inchar () != EOF);
705
706           if (c == EOF)
707             --read_in;
708
709           if (!(flags & SUPPRESS))
710             {
711               *str = '\0';
712               ++done;
713             }
714           break;
715
716         case 'S':
717           /* Wide character string.  */
718         wide_char_string:
719           {
720             wint_t val;
721             int first = 1;
722             STRING_ARG (wstr, wchar_t);
723
724             do
725               {
726                 size_t cnt = 0;
727                 NEXT_WIDE_CHAR (first);
728
729                 if (iswspace (val))
730                   {
731                     /* XXX We would have to push back the whole wide char
732                        with possibly many bytes.  But since scanf does
733                        not make a difference for white space characters
734                        we can simply push back a simple <SP> which is
735                        guaranteed to be in the [:space:] class.  */
736                     ungetc (' ', s);
737                     break;
738                   }
739
740                 STRING_ADD_CHAR (wstr, val, wchar_t);
741                 first = 0;
742               }
743             while (width <= 0 || --width > 0);
744
745             if (!(flags & SUPPRESS))
746               {
747                 *wstr = L'\0';
748                 ++done;
749               }
750           }
751           break;
752
753         case 'x':       /* Hexadecimal integer.  */
754         case 'X':       /* Ditto.  */
755           base = 16;
756           number_signed = 0;
757           goto number;
758
759         case 'o':       /* Octal integer.  */
760           base = 8;
761           number_signed = 0;
762           goto number;
763
764         case 'u':       /* Unsigned decimal integer.  */
765           base = 10;
766           number_signed = 0;
767           goto number;
768
769         case 'd':       /* Signed decimal integer.  */
770           base = 10;
771           number_signed = 1;
772           goto number;
773
774         case 'i':       /* Generic number.  */
775           base = 0;
776           number_signed = 1;
777
778         number:
779           c = inchar ();
780           if (c == EOF)
781             input_error ();
782
783           /* Check for a sign.  */
784           if (c == '-' || c == '+')
785             {
786               ADDW (c);
787               if (width > 0)
788                 --width;
789               c = inchar ();
790             }
791
792           /* Look for a leading indication of base.  */
793           if (width != 0 && c == '0')
794             {
795               if (width > 0)
796                 --width;
797
798               ADDW (c);
799               c = inchar ();
800
801               if (width != 0 && tolower (c) == 'x')
802                 {
803                   if (base == 0)
804                     base = 16;
805                   if (base == 16)
806                     {
807                       if (width > 0)
808                         --width;
809                       c = inchar ();
810                     }
811                 }
812               else if (base == 0)
813                 base = 8;
814             }
815
816           if (base == 0)
817             base = 10;
818
819           /* Read the number into workspace.  */
820           while (c != EOF && width != 0)
821             {
822               if (base == 16 ? !isxdigit (c) :
823                   ((!isdigit (c) || c - '0' >= base) &&
824                    !((flags & GROUP) && base == 10 && c == thousands)))
825                 break;
826               ADDW (c);
827               if (width > 0)
828                 --width;
829
830               c = inchar ();
831             }
832
833           /* The just read character is not part of the number anymore.  */
834           ungetc (c, s);
835
836           if (wpsize == 0 ||
837               (wpsize == 1 && (wp[0] == '+' || wp[0] == '-')))
838             /* There was no number.  */
839             conv_error ();
840
841           /* Convert the number.  */
842           ADDW ('\0');
843           if (flags & LONGDBL)
844             {
845               if (number_signed)
846                 num.q = __strtoll_internal (wp, &tw, base, flags & GROUP);
847               else
848                 num.uq = __strtoull_internal (wp, &tw, base, flags & GROUP);
849             }
850           else
851             {
852               if (number_signed)
853                 num.l = __strtol_internal (wp, &tw, base, flags & GROUP);
854               else
855                 num.ul = __strtoul_internal (wp, &tw, base, flags & GROUP);
856             }
857           if (wp == tw)
858             conv_error ();
859
860           if (!(flags & SUPPRESS))
861             {
862               if (! number_signed)
863                 {
864                   if (flags & LONGDBL)
865                     *ARG (unsigned LONGLONG int *) = num.uq;
866                   else if (flags & LONG)
867                     *ARG (unsigned long int *) = num.ul;
868                   else if (flags & SHORT)
869                     *ARG (unsigned short int *)
870                       = (unsigned short int) num.ul;
871                   else
872                     *ARG (unsigned int *) = (unsigned int) num.ul;
873                 }
874               else
875                 {
876                   if (flags & LONGDBL)
877                     *ARG (LONGLONG int *) = num.q;
878                   else if (flags & LONG)
879                     *ARG (long int *) = num.l;
880                   else if (flags & SHORT)
881                     *ARG (short int *) = (short int) num.l;
882                   else
883                     *ARG (int *) = (int) num.l;
884                 }
885               ++done;
886             }
887           break;
888
889         case 'e':       /* Floating-point numbers.  */
890         case 'E':
891         case 'f':
892         case 'g':
893         case 'G':
894         case 'A':
895           c = inchar ();
896           if (c == EOF)
897             input_error ();
898
899           /* Check for a sign.  */
900           if (c == '-' || c == '+')
901             {
902               negative = c == '-';
903               if (inchar () == EOF)
904                 /* EOF is only an input error before we read any chars.  */
905                 conv_error ();
906               if (width > 0)
907                 --width;
908             }
909           else
910             negative = 0;
911
912           if (c == '0' && tolower (c == inchar ()) == 'x')
913             {
914               /* It is a number in hexadecimal format.  */
915               ADDW ('0');
916               ADDW ('x');
917
918               is_hexa = 1;
919               exp_char = 'p';
920
921               /* Grouping is not allowed.  */
922               flags &= ~GROUP;
923               c = inchar ();
924             }
925           else
926             {
927               /* It not a hexadecimal prefix.  */
928               is_hexa = 0;
929               exp_char = 'e';
930             }
931
932           got_dot = got_e = 0;
933           do
934             {
935               if (isdigit (c))
936                 ADDW (c);
937               else if (!got_e && is_hexa && isxdigit (c))
938                 ADDW (c);
939               else if (got_e && wp[wpsize - 1] == exp_char
940                        && (c == '-' || c == '+'))
941                 ADDW (c);
942               else if (wpsize > 0 && !got_e && tolower (c) == exp_char)
943                 {
944                   ADDW (exp_char);
945                   got_e = got_dot = 1;
946                 }
947               else if (c == decimal && !got_dot)
948                 {
949                   ADDW (c);
950                   got_dot = 1;
951                 }
952               else if ((flags & GROUP) && c == thousands && !got_dot)
953                 ADDW (c);
954               else
955                 {
956                   /* The last read character is not part of the number
957                      anymore.  */
958                   ungetc (c, s);
959                   break;
960                 }
961               if (width > 0)
962                 --width;
963             }
964           while (width != 0 && inchar () != EOF);
965
966           /* Have we read any character?  If we try to read a number
967              in hexadecimal notation and we have read only the `0x'
968              prefix this is an error.  */
969           if (wpsize == 0 || (is_hexa && wpsize == 2))
970             conv_error ();
971
972           /* Convert the number.  */
973           ADDW ('\0');
974           if (flags & LONGDBL)
975             {
976               long double d = __strtold_internal (wp, &tw, flags & GROUP);
977               if (!(flags & SUPPRESS) && tw != wp)
978                 *ARG (long double *) = negative ? -d : d;
979             }
980           else if (flags & LONG)
981             {
982               double d = __strtod_internal (wp, &tw, flags & GROUP);
983               if (!(flags & SUPPRESS) && tw != wp)
984                 *ARG (double *) = negative ? -d : d;
985             }
986           else
987             {
988               float d = __strtof_internal (wp, &tw, flags & GROUP);
989               if (!(flags & SUPPRESS) && tw != wp)
990                 *ARG (float *) = negative ? -d : d;
991             }
992
993           if (tw == wp)
994             conv_error ();
995
996           if (!(flags & SUPPRESS))
997             ++done;
998           break;
999
1000         case '[':       /* Character class.  */
1001           if (flags & LONG)
1002             {
1003               STRING_ARG (wstr, wchar_t);
1004               c = '\0';         /* This is to keep gcc quiet.  */
1005             }
1006           else
1007             {
1008               STRING_ARG (str, char);
1009
1010               c = inchar ();
1011               if (c == EOF)
1012                 input_error ();
1013             }
1014
1015           if (*f == '^')
1016             {
1017               ++f;
1018               not_in = 1;
1019             }
1020           else
1021             not_in = 0;
1022
1023           /* Fill WP with byte flags indexed by character.
1024              We will use this flag map for matching input characters.  */
1025           if (wpmax < UCHAR_MAX)
1026             {
1027               wpmax = UCHAR_MAX;
1028               wp = (char *) alloca (wpmax);
1029             }
1030           memset (wp, 0, UCHAR_MAX);
1031
1032           fc = *f;
1033           if (fc == ']' || fc == '-')
1034             {
1035               /* If ] or - appears before any char in the set, it is not
1036                  the terminator or separator, but the first char in the
1037                  set.  */
1038               wp[fc] = 1;
1039               ++f;
1040             }
1041
1042           while ((fc = *f++) != '\0' && fc != ']')
1043             {
1044               if (fc == '-' && *f != '\0' && *f != ']' &&
1045                   (unsigned char) f[-2] <= (unsigned char) *f)
1046                 {
1047                   /* Add all characters from the one before the '-'
1048                      up to (but not including) the next format char.  */
1049                   for (fc = f[-2]; fc < *f; ++fc)
1050                     wp[fc] = 1;
1051                 }
1052               else
1053                 /* Add the character to the flag map.  */
1054                 wp[fc] = 1;
1055             }
1056           if (fc == '\0')
1057             {
1058               if (!(flags & LONG))
1059                 ungetc (c, s);
1060               conv_error();
1061             }
1062
1063           if (flags & LONG)
1064             {
1065               wint_t val;
1066               int first = 1;
1067
1068               do
1069                 {
1070                   size_t cnt = 0;
1071                   NEXT_WIDE_CHAR (first);
1072                   if (val > 255 || wp[val] == not_in)
1073                     {
1074                       /* XXX We have a problem here.  We read a wide
1075                          character and this possibly took several
1076                          bytes.  But we can only push back one single
1077                          character.  To be sure we don't create wrong
1078                          input we push it back only in case it is
1079                          representable within one byte.  */
1080                       if (val < 0x80)
1081                         ungetc (val, s);
1082                       break;
1083                     }
1084                   STRING_ADD_CHAR (wstr, val, wchar_t);
1085                   if (width > 0)
1086                     --width;
1087                   first = 0;
1088                 }
1089               while (width != 0);
1090
1091               if (first)
1092                 conv_error ();
1093
1094               if (!(flags & SUPPRESS))
1095                 {
1096                   *wstr = L'\0';
1097                   ++done;
1098                 }
1099             }
1100           else
1101             {
1102               num.ul = read_in - 1; /* -1 because we already read one char.  */
1103               do
1104                 {
1105                   if (wp[c] == not_in)
1106                     {
1107                       ungetc (c, s);
1108                       break;
1109                     }
1110                   STRING_ADD_CHAR (str, c, char);
1111                   if (width > 0)
1112                     --width;
1113                 }
1114               while (width != 0 && inchar () != EOF);
1115
1116               if (read_in == num.ul)
1117                 conv_error ();
1118
1119               if (!(flags & SUPPRESS))
1120                 {
1121                   *str = '\0';
1122                   ++done;
1123                 }
1124             }
1125           break;
1126
1127         case 'p':       /* Generic pointer.  */
1128           base = 16;
1129           /* A PTR must be the same size as a `long int'.  */
1130           flags &= ~(SHORT|LONGDBL);
1131           flags |= LONG;
1132           number_signed = 0;
1133           goto number;
1134         }
1135     }
1136
1137   /* The last thing we saw int the format string was a white space.
1138      Consume the last white spaces.  */
1139   if (skip_space)
1140     {
1141       do
1142         c = inchar ();
1143       while (isspace (c));
1144       ungetc (c, s);
1145     }
1146
1147   /* Unlock stream.  */
1148   UNLOCK_STREAM;
1149
1150   return done;
1151 }
1152
1153 #ifdef USE_IN_LIBIO
1154 int
1155 __vfscanf (FILE *s, const char *format, va_list argptr)
1156 {
1157   return _IO_vfscanf (s, format, argptr, NULL);
1158 }
1159 #endif
1160
1161 weak_alias (__vfscanf, vfscanf)