stdio-common/vfscanf.c

   1 /* Copyright (C) 1991, 92, 93, 94, 95, 96 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
  16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  17 Cambridge, MA 02139, USA.  */
  18
  19 #include <ansidecl.h>
  20 #include "../locale/localeinfo.h"
  21 #include <errno.h>
  22 #include <limits.h>
  23 #include <ctype.h>
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #ifdef  __GNUC__
  30 #define HAVE_LONGLONG
  31 #define LONGLONG        long long
  32 #else
  33 #define LONGLONG        long
  34 #endif
  35
  36 /* Those are flags in the conversion format. */
  37 # define LONG           0x001   /* l: long or double */
  38 # define LONGDBL        0x002   /* L: long long or long double */
  39 # define SHORT          0x004   /* h: short */
  40 # define SUPPRESS       0x008   /* *: suppress assignment */
  41 # define POINTER        0x010   /* weird %p pointer (`fake hex') */
  42 # define NOSKIP         0x020   /* do not skip blanks */
  43 # define WIDTH          0x040   /* width was given */
  44 # define GROUP          0x080   /* ': group numbers */
  45 # define MALLOC         0x100   /* a: malloc strings */
  46
  47 # define TYPEMOD        (LONG|LONGDBL|SHORT)
  48
  49
  50 #ifdef USE_IN_LIBIO
  51 # include <libioP.h>
  52 # include <libio.h>
  53
  54 # define va_list        _IO_va_list
  55 # define ungetc(c, s)   _IO_ungetc (c, s)
  56 # define inchar()       ((c = _IO_getc_unlocked (s)), (void) ++read_in, c)
  57 # define conv_error()   do {                                                  \
  58                           if (errp != NULL) *errp |= 2;                       \
  59                           if (c != EOF) _IO_ungetc (c, s);                    \
  60                           _IO_funlockfile (s);                                \
  61                           return done;                                        \
  62                         } while (0)
  63 # define input_error()  do {                                                  \
  64                           _IO_funlockfile (s);                                \
  65                           if (errp != NULL) *errp |= 1;                       \
  66                           return done ?: EOF;                                 \
  67                         } while (0)
  68 # define memory_error() do {                                                  \
  69                           _IO_funlockfile (s);                                \
  70                           errno = ENOMEM;                                     \
  71                           return EOF;                                         \
  72                         } while (0)
  73 # define ARGCHECK(s, format)                                                  \
  74   do                                                                          \
  75     {                                                                         \
  76       /* Check file argument for consistence.  */                             \
  77       CHECK_FILE (s, EOF);                                                    \
  78       if (s->_flags & _IO_NO_READS || format == NULL)                         \
  79        {                                                                      \
  80          MAYBE_SET_EINVAL;                                                    \
  81          return EOF;                                                          \
  82        }                                                                      \
  83     } while (0)
  84 # define flockfile(S) _IO_flockfile (S)
  85 # define funlockfile(S) _IO_funlockfile (S)
  86 #else
  87 # define inchar()       ((c = getc (s)), (void) ++read_in, c)
  88 # define conv_error()   do {                                                  \
  89                           funlockfile (s);                                    \
  90                           ungetc (c, s);                                      \
  91                           return done;                                        \
  92                         } while (0)
  93 # define input_error()  do {                                                  \
  94                           funlockfile (s);                                    \
  95                           return done ?: EOF;                                 \
  96                         } while (0)
  97 # define memory_error() do {                                                  \
  98                           funlockfile (s);                                    \
  99                           errno = ENOMEM;                                     \
 100                           return EOF;                                         \
 101                         } while (0)
 102 # define ARGCHECK(s, format)                                                  \
 103   do                                                                          \
 104     {                                                                         \
 105       /* Check file argument for consistence.  */                             \
 106       if (!__validfp (s) || !s->__mode.__read || format == NULL)              \
 107         {                                                                     \
 108           errno = EINVAL;                                                     \
 109           return EOF;                                                         \
 110         }                                                                     \
 111     } while (0)
 112 # define flockfile(S) /* nothing */
 113 # define funlockfile(S) /* nothing */
 114 #endif
 115
 116
 117 /* Read formatted input from S according to the format string
 118    FORMAT, using the argument list in ARG.
 119    Return the number of assignments made, or -1 for an input error.  */
 120 #ifdef USE_IN_LIBIO
 121 int
 122 _IO_vfscanf (s, format, argptr, errp)
 123      _IO_FILE *s;
 124      const char *format;
 125      _IO_va_list argptr;
 126      int *errp;
 127 #else
 128 int
 129 __vfscanf (FILE *s, const char *format, va_list argptr)
 130 #endif
 131 {
 132   va_list arg = (va_list) argptr;
 133
 134   register const char *f = format;
 135   register unsigned char fc;    /* Current character of the format.  */
 136   register size_t done = 0;     /* Assignments done.  */
 137   register size_t read_in = 0;  /* Chars read in.  */
 138   register int c;               /* Last char read.  */
 139   register int width;           /* Maximum field width.  */
 140   register int flags;           /* Modifiers for current format element.  */
 141
 142   /* Status for reading F-P nums.  */
 143   char got_dot, got_e, negative;
 144   /* If a [...] is a [^...].  */
 145   char not_in;
 146   /* Base for integral numbers.  */
 147   int base;
 148   /* Signedness for integral numbers.  */
 149   int number_signed;
 150   /* Decimal point character.  */
 151   wchar_t decimal;
 152   /* The thousands character of the current locale.  */
 153   wchar_t thousands;
 154   /* Integral holding variables.  */
 155   union
 156     {
 157       long long int q;
 158       unsigned long long int uq;
 159       long int l;
 160       unsigned long int ul;
 161     } num;
 162   /* Character-buffer pointer.  */
 163   register char *str, **strptr;
 164   size_t strsize;
 165   /* We must not react on white spaces immediately because they can
 166      possibly be matched even if in the input stream no character is
 167      available anymore.  */
 168   int skip_space = 0;
 169   /* Workspace.  */
 170   char *tw;                     /* Temporary pointer.  */
 171   char *wp = NULL;              /* Workspace.  */
 172   size_t wpmax = 0;             /* Maximal size of workspace.  */
 173   size_t wpsize;                /* Currently used bytes in workspace.  */
 174 #define ADDW(Ch)                                                            \
 175   do                                                                        \
 176     {                                                                       \
 177       if (wpsize == wpmax)                                                  \
 178         {                                                                   \
 179           char *old = wp;                                                   \
 180           wpmax = UCHAR_MAX > 2 * wpmax ? UCHAR_MAX : 2 * wpmax;            \
 181           wp = (char *) alloca (wpmax);                                     \
 182           if (old != NULL)                                                  \
 183             memcpy (wp, old, wpsize);                                       \
 184         }                                                                   \
 185       wp[wpsize++] = (Ch);                                                  \
 186     }                                                                       \
 187   while (0)
 188
 189   ARGCHECK (s, format);
 190
 191   /* Figure out the decimal point character.  */
 192   if (mbtowc (&decimal, _NL_CURRENT (LC_NUMERIC, DECIMAL_POINT),
 193               strlen (_NL_CURRENT (LC_NUMERIC, DECIMAL_POINT))) <= 0)
 194     decimal = (wchar_t) *_NL_CURRENT (LC_NUMERIC, DECIMAL_POINT);
 195   /* Figure out the thousands separator character.  */
 196   if (mbtowc (&thousands, _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP),
 197               strlen (_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP))) <= 0)
 198     thousands = (wchar_t) *_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
 199
 200   /* Lock the stream.  */
 201   flockfile (s);
 202
 203   c = inchar ();
 204
 205   /* Run through the format string.  */
 206   while (*f != '\0')
 207     {
 208       unsigned int argpos;
 209       /* Extract the next argument, which is of type TYPE.
 210          For a %N$... spec, this is the Nth argument from the beginning;
 211          otherwise it is the next argument after the state now in ARG.  */
 212 #if 0
 213       /* XXX Possible optimization.  */
 214 # define ARG(type)      (argpos == 0 ? va_arg (arg, type) :                   \
 215                          ({ va_list arg = (va_list) argptr;                   \
 216                             arg = (va_list) ((char *) arg                     \
 217                                              + (argpos - 1)                   \
 218                                              * __va_rounded_size (void *));   \
 219                             va_arg (arg, type);                               \
 220                          }))
 221 #else
 222 # define ARG(type)      (argpos == 0 ? va_arg (arg, type) :                   \
 223                          ({ unsigned int pos = argpos;                        \
 224                             va_list arg = (va_list) argptr;                   \
 225                             while (--pos > 0)                                 \
 226                               (void) va_arg (arg, void *);                    \
 227                             va_arg (arg, type);                               \
 228                           }))
 229 #endif
 230
 231       if (!isascii (*f))
 232         {
 233           /* Non-ASCII, may be a multibyte.  */
 234           int len = mblen (f, strlen (f));
 235           if (len > 0)
 236             {
 237               while (len-- > 0)
 238                 if (c == EOF)
 239                   input_error ();
 240                 else if (c == *f++)
 241                   (void) inchar ();
 242                 else
 243                   conv_error ();
 244               continue;
 245             }
 246         }
 247
 248       fc = *f++;
 249       if (fc != '%')
 250         {
 251           /* Remember to skip spaces.  */
 252           if (isspace (fc))
 253             {
 254               skip_space = 1;
 255               continue;
 256             }
 257
 258           /* Characters other than format specs must just match.  */
 259           if (c == EOF)
 260             input_error ();
 261
 262           /* We saw white space char as the last character in the format
 263              string.  Now it's time to skip all leading white space.  */
 264           if (skip_space)
 265             {
 266               while (isspace (c))
 267                 (void) inchar ();
 268               skip_space = 0;
 269             }
 270
 271           if (c == fc)
 272             (void) inchar ();
 273           else
 274             conv_error ();
 275
 276           continue;
 277         }
 278
 279       /* This is the start of the conversion string. */
 280       flags = 0;
 281
 282       /* Initialize state of modifiers.  */
 283       argpos = 0;
 284
 285       /* Prepare temporary buffer.  */
 286       wpsize = 0;
 287
 288       /* Check for a positional parameter specification.  */
 289       if (isdigit (*f))
 290         {
 291           argpos = *f++ - '0';
 292           while (isdigit (*f))
 293             argpos = argpos * 10 + (*f++ - '0');
 294           if (*f == '$')
 295             ++f;
 296           else
 297             {
 298               /* Oops; that was actually the field width.  */
 299               width = argpos;
 300               flags |= WIDTH;
 301               argpos = 0;
 302               goto got_width;
 303             }
 304         }
 305
 306       /* Check for the assignment-suppressant and the number grouping flag.  */
 307       while (*f == '*' || *f == '\'')
 308         switch (*f++)
 309           {
 310           case '*':
 311             flags |= SUPPRESS;
 312             break;
 313           case '\'':
 314             flags |= GROUP;
 315             break;
 316           }
 317
 318       /* We have seen width. */
 319       if (isdigit (*f))
 320         flags |= WIDTH;
 321
 322       /* Find the maximum field width.  */
 323       width = 0;
 324       while (isdigit (*f))
 325         {
 326           width *= 10;
 327           width += *f++ - '0';
 328         }
 329     got_width:
 330       if (width == 0)
 331         width = -1;
 332
 333       /* Check for type modifiers.  */
 334       while (*f == 'h' || *f == 'l' || *f == 'L' || *f == 'a' || *f == 'q')
 335         switch (*f++)
 336           {
 337           case 'h':
 338             /* int's are short int's.  */
 339             if (flags & TYPEMOD)
 340               /* Signal illegal format element.  */
 341               conv_error ();
 342             flags |= SHORT;
 343             break;
 344           case 'l':
 345             if (flags & (SHORT|LONGDBL))
 346               conv_error ();
 347             else if (flags & LONG)
 348               {
 349                 /* A double `l' is equivalent to an `L'.  */
 350                 flags &= ~LONG;
 351                 flags |= LONGDBL;
 352               }
 353             else
 354               /* int's are long int's.  */
 355               flags |= LONG;
 356             break;
 357           case 'q':
 358           case 'L':
 359             /* double's are long double's, and int's are long long int's.  */
 360             if (flags & TYPEMOD)
 361               /* Signal illegal format element.  */
 362               conv_error ();
 363             flags |= LONGDBL;
 364             break;
 365           case 'a':
 366             if (flags & TYPEMOD)
 367               /* Signal illegal format element.  */
 368               conv_error ();
 369             /* String conversions (%s, %[) take a `char **'
 370                arg and fill it in with a malloc'd pointer.  */
 371             flags |= MALLOC;
 372             break;
 373           }
 374
 375       /* End of the format string?  */
 376       if (*f == '\0')
 377         conv_error ();
 378
 379       /* Find the conversion specifier.  */
 380       fc = *f++;
 381       if (skip_space || (fc != '[' && fc != 'c' && fc != 'n'))
 382         {
 383           /* Eat whitespace.  */
 384           while (isspace (c))
 385             (void) inchar ();
 386           skip_space = 0;
 387         }
 388
 389       switch (fc)
 390         {
 391         case '%':       /* Must match a literal '%'.  */
 392           if (c != fc)
 393             conv_error ();
 394           inchar ();
 395           break;
 396
 397         case 'n':       /* Answer number of assignments done.  */
 398           /* Corrigendum 1 to ISO C 1990 describes the allowed flags
 399              with the 'n' conversion specifier.  */
 400           if (!(flags & SUPPRESS))
 401             /* Don't count the read-ahead.  */
 402             if (flags & LONGDBL)
 403               *ARG (long long int *) = read_in - 1;
 404             else if (flags & LONG)
 405               *ARG (long int *) = read_in - 1;
 406             else if (flags & SHORT)
 407               *ARG (short int *) = read_in - 1;
 408             else
 409               *ARG (int *) = read_in - 1;
 410           break;
 411
 412         case 'c':       /* Match characters.  */
 413           if (!(flags & SUPPRESS))
 414             {
 415               str = ARG (char *);
 416               if (str == NULL)
 417                 conv_error ();
 418             }
 419
 420           if (c == EOF)
 421             input_error ();
 422
 423           if (width == -1)
 424             width = 1;
 425
 426           if (!(flags & SUPPRESS))
 427             {
 428               do
 429                 *str++ = c;
 430               while (inchar () != EOF && --width > 0);
 431             }
 432           else
 433             while (inchar () != EOF && --width > 0);
 434
 435           if (!(flags & SUPPRESS))
 436             ++done;
 437
 438           break;
 439
 440         case 's':               /* Read a string.  */
 441 #define STRING_ARG                                                            \
 442           if (!(flags & SUPPRESS))                                            \
 443             {                                                                 \
 444               if (flags & MALLOC)                                             \
 445                 {                                                             \
 446                   /* The string is to be stored in a malloc'd buffer.  */     \
 447                   strptr = ARG (char **);                                     \
 448                   if (strptr == NULL)                                         \
 449                     conv_error ();                                            \
 450                   /* Allocate an initial buffer.  */                          \
 451                   strsize = 100;                                              \
 452                   *strptr = str = malloc (strsize);                           \
 453                 }                                                             \
 454               else                                                            \
 455                 str = ARG (char *);                                           \
 456               if (str == NULL)                                                \
 457                 conv_error ();                                                \
 458             }
 459           STRING_ARG;
 460
 461           if (c == EOF)
 462             input_error ();
 463
 464           do
 465             {
 466               if (isspace (c))
 467                 break;
 468 #define STRING_ADD_CHAR(c)                                                    \
 469               if (!(flags & SUPPRESS))                                        \
 470                 {                                                             \
 471                   *str++ = c;                                                 \
 472                   if ((flags & MALLOC) && str == *strptr + strsize)           \
 473                     {                                                         \
 474                       /* Enlarge the buffer.  */                              \
 475                       str = realloc (*strptr, strsize * 2);                   \
 476                       if (str == NULL)                                        \
 477                         {                                                     \
 478                           /* Can't allocate that much.  Last-ditch effort.  */\
 479                           str = realloc (*strptr, strsize + 1);               \
 480                           if (str == NULL)                                    \
 481                             {                                                 \
 482                               /* We lose.  Oh well.                           \
 483                                  Terminate the string and stop converting,    \
 484                                  so at least we don't skip any input.  */     \
 485                               (*strptr)[strsize] = '\0';                      \
 486                               ++done;                                         \
 487                               conv_error ();                                  \
 488                             }                                                 \
 489                           else                                                \
 490                             {                                                 \
 491                               *strptr = str;                                  \
 492                               str += strsize;                                 \
 493                               ++strsize;                                      \
 494                             }                                                 \
 495                         }                                                     \
 496                       else                                                    \
 497                         {                                                     \
 498                           *strptr = str;                                      \
 499                           str += strsize;                                     \
 500                           strsize *= 2;                                       \
 501                         }                                                     \
 502                     }                                                         \
 503                 }
 504               STRING_ADD_CHAR (c);
 505             } while (inchar () != EOF && (width <= 0 || --width > 0));
 506
 507           if (!(flags & SUPPRESS))
 508             {
 509               *str = '\0';
 510               ++done;
 511             }
 512           break;
 513
 514         case 'x':       /* Hexadecimal integer.  */
 515         case 'X':       /* Ditto.  */
 516           base = 16;
 517           number_signed = 0;
 518           goto number;
 519
 520         case 'o':       /* Octal integer.  */
 521           base = 8;
 522           number_signed = 0;
 523           goto number;
 524
 525         case 'u':       /* Unsigned decimal integer.  */
 526           base = 10;
 527           number_signed = 0;
 528           goto number;
 529
 530         case 'd':       /* Signed decimal integer.  */
 531           base = 10;
 532           number_signed = 1;
 533           goto number;
 534
 535         case 'i':       /* Generic number.  */
 536           base = 0;
 537           number_signed = 1;
 538
 539         number:
 540           if (c == EOF)
 541             input_error ();
 542
 543           /* Check for a sign.  */
 544           if (c == '-' || c == '+')
 545             {
 546               ADDW (c);
 547               if (width > 0)
 548                 --width;
 549               (void) inchar ();
 550             }
 551
 552           /* Look for a leading indication of base.  */
 553           if (width != 0 && c == '0')
 554             {
 555               if (width > 0)
 556                 --width;
 557
 558               ADDW (c);
 559               (void) inchar ();
 560
 561               if (width != 0 && tolower (c) == 'x')
 562                 {
 563                   if (base == 0)
 564                     base = 16;
 565                   if (base == 16)
 566                     {
 567                       if (width > 0)
 568                         --width;
 569                       (void) inchar ();
 570                     }
 571                 }
 572               else if (base == 0)
 573                 base = 8;
 574             }
 575
 576           if (base == 0)
 577             base = 10;
 578
 579           /* Read the number into workspace.  */
 580           while (c != EOF && width != 0)
 581             {
 582               if (base == 16 ? !isxdigit (c) :
 583                   ((!isdigit (c) || c - '0' >= base) &&
 584                    !((flags & GROUP) && base == 10 && c == thousands)))
 585                 break;
 586               ADDW (c);
 587               if (width > 0)
 588                 --width;
 589
 590               (void) inchar ();
 591             }
 592
 593           if (wpsize == 0 ||
 594               (wpsize == 1 && (wp[0] == '+' || wp[0] == '-')))
 595             /* There was no number.  */
 596             conv_error ();
 597
 598           /* Convert the number.  */
 599           ADDW ('\0');
 600           if (flags & LONGDBL)
 601             {
 602               if (number_signed)
 603                 num.q = __strtoq_internal (wp, &tw, base, flags & GROUP);
 604               else
 605                 num.uq = __strtouq_internal (wp, &tw, base, flags & GROUP);
 606             }
 607           else
 608             {
 609               if (number_signed)
 610                 num.l = __strtol_internal (wp, &tw, base, flags & GROUP);
 611               else
 612                 num.ul = __strtoul_internal (wp, &tw, base, flags & GROUP);
 613             }
 614           if (wp == tw)
 615             conv_error ();
 616
 617           if (!(flags & SUPPRESS))
 618             {
 619               if (! number_signed)
 620                 {
 621                   if (flags & LONGDBL)
 622                     *ARG (unsigned LONGLONG int *) = num.uq;
 623                   else if (flags & LONG)
 624                     *ARG (unsigned long int *) = num.ul;
 625                   else if (flags & SHORT)
 626                     *ARG (unsigned short int *)
 627                       = (unsigned short int) num.ul;
 628                   else
 629                     *ARG (unsigned int *) = (unsigned int) num.ul;
 630                 }
 631               else
 632                 {
 633                   if (flags & LONGDBL)
 634                     *ARG (LONGLONG int *) = num.q;
 635                   else if (flags & LONG)
 636                     *ARG (long int *) = num.l;
 637                   else if (flags & SHORT)
 638                     *ARG (short int *) = (short int) num.l;
 639                   else
 640                     *ARG (int *) = (int) num.l;
 641                 }
 642               ++done;
 643             }
 644           break;
 645
 646         case 'e':       /* Floating-point numbers.  */
 647         case 'E':
 648         case 'f':
 649         case 'g':
 650         case 'G':
 651           if (c == EOF)
 652             input_error ();
 653
 654           /* Check for a sign.  */
 655           if (c == '-' || c == '+')
 656             {
 657               negative = c == '-';
 658               if (inchar () == EOF)
 659                 /* EOF is only an input error before we read any chars.  */
 660                 conv_error ();
 661               if (width > 0)
 662                 --width;
 663             }
 664           else
 665             negative = 0;
 666
 667           got_dot = got_e = 0;
 668           do
 669             {
 670               if (isdigit (c))
 671                 ADDW (c);
 672               else if (got_e && wp[wpsize - 1] == 'e'
 673                        && (c == '-' || c == '+'))
 674                 ADDW (c);
 675               else if (wpsize > 0 && !got_e && tolower (c) == 'e')
 676                 {
 677                   ADDW ('e');
 678                   got_e = got_dot = 1;
 679                 }
 680               else if (c == decimal && !got_dot)
 681                 {
 682                   ADDW (c);
 683                   got_dot = 1;
 684                 }
 685               else if ((flags & GROUP) && c == thousands && !got_dot)
 686                 ADDW (c);
 687               else
 688                 break;
 689               if (width > 0)
 690                 --width;
 691             }
 692           while (inchar () != EOF && width != 0);
 693
 694           if (wpsize == 0)
 695             conv_error ();
 696
 697           /* Convert the number.  */
 698           ADDW ('\0');
 699           if (flags & LONGDBL)
 700             {
 701               long double d = __strtold_internal (wp, &tw, flags & GROUP);
 702               if (!(flags & SUPPRESS) && tw != wp)
 703                 *ARG (long double *) = negative ? -d : d;
 704             }
 705           else if (flags & LONG)
 706             {
 707               double d = __strtod_internal (wp, &tw, flags & GROUP);
 708               if (!(flags & SUPPRESS) && tw != wp)
 709                 *ARG (double *) = negative ? -d : d;
 710             }
 711           else
 712             {
 713               float d = __strtof_internal (wp, &tw, flags & GROUP);
 714               if (!(flags & SUPPRESS) && tw != wp)
 715                 *ARG (float *) = negative ? -d : d;
 716             }
 717
 718           if (tw == wp)
 719             conv_error ();
 720
 721           if (!(flags & SUPPRESS))
 722             ++done;
 723           break;
 724
 725         case '[':       /* Character class.  */
 726           STRING_ARG;
 727
 728           if (c == EOF)
 729             input_error();
 730
 731           if (*f == '^')
 732             {
 733               ++f;
 734               not_in = 1;
 735             }
 736           else
 737             not_in = 0;
 738
 739           /* Fill WP with byte flags indexed by character.
 740              We will use this flag map for matching input characters.  */
 741           if (wpmax < UCHAR_MAX)
 742             {
 743               wpmax = UCHAR_MAX;
 744               wp = (char *) alloca (wpmax);
 745             }
 746           memset (wp, 0, UCHAR_MAX);
 747
 748           fc = *f;
 749           if (fc == ']' || fc == '-')
 750             {
 751               /* If ] or - appears before any char in the set, it is not
 752                  the terminator or separator, but the first char in the
 753                  set.  */
 754               wp[fc] = 1;
 755               ++f;
 756             }
 757
 758           while ((fc = *f++) != '\0' && fc != ']')
 759             {
 760               if (fc == '-' && *f != '\0' && *f != ']' &&
 761                   (unsigned char) f[-2] <= (unsigned char) *f)
 762                 {
 763                   /* Add all characters from the one before the '-'
 764                      up to (but not including) the next format char.  */
 765                   for (fc = f[-2]; fc < *f; ++fc)
 766                     wp[fc] = 1;
 767                 }
 768               else
 769                 /* Add the character to the flag map.  */
 770                 wp[fc] = 1;
 771             }
 772           if (fc == '\0')
 773             conv_error();
 774
 775           num.ul = read_in;
 776           do
 777             {
 778               if (wp[c] == not_in)
 779                 break;
 780               STRING_ADD_CHAR (c);
 781               if (width > 0)
 782                 --width;
 783             }
 784           while (inchar () != EOF && width != 0);
 785           if (read_in == num.ul)
 786             conv_error ();
 787
 788           if (!(flags & SUPPRESS))
 789             {
 790               *str = '\0';
 791               ++done;
 792             }
 793           break;
 794
 795         case 'p':       /* Generic pointer.  */
 796           base = 16;
 797           /* A PTR must be the same size as a `long int'.  */
 798           flags &= ~(SHORT|LONGDBL);
 799           flags |= LONG;
 800           number_signed = 0;
 801           goto number;
 802         }
 803     }
 804
 805   /* The last thing we saw int the format string was a white space.
 806      Consume the last white spaces.  */
 807   if (skip_space)
 808     while (isspace (c))
 809       (void) inchar ();
 810
 811   /* Unlock stream.  */
 812   funlockfile (s);
 813
 814   return ((void) (c == EOF || ungetc (c, s)), done);
 815 }
 816
 817 #ifdef USE_IN_LIBIO
 818 int
 819 __vfscanf (FILE *s, const char *format, va_list argptr)
 820 {
 821   return _IO_vfscanf (s, format, argptr, NULL);
 822 }
 823 #endif
 824
 825 weak_alias (__vfscanf, vfscanf)