StdLib/LibC/Stdio/vfscanf.c

   1 /** @file
   2     Implementation of scanf internals for <stdio.h>.
   3
   4     Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
   5     This program and the accompanying materials are licensed and made available
   6     under the terms and conditions of the BSD License that accompanies this
   7     distribution.  The full text of the license may be found at
   8     http://opensource.org/licenses/bsd-license.
   9
  10     THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11     WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13     Copyright (c) 1990, 1993
  14     The Regents of the University of California.  All rights reserved.
  15
  16     This code is derived from software contributed to Berkeley by
  17     Chris Torek.
  18
  19     Redistribution and use in source and binary forms, with or without
  20     modification, are permitted provided that the following conditions
  21     are met:
  22       - Redistributions of source code must retain the above copyright
  23         notice, this list of conditions and the following disclaimer.
  24       - Redistributions in binary form must reproduce the above copyright
  25         notice, this list of conditions and the following disclaimer in the
  26         documentation and/or other materials provided with the distribution.
  27       - Neither the name of the University nor the names of its contributors
  28         may be used to endorse or promote products derived from this software
  29         without specific prior written permission.
  30
  31     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  32     AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  33     IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  34     ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
  35     LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  36     CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  37     SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  38     INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  39     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  40     ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41     POSSIBILITY OF SUCH DAMAGE.
  42
  43     NetBSD: vfscanf.c,v 1.37.4.1 2007/05/07 19:49:08 pavel Exp
  44     FreeBSD: src/lib/libc/stdio/vfscanf.c,v 1.41 2007/01/09 00:28:07 imp Exp
  45     vfscanf.c 8.1 (Berkeley) 6/4/93
  46 **/
  47 #include  <LibConfig.h>
  48
  49 #include "namespace.h"
  50 #include <assert.h>
  51 #include <ctype.h>
  52 #include  <errno.h>
  53 #include <inttypes.h>
  54 #include <stdio.h>
  55 #include <stdlib.h>
  56 #include <stddef.h>
  57 #include <stdarg.h>
  58 #include <string.h>
  59 #include  <sys/types.h>
  60 #include <wchar.h>
  61 #include <wctype.h>
  62
  63 #include "reentrant.h"
  64 #include "local.h"
  65
  66 #ifndef NO_FLOATING_POINT
  67 #include <locale.h>
  68 #endif
  69
  70 /*
  71  * Provide an external name for vfscanf.  Note, EFI uses the normal
  72  * namespace.h method; stdio routines explicitly use the internal name
  73  * __svfscanf.
  74  */
  75 #ifdef __weak_alias
  76 __weak_alias(vfscanf,__svfscanf)
  77 #endif
  78
  79 #define BUF   513 /* Maximum length of numeric string. */
  80
  81 /*
  82  * Flags used during conversion.
  83  */
  84 #define LONG        0x0001  /* l: long or double */
  85 #define LONGDBL     0x0002  /* L: long double */
  86 #define SHORT       0x0004  /* h: short */
  87 #define SUPPRESS    0x0008  /* *: suppress assignment */
  88 #define POINTER     0x0010  /* p: void * (as hex) */
  89 #define NOSKIP      0x0020  /* [ or c: do not skip blanks */
  90 #define LONGLONG    0x0400  /* ll: long long (+ deprecated q: quad) */
  91 #define INTMAXT     0x0800  /* j: intmax_t */
  92 #define PTRDIFFT    0x1000  /* t: ptrdiff_t */
  93 #define SIZET       0x2000  /* z: size_t */
  94 #define SHORTSHORT  0x4000  /* hh: char */
  95 #define UNSIGNED    0x8000  /* %[oupxX] conversions */
  96
  97 /*
  98  * The following are used in integral conversions only:
  99  * SIGNOK, NDIGITS, PFXOK, and NZDIGITS
 100  */
 101 #define SIGNOK      0x00040 /* +/- is (still) legal */
 102 #define NDIGITS     0x00080 /* no digits detected */
 103 #define PFXOK       0x00100 /* 0x prefix is (still) legal */
 104 #define NZDIGITS    0x00200 /* no zero digits detected */
 105 #define HAVESIGN    0x10000 /* sign detected */
 106
 107 /*
 108  * Conversion types.
 109  */
 110 #define CT_CHAR     0 /* %c conversion */
 111 #define CT_CCL      1 /* %[...] conversion */
 112 #define CT_STRING   2 /* %s conversion */
 113 #define CT_INT      3 /* %[dioupxX] conversion */
 114 #define CT_FLOAT    4 /* %[efgEFG] conversion */
 115
 116 static const u_char  *__sccl(char *, const u_char *);
 117 #ifndef NO_FLOATING_POINT
 118   static int            parsefloat(FILE *, char *, char *);
 119 #endif
 120
 121 int __scanfdebug = 0;
 122
 123 #define __collate_load_error /*CONSTCOND*/0
 124 static int
 125 __collate_range_cmp(int c1, int c2)
 126 {
 127   static char s1[2] = { 0 };
 128   static char s2[2] = { 0 };
 129
 130   s1[0] = (char)c1;
 131   s2[0] = (char)c2;
 132   return strcoll(s1, s2);
 133 }
 134
 135
 136 /*
 137  * __svfscanf - MT-safe version
 138  */
 139 int
 140 __svfscanf(FILE *fp, char const *fmt0, va_list ap)
 141 {
 142   int ret;
 143
 144   if(fp == NULL) {
 145     errno = EINVAL;
 146     return (EOF);
 147   }
 148   FLOCKFILE(fp);
 149   ret = __svfscanf_unlocked(fp, fmt0, ap);
 150   FUNLOCKFILE(fp);
 151   return (ret);
 152 }
 153
 154 /*
 155  * __svfscanf_unlocked - non-MT-safe version of __svfscanf
 156  */
 157 int
 158 __svfscanf_unlocked(FILE *fp, const char *fmt0, va_list ap)
 159 {
 160           const u_char     *fmt     = (const u_char *)fmt0;
 161                 int         c;              /* character from format, or conversion */
 162                 size_t      width;          /* field width, or 0 */
 163                 char       *p;              /* points into all kinds of strings */
 164                 size_t      n;              /* handy size_t */
 165                 int         flags;          /* flags as defined above */
 166                 char       *p0;             /* saves original value of p when necessary */
 167                 int         nassigned;      /* number of fields assigned */
 168                 int         nconversions;   /* number of conversions */
 169                 int         nread;          /* number of characters consumed from fp */
 170                 int         base;           /* base argument to conversion function */
 171                 char        ccltab[256];    /* character class table for %[...] */
 172                 char        buf[BUF];       /* buffer for numeric and mb conversions */
 173                 wchar_t    *wcp;            /* handy wide character pointer */
 174                 size_t      nconv;          /* length of multibyte sequence converted */
 175   static const  mbstate_t   initial = { 0 };
 176                 mbstate_t   mbs;
 177
 178   /* `basefix' is used to avoid `if' tests in the integer scanner */
 179   static const short basefix[17] =
 180     { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
 181
 182   _DIAGASSERT(fp != NULL);
 183   _DIAGASSERT(fmt0 != NULL);
 184   if(fp == NULL) {
 185     errno = EINVAL;
 186     return (EOF);
 187   }
 188
 189   _SET_ORIENTATION(fp, -1);
 190
 191 //Print(L"%a( %d, \"%a\", ...)\n", __func__, fp->_file, fmt0);
 192   nassigned = 0;
 193   nconversions = 0;
 194   nread = 0;
 195   base = 0;
 196   for (;;) {
 197     c = (unsigned char)*fmt++;
 198     if (c == 0)
 199       return (nassigned);
 200     if (isspace(c)) {
 201       while ((fp->_r > 0 || __srefill(fp) == 0) &&
 202           isspace(*fp->_p))
 203         nread++, fp->_r--, fp->_p++;
 204       continue;
 205     }
 206 //Print(L"%a: %d\n", __func__, __LINE__);
 207     if (c != '%')
 208       goto literal;
 209     width = 0;
 210     flags = 0;
 211     /*
 212      * switch on the format.  continue if done;
 213      * break once format type is derived.
 214      */
 215 again:    c = *fmt++;
 216 //Print(L"%a: %d\n", __func__, __LINE__);
 217     switch (c) {
 218     case '%':
 219 literal:
 220 //Print(L"%a: %d\n", __func__, __LINE__);
 221       if (fp->_r <= 0 && __srefill(fp))
 222         goto input_failure;
 223       if (*fp->_p != c)
 224         goto match_failure;
 225       fp->_r--, fp->_p++;
 226       nread++;
 227       continue;
 228
 229     case '*':
 230       flags |= SUPPRESS;
 231       goto again;
 232     case 'j':
 233       flags |= INTMAXT;
 234       goto again;
 235     case 'l':
 236       if (flags & LONG) {
 237         flags &= ~LONG;
 238         flags |= LONGLONG;
 239       } else
 240         flags |= LONG;
 241       goto again;
 242     case 'q':
 243       flags |= LONGLONG;  /* not quite */
 244       goto again;
 245     case 't':
 246       flags |= PTRDIFFT;
 247       goto again;
 248     case 'z':
 249       flags |= SIZET;
 250       goto again;
 251     case 'L':
 252       flags |= LONGDBL;
 253       goto again;
 254     case 'h':
 255       if (flags & SHORT) {
 256         flags &= ~SHORT;
 257         flags |= SHORTSHORT;
 258       } else
 259         flags |= SHORT;
 260       goto again;
 261
 262     case '0': case '1': case '2': case '3': case '4':
 263     case '5': case '6': case '7': case '8': case '9':
 264       width = width * 10 + c - '0';
 265       goto again;
 266
 267     /*
 268      * Conversions.
 269      */
 270     case 'd':
 271       c = CT_INT;
 272       base = 10;
 273       break;
 274
 275     case 'i':
 276       c = CT_INT;
 277       base = 0;
 278       break;
 279
 280     case 'o':
 281       c = CT_INT;
 282       flags |= UNSIGNED;
 283       base = 8;
 284       break;
 285
 286     case 'u':
 287       c = CT_INT;
 288       flags |= UNSIGNED;
 289       base = 10;
 290       break;
 291
 292     case 'X':
 293     case 'x':
 294       flags |= PFXOK; /* enable 0x prefixing */
 295       c = CT_INT;
 296       flags |= UNSIGNED;
 297       base = 16;
 298       break;
 299
 300 #ifndef NO_FLOATING_POINT
 301     case 'A': case 'E': case 'F': case 'G':
 302     case 'a': case 'e': case 'f': case 'g':
 303       c = CT_FLOAT;
 304       break;
 305 #endif
 306
 307     case 'S':
 308       flags |= LONG;
 309       /* FALLTHROUGH */
 310     case 's':
 311       c = CT_STRING;
 312       break;
 313
 314     case '[':
 315       fmt = __sccl(ccltab, fmt);
 316       flags |= NOSKIP;
 317       c = CT_CCL;
 318       break;
 319
 320     case 'C':
 321       flags |= LONG;
 322       /* FALLTHROUGH */
 323     case 'c':
 324       flags |= NOSKIP;
 325       c = CT_CHAR;
 326       break;
 327
 328     case 'p': /* pointer format is like hex */
 329       flags |= POINTER | PFXOK;
 330       c = CT_INT;   /* assumes sizeof(uintmax_t) */
 331       flags |= UNSIGNED;  /*      >= sizeof(uintptr_t) */
 332       base = 16;
 333       break;
 334
 335     case 'n':
 336       nconversions++;
 337       if (flags & SUPPRESS) /* ??? */
 338         continue;
 339       if (flags & SHORTSHORT)
 340         *va_arg(ap, char *) = (char)nread;
 341       else if (flags & SHORT)
 342         *va_arg(ap, short *) = (short)nread;
 343       else if (flags & LONG)
 344         *va_arg(ap, long *) = nread;
 345       else if (flags & LONGLONG)
 346         *va_arg(ap, long long *) = nread;
 347       else if (flags & INTMAXT)
 348         *va_arg(ap, intmax_t *) = nread;
 349       else if (flags & SIZET)
 350         *va_arg(ap, size_t *) = nread;
 351       else if (flags & PTRDIFFT)
 352         *va_arg(ap, ptrdiff_t *) = nread;
 353       else
 354         *va_arg(ap, int *) = nread;
 355       continue;
 356
 357     default:
 358       goto match_failure;
 359
 360     /*
 361      * Disgusting backwards compatibility hack. XXX
 362      */
 363     case '\0':  /* compat */
 364       return (EOF);
 365     }
 366 //Print(L"%a: %d\n", __func__, __LINE__);
 367
 368     /*
 369      * We have a conversion that requires input.
 370      */
 371     if (fp->_r <= 0 && __srefill(fp))
 372     {
 373 //Print(L"%a: %d\n", __func__, __LINE__);
 374       goto input_failure;
 375     }
 376
 377     /*
 378      * Consume leading white space, except for formats
 379      * that suppress this.
 380      */
 381     if ((flags & NOSKIP) == 0) {
 382       while (isspace(*fp->_p)) {
 383         nread++;
 384         if (--fp->_r > 0)
 385           fp->_p++;
 386         else if (__srefill(fp))
 387         {
 388 //Print(L"%a: %d\n", __func__, __LINE__);
 389           goto input_failure;
 390         }
 391       }
 392       /*
 393        * Note that there is at least one character in
 394        * the buffer, so conversions that do not set NOSKIP
 395        * ca no longer result in an input failure.
 396        */
 397     }
 398
 399     /*
 400      * Do the conversion.
 401      */
 402 //Print(L"%a: %d\n", __func__, __LINE__);
 403     switch (c) {
 404
 405     case CT_CHAR:
 406       /* scan arbitrary characters (sets NOSKIP) */
 407       if (width == 0)
 408         width = 1;
 409       if (flags & LONG) {
 410         if ((flags & SUPPRESS) == 0)
 411           wcp = va_arg(ap, wchar_t *);
 412         else
 413           wcp = NULL;
 414         n = 0;
 415         while (width != 0) {
 416           if (n == MB_CUR_MAX) {
 417             fp->_flags |= __SERR;
 418             goto input_failure;
 419           }
 420           buf[n++] = *fp->_p;
 421           fp->_p++;
 422           fp->_r--;
 423           mbs = initial;
 424           nconv = mbrtowc(wcp, buf, n, &mbs);
 425           if (nconv == (size_t)-1) {
 426             fp->_flags |= __SERR;
 427             goto input_failure;
 428           }
 429           if (nconv == 0 && !(flags & SUPPRESS))
 430             *wcp = L'\0';
 431           if (nconv != (size_t)-2) {
 432             nread += (int)n;
 433             width--;
 434             if (!(flags & SUPPRESS))
 435               wcp++;
 436             n = 0;
 437           }
 438           if (fp->_r <= 0 && __srefill(fp)) {
 439             if (n != 0) {
 440               fp->_flags |= __SERR;
 441               goto input_failure;
 442             }
 443             break;
 444           }
 445         }
 446         if (!(flags & SUPPRESS))
 447           nassigned++;
 448       } else if (flags & SUPPRESS) {
 449         size_t sum = 0;
 450         for (;;) {
 451           if ((n = fp->_r) < width) {
 452             sum += n;
 453             width -= n;
 454             fp->_p += n;
 455             if (__srefill(fp)) {
 456               if (sum == 0)
 457                   goto input_failure;
 458               break;
 459             }
 460           } else {
 461             sum += width;
 462             fp->_r -= (int)width;
 463             fp->_p += width;
 464             break;
 465           }
 466         }
 467         nread += (int)sum;
 468       } else {
 469         size_t r = fread(va_arg(ap, char *), 1,
 470             width, fp);
 471
 472         if (r == 0)
 473           goto input_failure;
 474         nread += (int)r;
 475         nassigned++;
 476       }
 477       nconversions++;
 478       break;
 479
 480     case CT_CCL:
 481       /* scan a (nonempty) character class (sets NOSKIP) */
 482       if (width == 0)
 483         width = (size_t)~0; /* `infinity' */
 484       /* take only those things in the class */
 485       if (flags & LONG) {
 486         wchar_t twc;
 487         int nchars;
 488
 489         if ((flags & SUPPRESS) == 0)
 490           wcp = va_arg(ap, wchar_t *);
 491         else
 492           wcp = &twc;
 493         n = 0;
 494         nchars = 0;
 495         while (width != 0) {
 496           if (n == MB_CUR_MAX) {
 497             fp->_flags |= __SERR;
 498             goto input_failure;
 499           }
 500           buf[n++] = *fp->_p;
 501           fp->_p++;
 502           fp->_r--;
 503           mbs = initial;
 504           nconv = mbrtowc(wcp, buf, n, &mbs);
 505           if (nconv == (size_t)-1) {
 506             fp->_flags |= __SERR;
 507             goto input_failure;
 508           }
 509           if (nconv == 0)
 510             *wcp = L'\0';
 511           if (nconv != (size_t)-2) {
 512             if (wctob(*wcp) != EOF &&
 513                 !ccltab[wctob(*wcp)]) {
 514               while (n != 0) {
 515                 n--;
 516                 (void)ungetc(buf[n],
 517                     fp);
 518               }
 519               break;
 520             }
 521             nread += (int)n;
 522             width--;
 523             if (!(flags & SUPPRESS))
 524               wcp++;
 525             nchars++;
 526             n = 0;
 527           }
 528           if (fp->_r <= 0 && __srefill(fp)) {
 529             if (n != 0) {
 530               fp->_flags |= __SERR;
 531               goto input_failure;
 532             }
 533             break;
 534           }
 535         }
 536         if (n != 0) {
 537           fp->_flags |= __SERR;
 538           goto input_failure;
 539         }
 540         n = nchars;
 541         if (n == 0)
 542           goto match_failure;
 543         if (!(flags & SUPPRESS)) {
 544           *wcp = L'\0';
 545           nassigned++;
 546         }
 547       } else if (flags & SUPPRESS) {
 548         n = 0;
 549         while (ccltab[*fp->_p]) {
 550           n++, fp->_r--, fp->_p++;
 551           if (--width == 0)
 552             break;
 553           if (fp->_r <= 0 && __srefill(fp)) {
 554             if (n == 0)
 555               goto input_failure;
 556             break;
 557           }
 558         }
 559         if (n == 0)
 560           goto match_failure;
 561       } else {
 562         p0 = p = va_arg(ap, char *);
 563         while (ccltab[*fp->_p]) {
 564           fp->_r--;
 565           *p++ = *fp->_p++;
 566           if (--width == 0)
 567             break;
 568           if (fp->_r <= 0 && __srefill(fp)) {
 569             if (p == p0)
 570               goto input_failure;
 571             break;
 572           }
 573         }
 574         n = p - p0;
 575         if (n == 0)
 576           goto match_failure;
 577         *p = 0;
 578         nassigned++;
 579       }
 580       nread += (int)n;
 581       nconversions++;
 582       break;
 583
 584     case CT_STRING:
 585       /* like CCL, but zero-length string OK, & no NOSKIP */
 586       if (width == 0)
 587         width = (size_t)~0;
 588       if (flags & LONG) {
 589         wchar_t twc;
 590
 591         if ((flags & SUPPRESS) == 0)
 592           wcp = va_arg(ap, wchar_t *);
 593         else
 594           wcp = &twc;
 595         n = 0;
 596         while (!isspace(*fp->_p) && width != 0) {
 597           if (n == MB_CUR_MAX) {
 598             fp->_flags |= __SERR;
 599             goto input_failure;
 600           }
 601           buf[n++] = *fp->_p;
 602           fp->_p++;
 603           fp->_r--;
 604           mbs = initial;
 605           nconv = mbrtowc(wcp, buf, n, &mbs);
 606           if (nconv == (size_t)-1) {
 607             fp->_flags |= __SERR;
 608             goto input_failure;
 609           }
 610           if (nconv == 0)
 611             *wcp = L'\0';
 612           if (nconv != (size_t)-2) {
 613             if (iswspace(*wcp)) {
 614               while (n != 0) {
 615                 n--;
 616                 (void)ungetc(buf[n],
 617                     fp);
 618               }
 619               break;
 620             }
 621             nread += (int)n;
 622             width--;
 623             if (!(flags & SUPPRESS))
 624               wcp++;
 625             n = 0;
 626           }
 627           if (fp->_r <= 0 && __srefill(fp)) {
 628             if (n != 0) {
 629               fp->_flags |= __SERR;
 630               goto input_failure;
 631             }
 632             break;
 633           }
 634         }
 635         if (!(flags & SUPPRESS)) {
 636           *wcp = L'\0';
 637           nassigned++;
 638         }
 639       } else if (flags & SUPPRESS) {
 640         n = 0;
 641         while (!isspace(*fp->_p)) {
 642           n++, fp->_r--, fp->_p++;
 643           if (--width == 0)
 644             break;
 645           if (fp->_r <= 0 && __srefill(fp))
 646             break;
 647         }
 648         nread += (int)n;
 649       } else {
 650         p0 = p = va_arg(ap, char *);
 651         while (!isspace(*fp->_p)) {
 652           fp->_r--;
 653           *p++ = *fp->_p++;
 654           if (--width == 0)
 655             break;
 656           if (fp->_r <= 0 && __srefill(fp))
 657             break;
 658         }
 659         *p = 0;
 660         nread += (int)(p - p0);
 661         nassigned++;
 662       }
 663       nconversions++;
 664       continue;
 665
 666     case CT_INT:
 667 //Print(L"%a: %d\n", __func__, __LINE__);
 668       /* scan an integer as if by the conversion function */
 669 #ifdef hardway
 670       if (width == 0 || width > sizeof(buf) - 1)
 671         width = sizeof(buf) - 1;
 672 #else
 673       /* size_t is unsigned, hence this optimisation */
 674       if (--width > sizeof(buf) - 2)
 675         width = sizeof(buf) - 2;
 676       width++;
 677 #endif
 678       flags |= SIGNOK | NDIGITS | NZDIGITS;
 679       for (p = buf; width; width--) {
 680         c = *fp->_p;
 681         /*
 682          * Switch on the character; `goto ok'
 683          * if we accept it as a part of number.
 684          */
 685         switch (c) {
 686
 687         /*
 688          * The digit 0 is always legal, but is
 689          * special.  For %i conversions, if no
 690          * digits (zero or nonzero) have been
 691          * scanned (only signs), we will have
 692          * base==0.  In that case, we should set
 693          * it to 8 and enable 0x prefixing.
 694          * Also, if we have not scanned zero digits
 695          * before this, do not turn off prefixing
 696          * (someone else will turn it off if we
 697          * have scanned any nonzero digits).
 698          */
 699         case '0':
 700           if (base == 0) {
 701             base = 8;
 702             flags |= PFXOK;
 703           }
 704           if (flags & NZDIGITS)
 705               flags &= ~(SIGNOK|NZDIGITS|NDIGITS);
 706           else
 707               flags &= ~(SIGNOK|PFXOK|NDIGITS);
 708           goto ok;
 709
 710         /* 1 through 7 always legal */
 711         case '1': case '2': case '3':
 712         case '4': case '5': case '6': case '7':
 713           base = basefix[base];
 714           flags &= ~(SIGNOK | PFXOK | NDIGITS);
 715           goto ok;
 716
 717         /* digits 8 and 9 ok iff decimal or hex */
 718         case '8': case '9':
 719           base = basefix[base];
 720           if (base <= 8)
 721             break;  /* not legal here */
 722           flags &= ~(SIGNOK | PFXOK | NDIGITS);
 723           goto ok;
 724
 725         /* letters ok iff hex */
 726         case 'A': case 'B': case 'C':
 727         case 'D': case 'E': case 'F':
 728         case 'a': case 'b': case 'c':
 729         case 'd': case 'e': case 'f':
 730           /* no need to fix base here */
 731           if (base <= 10)
 732             break;  /* not legal here */
 733           flags &= ~(SIGNOK | PFXOK | NDIGITS);
 734           goto ok;
 735
 736         /* sign ok only as first character */
 737         case '+': case '-':
 738           if (flags & SIGNOK) {
 739             flags &= ~SIGNOK;
 740             flags |= HAVESIGN;
 741             goto ok;
 742           }
 743           break;
 744
 745         /*
 746          * x ok iff flag still set & 2nd char (or
 747          * 3rd char if we have a sign).
 748          */
 749         case 'x': case 'X':
 750           if (flags & PFXOK && p ==
 751               buf + 1 + !!(flags & HAVESIGN)) {
 752             base = 16;  /* if %i */
 753             flags &= ~PFXOK;
 754             goto ok;
 755           }
 756           break;
 757         }
 758
 759         /*
 760          * If we got here, c is not a legal character
 761          * for a number.  Stop accumulating digits.
 762          */
 763         break;
 764     ok:
 765         /*
 766          * c is legal: store it and look at the next.
 767          */
 768         *p++ = (char)c;
 769         if (--fp->_r > 0)
 770           fp->_p++;
 771         else if (__srefill(fp))
 772           break;    /* EOF */
 773       }
 774       /*
 775        * If we had only a sign, it is no good; push
 776        * back the sign.  If the number ends in `x',
 777        * it was [sign] '0' 'x', so push back the x
 778        * and treat it as [sign] '0'.
 779        */
 780       if (flags & NDIGITS) {
 781         if (p > buf)
 782           (void)ungetc(*(u_char *)--p, fp);
 783         goto match_failure;
 784       }
 785       c = ((u_char *)p)[-1];
 786       if (c == 'x' || c == 'X') {
 787         --p;
 788         (void)ungetc(c, fp);
 789       }
 790       if ((flags & SUPPRESS) == 0) {
 791         //uintmax_t res;
 792         // Use a union to get around the truncation warnings.
 793         union {
 794           uintmax_t   umax;
 795           intmax_t    imax;
 796           void       *vp;
 797           ptrdiff_t   pdt;
 798           size_t      sz;
 799           long long   ll;
 800           long        lo;
 801           int         in;
 802           short       hw;
 803           char        ch;
 804         } res;
 805
 806         *p = 0;
 807         if ((flags & UNSIGNED) == 0)
 808             res.imax = strtoimax(buf, (char **)NULL, base);
 809         else
 810             res.umax = strtoumax(buf, (char **)NULL, base);
 811         if (flags & POINTER)
 812           *va_arg(ap, void **) = res.vp;
 813               //(void *)((uintptr_t)res);
 814         else if (flags & SHORTSHORT)
 815           *va_arg(ap, char *) = res.ch;
 816         else if (flags & SHORT)
 817           *va_arg(ap, short *) = res.hw;
 818         else if (flags & LONG)
 819           *va_arg(ap, long *) = res.lo;
 820         else if (flags & LONGLONG)
 821           *va_arg(ap, long long *) = res.ll;
 822         else if (flags & INTMAXT)
 823           *va_arg(ap, intmax_t *) = res.imax;
 824         else if (flags & PTRDIFFT)
 825           *va_arg(ap, ptrdiff_t *) = res.pdt;
 826               //(ptrdiff_t)res;
 827         else if (flags & SIZET)
 828           *va_arg(ap, size_t *) = res.sz;
 829         else
 830           *va_arg(ap, int *) = res.in;
 831         nassigned++;
 832       }
 833       nread += (int)(p - buf);
 834       nconversions++;
 835 //Print(L"%a: %d\n", __func__, __LINE__);
 836       break;
 837
 838 #ifndef NO_FLOATING_POINT
 839     case CT_FLOAT:
 840       /* scan a floating point number as if by strtod */
 841       if (width == 0 || width > sizeof(buf) - 1)
 842         width = sizeof(buf) - 1;
 843       if ((width = parsefloat(fp, buf, buf + width)) == 0)
 844         goto match_failure;
 845       if ((flags & SUPPRESS) == 0) {
 846         if (flags & LONGDBL) {
 847           long double res = strtold(buf, &p);
 848           *va_arg(ap, long double *) = res;
 849         } else if (flags & LONG) {
 850           double res = strtod(buf, &p);
 851           *va_arg(ap, double *) = res;
 852         } else {
 853           float res = strtof(buf, &p);
 854           *va_arg(ap, float *) = res;
 855         }
 856         if (__scanfdebug && p - buf != (ptrdiff_t)width)
 857           abort();
 858         nassigned++;
 859       }
 860       nread += (int)width;
 861       nconversions++;
 862       break;
 863 #endif /* !NO_FLOATING_POINT */
 864     }
 865   }
 866 input_failure:
 867 //Print(L"%a: %d\n", __func__, __LINE__);
 868   return (nconversions != 0 ? nassigned : EOF);
 869 match_failure:
 870   return (nassigned);
 871 }
 872
 873 /*
 874  * Fill in the given table from the scanset at the given format
 875  * (just after `[').  Return a pointer to the character past the
 876  * closing `]'.  The table has a 1 wherever characters should be
 877  * considered part of the scanset.
 878  */
 879 static const u_char *
 880 __sccl(char *tab, const u_char *fmt)
 881 {
 882   int c, n, v, i;
 883
 884   _DIAGASSERT(tab != NULL);
 885   _DIAGASSERT(fmt != NULL);
 886   /* first `clear' the whole table */
 887   c = *fmt++;   /* first char hat => negated scanset */
 888   if (c == '^') {
 889     v = 1;    /* default => accept */
 890     c = *fmt++; /* get new first char */
 891   } else
 892     v = 0;    /* default => reject */
 893
 894   /* XXX: Will not work if sizeof(tab*) > sizeof(char) */
 895   (void)memset(tab, v, 256);
 896
 897   if (c == 0)
 898     return (fmt - 1);/* format ended before closing ] */
 899
 900   /*
 901    * Now set the entries corresponding to the actual scanset
 902    * to the opposite of the above.
 903    *
 904    * The first character may be ']' (or '-') without being special;
 905    * the last character may be '-'.
 906    */
 907   v = 1 - v;
 908   for (;;) {
 909     tab[c] = (char)v;   /* take character c */
 910 doswitch:
 911     n = *fmt++;   /* and examine the next */
 912     switch (n) {
 913
 914     case 0:     /* format ended too soon */
 915       return (fmt - 1);
 916
 917     case '-':
 918       /*
 919        * A scanset of the form
 920        *  [01+-]
 921        * is defined as `the digit 0, the digit 1,
 922        * the character +, the character -', but
 923        * the effect of a scanset such as
 924        *  [a-zA-Z0-9]
 925        * is implementation defined.  The V7 Unix
 926        * scanf treats `a-z' as `the letters a through
 927        * z', but treats `a-a' as `the letter a, the
 928        * character -, and the letter a'.
 929        *
 930        * For compatibility, the `-' is not considerd
 931        * to define a range if the character following
 932        * it is either a close bracket (required by ANSI)
 933        * or is not numerically greater than the character
 934        * we just stored in the table (c).
 935        */
 936       n = *fmt;
 937       if (n == ']' || (__collate_load_error ? n < c :
 938           __collate_range_cmp(n, c) < 0)) {
 939         c = '-';
 940         break;  /* resume the for(;;) */
 941       }
 942       fmt++;
 943       /* fill in the range */
 944       if (__collate_load_error) {
 945         do
 946           tab[++c] = (char)v;
 947         while (c < n);
 948       } else {
 949         for (i = 0; i < 256; i ++)
 950           if (__collate_range_cmp(c, i) < 0 &&
 951               __collate_range_cmp(i, n) <= 0)
 952             tab[i] = (char)v;
 953       }
 954 #if 1 /* XXX another disgusting compatibility hack */
 955       c = n;
 956       /*
 957        * Alas, the V7 Unix scanf also treats formats
 958        * such as [a-c-e] as `the letters a through e'.
 959        * This too is permitted by the standard....
 960        */
 961       goto doswitch;
 962 #else
 963       c = *fmt++;
 964       if (c == 0)
 965         return (fmt - 1);
 966       if (c == ']')
 967         return (fmt);
 968 #endif
 969
 970     case ']':   /* end of scanset */
 971       return (fmt);
 972
 973     default:    /* just another character */
 974       c = n;
 975       break;
 976     }
 977   }
 978   /* NOTREACHED */
 979 }
 980
 981 #ifndef NO_FLOATING_POINT
 982 static int
 983 parsefloat(FILE *fp, char *buf, char *end)
 984 {
 985   char *commit, *p;
 986   int infnanpos = 0;
 987   enum {
 988     S_START, S_GOTSIGN, S_INF, S_NAN, S_MAYBEHEX,
 989     S_DIGITS, S_FRAC, S_EXP, S_EXPDIGITS
 990   } state = S_START;
 991   unsigned char c;
 992   char decpt = *localeconv()->decimal_point;
 993   _Bool gotmantdig = 0, ishex = 0;
 994
 995   if(fp == NULL) {
 996     errno = EINVAL;
 997     return (EOF);
 998   }
 999
1000   /*
1001    * We set commit = p whenever the string we have read so far
1002    * constitutes a valid representation of a floating point
1003    * number by itself.  At some point, the parse will complete
1004    * or fail, and we will ungetc() back to the last commit point.
1005    * To ensure that the file offset gets updated properly, it is
1006    * always necessary to read at least one character that doesn't
1007    * match; thus, we can't short-circuit "infinity" or "nan(...)".
1008    */
1009   commit = buf - 1;
1010   for (p = buf; p < end; ) {
1011     c = *fp->_p;
1012 reswitch:
1013     switch (state) {
1014     case S_START:
1015       state = S_GOTSIGN;
1016       if (c == '-' || c == '+')
1017         break;
1018       else
1019         goto reswitch;
1020     case S_GOTSIGN:
1021       switch (c) {
1022       case '0':
1023         state = S_MAYBEHEX;
1024         commit = p;
1025         break;
1026       case 'I':
1027       case 'i':
1028         state = S_INF;
1029         break;
1030       case 'N':
1031       case 'n':
1032         state = S_NAN;
1033         break;
1034       default:
1035         state = S_DIGITS;
1036         goto reswitch;
1037       }
1038       break;
1039     case S_INF:
1040       if (infnanpos > 6 ||
1041           (c != "nfinity"[infnanpos] &&
1042            c != "NFINITY"[infnanpos]))
1043         goto parsedone;
1044       if (infnanpos == 1 || infnanpos == 6)
1045         commit = p; /* inf or infinity */
1046       infnanpos++;
1047       break;
1048     case S_NAN:
1049       switch (infnanpos) {
1050       case -1:  /* XXX kludge to deal with nan(...) */
1051         goto parsedone;
1052       case 0:
1053         if (c != 'A' && c != 'a')
1054           goto parsedone;
1055         break;
1056       case 1:
1057         if (c != 'N' && c != 'n')
1058           goto parsedone;
1059         else
1060           commit = p;
1061         break;
1062       case 2:
1063         if (c != '(')
1064           goto parsedone;
1065         break;
1066       default:
1067         if (c == ')') {
1068           commit = p;
1069           infnanpos = -2;
1070         } else if (!isalnum(c) && c != '_')
1071           goto parsedone;
1072         break;
1073       }
1074       infnanpos++;
1075       break;
1076     case S_MAYBEHEX:
1077       state = S_DIGITS;
1078       if (c == 'X' || c == 'x') {
1079         ishex = 1;
1080         break;
1081       } else {  /* we saw a '0', but no 'x' */
1082         gotmantdig = 1;
1083         goto reswitch;
1084       }
1085     case S_DIGITS:
1086       if ((ishex && isxdigit(c)) || isdigit(c))
1087         gotmantdig = 1;
1088       else {
1089         state = S_FRAC;
1090         if (c != decpt)
1091           goto reswitch;
1092       }
1093       if (gotmantdig)
1094         commit = p;
1095       break;
1096     case S_FRAC:
1097       if (((c == 'E' || c == 'e') && !ishex) ||
1098           ((c == 'P' || c == 'p') && ishex)) {
1099         if (!gotmantdig)
1100           goto parsedone;
1101         else
1102           state = S_EXP;
1103       } else if ((ishex && isxdigit(c)) || isdigit(c)) {
1104         commit = p;
1105         gotmantdig = 1;
1106       } else
1107         goto parsedone;
1108       break;
1109     case S_EXP:
1110       state = S_EXPDIGITS;
1111       if (c == '-' || c == '+')
1112         break;
1113       else
1114         goto reswitch;
1115     case S_EXPDIGITS:
1116       if (isdigit(c))
1117         commit = p;
1118       else
1119         goto parsedone;
1120       break;
1121     default:
1122       abort();
1123     }
1124     *p++ = c;
1125     if (--fp->_r > 0)
1126       fp->_p++;
1127     else if (__srefill(fp))
1128       break;  /* EOF */
1129   }
1130
1131 parsedone:
1132   while (commit < --p)
1133     (void)ungetc(*(u_char *)p, fp);
1134   *++commit = '\0';
1135   return (int)(commit - buf);
1136 }
1137 #endif