1 /*- 2 * Copyright (c) 1990, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Chris Torek. 7 * 8 * Copyright (c) 2011 The FreeBSD Foundation 9 * All rights reserved. 10 * Portions of this software were developed by David Chisnall 11 * under sponsorship from the FreeBSD Foundation. 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 3. Neither the name of the University nor the names of its contributors 22 * may be used to endorse or promote products derived from this software 23 * without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 35 * SUCH DAMAGE. 36 * 37 * @(#)vfscanf.c 8.1 (Berkeley) 6/4/93 38 * $FreeBSD: head/lib/libc/stdio/vfwscanf.c 249808 2013-04-23 13:33:13Z emaste $ 39 */ 40 41 #include "namespace.h" 42 #include <ctype.h> 43 #include <inttypes.h> 44 #include <limits.h> 45 #include <stdio.h> 46 #include <stdlib.h> 47 #include <stddef.h> 48 #include <stdarg.h> 49 #include <string.h> 50 #include <wchar.h> 51 #include <wctype.h> 52 #include "un-namespace.h" 53 54 #include "libc_private.h" 55 #include "local.h" 56 #include "xlocale_private.h" 57 58 #define BUF 513 /* Maximum length of numeric string. */ 59 60 /* 61 * Flags used during conversion. 62 */ 63 #define LONG 0x01 /* l: long or double */ 64 #define LONGDBL 0x02 /* L: long double */ 65 #define SHORT 0x04 /* h: short */ 66 #define SUPPRESS 0x08 /* *: suppress assignment */ 67 #define POINTER 0x10 /* p: void * (as hex) */ 68 #define NOSKIP 0x20 /* [ or c: do not skip blanks */ 69 #define LONGLONG 0x400 /* ll: long long (+ deprecated q: quad) */ 70 #define INTMAXT 0x800 /* j: intmax_t */ 71 #define PTRDIFFT 0x1000 /* t: ptrdiff_t */ 72 #define SIZET 0x2000 /* z: size_t */ 73 #define SHORTSHORT 0x4000 /* hh: char */ 74 #define UNSIGNED 0x8000 /* %[oupxX] conversions */ 75 76 /* 77 * The following are used in integral conversions only: 78 * SIGNOK, NDIGITS, PFXOK, and NZDIGITS 79 */ 80 #define SIGNOK 0x40 /* +/- is (still) legal */ 81 #define NDIGITS 0x80 /* no digits detected */ 82 #define PFXOK 0x100 /* 0x prefix is (still) legal */ 83 #define NZDIGITS 0x200 /* no zero digits detected */ 84 #define HAVESIGN 0x10000 /* sign detected */ 85 86 /* 87 * Conversion types. 88 */ 89 #define CT_CHAR 0 /* %c conversion */ 90 #define CT_CCL 1 /* %[...] conversion */ 91 #define CT_STRING 2 /* %s conversion */ 92 #define CT_INT 3 /* %[dioupxX] conversion */ 93 #define CT_FLOAT 4 /* %[efgEFG] conversion */ 94 95 #ifndef NO_FLOATING_POINT 96 static int parsefloat(FILE *, wchar_t *, wchar_t *, locale_t); 97 #endif 98 99 struct ccl { 100 const wchar_t *start; /* character class start */ 101 const wchar_t *end; /* character class end */ 102 int compl; /* ccl is complemented? */ 103 }; 104 105 static __inline int 106 inccl(const struct ccl *ccl, wint_t wi) 107 { 108 109 if (ccl->compl) { 110 return (wmemchr(ccl->start, wi, ccl->end - ccl->start) 111 == NULL); 112 } else { 113 return (wmemchr(ccl->start, wi, ccl->end - ccl->start) != NULL); 114 } 115 } 116 117 /* 118 * Conversion functions are passed a pointer to this object instead of 119 * a real parameter to indicate that the assignment-suppression (*) 120 * flag was specified. We could use a NULL pointer to indicate this, 121 * but that would mask bugs in applications that call scanf() with a 122 * NULL pointer. 123 */ 124 static const int suppress; 125 #define SUPPRESS_PTR ((void *)&suppress) 126 127 static const mbstate_t initial_mbs; 128 129 /* 130 * The following conversion functions return the number of characters consumed, 131 * or -1 on input failure. Character class conversion returns 0 on match 132 * failure. 133 */ 134 135 static __inline int 136 convert_char(FILE *fp, char * mbp, int width, locale_t locale) 137 { 138 mbstate_t mbs; 139 size_t nconv; 140 wint_t wi; 141 int n; 142 143 n = 0; 144 mbs = initial_mbs; 145 while (width-- != 0 && (wi = __fgetwc(fp, locale)) != WEOF) { 146 if (mbp != SUPPRESS_PTR) { 147 nconv = wcrtomb(mbp, wi, &mbs); 148 if (nconv == (size_t)-1) 149 return (-1); 150 mbp += nconv; 151 } 152 n++; 153 } 154 if (n == 0) 155 return (-1); 156 return (n); 157 } 158 159 static __inline int 160 convert_wchar(FILE *fp, wchar_t *wcp, int width, locale_t locale) 161 { 162 wint_t wi; 163 int n; 164 165 n = 0; 166 while (width-- != 0 && (wi = __fgetwc(fp, locale)) != WEOF) { 167 if (wcp != SUPPRESS_PTR) 168 *wcp++ = (wchar_t)wi; 169 n++; 170 } 171 if (n == 0) 172 return (-1); 173 return (n); 174 } 175 176 static __inline int 177 convert_ccl(FILE *fp, char * mbp, int width, const struct ccl *ccl, 178 locale_t locale) 179 { 180 mbstate_t mbs; 181 size_t nconv; 182 wint_t wi; 183 int n; 184 185 n = 0; 186 mbs = initial_mbs; 187 while ((wi = __fgetwc(fp, locale)) != WEOF && 188 width-- != 0 && inccl(ccl, wi)) { 189 if (mbp != SUPPRESS_PTR) { 190 nconv = wcrtomb(mbp, wi, &mbs); 191 if (nconv == (size_t)-1) 192 return (-1); 193 mbp += nconv; 194 } 195 n++; 196 } 197 if (wi != WEOF) 198 __ungetwc(wi, fp, locale); 199 if (mbp != SUPPRESS_PTR) 200 *mbp = 0; 201 return (n); 202 } 203 204 static __inline int 205 convert_wccl(FILE *fp, wchar_t *wcp, int width, const struct ccl *ccl, 206 locale_t locale) 207 { 208 wchar_t *wcp0; 209 wint_t wi; 210 int n; 211 212 if (wcp == SUPPRESS_PTR) { 213 n = 0; 214 while ((wi = __fgetwc(fp, locale)) != WEOF && 215 width-- != 0 && inccl(ccl, wi)) 216 n++; 217 if (wi != WEOF) 218 __ungetwc(wi, fp, locale); 219 } else { 220 wcp0 = wcp; 221 while ((wi = __fgetwc(fp, locale)) != WEOF && 222 width-- != 0 && inccl(ccl, wi)) 223 *wcp++ = (wchar_t)wi; 224 if (wi != WEOF) 225 __ungetwc(wi, fp, locale); 226 n = wcp - wcp0; 227 if (n == 0) 228 return (0); 229 *wcp = 0; 230 } 231 return (n); 232 } 233 234 static __inline int 235 convert_string(FILE *fp, char * mbp, int width, locale_t locale) 236 { 237 mbstate_t mbs; 238 size_t nconv; 239 wint_t wi; 240 int nread; 241 242 mbs = initial_mbs; 243 nread = 0; 244 while ((wi = __fgetwc(fp, locale)) != WEOF && width-- != 0 && 245 !iswspace(wi)) { 246 if (mbp != SUPPRESS_PTR) { 247 nconv = wcrtomb(mbp, wi, &mbs); 248 if (nconv == (size_t)-1) 249 return (-1); 250 mbp += nconv; 251 } 252 nread++; 253 } 254 if (wi != WEOF) 255 __ungetwc(wi, fp, locale); 256 if (mbp != SUPPRESS_PTR) 257 *mbp = 0; 258 return (nread); 259 } 260 261 static __inline int 262 convert_wstring(FILE *fp, wchar_t *wcp, int width, locale_t locale) 263 { 264 wchar_t *wcp0 __unused; 265 wint_t wi; 266 int nread; 267 268 nread = 0; 269 if (wcp == SUPPRESS_PTR) { 270 while ((wi = __fgetwc(fp, locale)) != WEOF && 271 width-- != 0 && !iswspace(wi)) 272 nread++; 273 if (wi != WEOF) 274 __ungetwc(wi, fp, locale); 275 } else { 276 wcp0 = wcp; 277 while ((wi = __fgetwc(fp, locale)) != WEOF && 278 width-- != 0 && !iswspace(wi)) { 279 *wcp++ = (wchar_t)wi; 280 nread++; 281 } 282 if (wi != WEOF) 283 __ungetwc(wi, fp, locale); 284 *wcp = '\0'; 285 } 286 return (nread); 287 } 288 289 /* 290 * Read an integer, storing it in buf. The only relevant bit in the 291 * flags argument is PFXOK. 292 * 293 * Return 0 on a match failure, and the number of characters read 294 * otherwise. 295 */ 296 static __inline int 297 parseint(FILE *fp, wchar_t *buf, int width, int base, int flags, 298 locale_t locale) 299 { 300 /* `basefix' is used to avoid `if' tests */ 301 static const short basefix[17] = 302 { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; 303 wchar_t *wcp; 304 int c; 305 306 flags |= SIGNOK | NDIGITS | NZDIGITS; 307 for (wcp = buf; width; width--) { 308 c = __fgetwc(fp, locale); 309 /* 310 * Switch on the character; `goto ok' if we accept it 311 * as a part of number. 312 */ 313 switch (c) { 314 315 /* 316 * The digit 0 is always legal, but is special. For 317 * %i conversions, if no digits (zero or nonzero) have 318 * been scanned (only signs), we will have base==0. 319 * In that case, we should set it to 8 and enable 0x 320 * prefixing. Also, if we have not scanned zero 321 * digits before this, do not turn off prefixing 322 * (someone else will turn it off if we have scanned 323 * any nonzero digits). 324 */ 325 case '0': 326 if (base == 0) { 327 base = 8; 328 flags |= PFXOK; 329 } 330 if (flags & NZDIGITS) 331 flags &= ~(SIGNOK|NZDIGITS|NDIGITS); 332 else 333 flags &= ~(SIGNOK|PFXOK|NDIGITS); 334 goto ok; 335 336 /* 1 through 7 always legal */ 337 case '1': case '2': case '3': 338 case '4': case '5': case '6': case '7': 339 base = basefix[base]; 340 flags &= ~(SIGNOK | PFXOK | NDIGITS); 341 goto ok; 342 343 /* digits 8 and 9 ok iff decimal or hex */ 344 case '8': case '9': 345 base = basefix[base]; 346 if (base <= 8) 347 break; /* not legal here */ 348 flags &= ~(SIGNOK | PFXOK | NDIGITS); 349 goto ok; 350 351 /* letters ok iff hex */ 352 case 'A': case 'B': case 'C': 353 case 'D': case 'E': case 'F': 354 case 'a': case 'b': case 'c': 355 case 'd': case 'e': case 'f': 356 /* no need to fix base here */ 357 if (base <= 10) 358 break; /* not legal here */ 359 flags &= ~(SIGNOK | PFXOK | NDIGITS); 360 goto ok; 361 362 /* sign ok only as first character */ 363 case '+': case '-': 364 if (flags & SIGNOK) { 365 flags &= ~SIGNOK; 366 flags |= HAVESIGN; 367 goto ok; 368 } 369 break; 370 371 /* 372 * x ok iff flag still set & 2nd char (or 3rd char if 373 * we have a sign). 374 */ 375 case 'x': case 'X': 376 if (flags & PFXOK && wcp == 377 buf + 1 + !!(flags & HAVESIGN)) { 378 base = 16; /* if %i */ 379 flags &= ~PFXOK; 380 goto ok; 381 } 382 break; 383 } 384 385 /* 386 * If we got here, c is not a legal character for a 387 * number. Stop accumulating digits. 388 */ 389 if (c != WEOF) 390 __ungetwc(c, fp, locale); 391 break; 392 ok: 393 /* 394 * c is legal: store it and look at the next. 395 */ 396 *wcp++ = (wchar_t)c; 397 } 398 /* 399 * If we had only a sign, it is no good; push back the sign. 400 * If the number ends in `x', it was [sign] '0' 'x', so push 401 * back the x and treat it as [sign] '0'. 402 */ 403 if (flags & NDIGITS) { 404 if (wcp > buf) 405 __ungetwc(*--wcp, fp, locale); 406 return (0); 407 } 408 c = wcp[-1]; 409 if (c == 'x' || c == 'X') { 410 --wcp; 411 __ungetwc(c, fp, locale); 412 } 413 return (wcp - buf); 414 } 415 416 /* 417 * MT-safe version. 418 */ 419 int 420 vfwscanf_l(FILE * __restrict fp, locale_t locale, 421 const wchar_t * __restrict fmt, va_list ap) 422 { 423 int ret; 424 FIX_LOCALE(locale); 425 426 FLOCKFILE(fp); 427 ORIENT(fp, 1); 428 ret = __vfwscanf(fp, locale, fmt, ap); 429 FUNLOCKFILE(fp); 430 return (ret); 431 } 432 int 433 vfwscanf(FILE * __restrict fp, const wchar_t * __restrict fmt, va_list ap) 434 { 435 return vfwscanf_l(fp, __get_locale(), fmt, ap); 436 } 437 438 /* 439 * Non-MT-safe version. 440 */ 441 int 442 __vfwscanf(FILE * __restrict fp, locale_t locale, 443 const wchar_t * __restrict fmt, va_list ap) 444 { 445 #define GETARG(type) ((flags & SUPPRESS) ? SUPPRESS_PTR : va_arg(ap, type)) 446 wint_t c; /* character from format, or conversion */ 447 size_t width; /* field width, or 0 */ 448 int flags; /* flags as defined above */ 449 int nassigned; /* number of fields assigned */ 450 int nconversions; /* number of conversions */ 451 int nr; /* characters read by the current conversion */ 452 int nread; /* number of characters consumed from fp */ 453 int base; /* base argument to conversion function */ 454 struct ccl ccl; /* character class info */ 455 wchar_t buf[BUF]; /* buffer for numeric conversions */ 456 wint_t wi; /* handy wint_t */ 457 458 nassigned = 0; 459 nconversions = 0; 460 nread = 0; 461 ccl.start = ccl.end = NULL; 462 for (;;) { 463 c = *fmt++; 464 if (c == 0) 465 return (nassigned); 466 if (iswspace(c)) { 467 while ((c = __fgetwc(fp, locale)) != WEOF && 468 iswspace_l(c, locale)) 469 nread++; 470 if (c != WEOF) 471 __ungetwc(c, fp, locale); 472 continue; 473 } 474 if (c != '%') 475 goto literal; 476 width = 0; 477 flags = 0; 478 /* 479 * switch on the format. continue if done; 480 * break once format type is derived. 481 */ 482 again: c = *fmt++; 483 switch (c) { 484 case '%': 485 literal: 486 if ((wi = __fgetwc(fp, locale)) == WEOF) 487 goto input_failure; 488 if (wi != c) { 489 __ungetwc(wi, fp, locale); 490 goto input_failure; 491 } 492 nread++; 493 continue; 494 495 case '*': 496 flags |= SUPPRESS; 497 goto again; 498 case 'j': 499 flags |= INTMAXT; 500 goto again; 501 case 'l': 502 if (flags & LONG) { 503 flags &= ~LONG; 504 flags |= LONGLONG; 505 } else 506 flags |= LONG; 507 goto again; 508 case 'q': 509 flags |= LONGLONG; /* not quite */ 510 goto again; 511 case 't': 512 flags |= PTRDIFFT; 513 goto again; 514 case 'z': 515 flags |= SIZET; 516 goto again; 517 case 'L': 518 flags |= LONGDBL; 519 goto again; 520 case 'h': 521 if (flags & SHORT) { 522 flags &= ~SHORT; 523 flags |= SHORTSHORT; 524 } else 525 flags |= SHORT; 526 goto again; 527 528 case '0': case '1': case '2': case '3': case '4': 529 case '5': case '6': case '7': case '8': case '9': 530 width = width * 10 + c - '0'; 531 goto again; 532 533 /* 534 * Conversions. 535 */ 536 case 'd': 537 c = CT_INT; 538 base = 10; 539 break; 540 541 case 'i': 542 c = CT_INT; 543 base = 0; 544 break; 545 546 case 'o': 547 c = CT_INT; 548 flags |= UNSIGNED; 549 base = 8; 550 break; 551 552 case 'u': 553 c = CT_INT; 554 flags |= UNSIGNED; 555 base = 10; 556 break; 557 558 case 'X': 559 case 'x': 560 flags |= PFXOK; /* enable 0x prefixing */ 561 c = CT_INT; 562 flags |= UNSIGNED; 563 base = 16; 564 break; 565 566 #ifndef NO_FLOATING_POINT 567 case 'A': case 'E': case 'F': case 'G': 568 case 'a': case 'e': case 'f': case 'g': 569 c = CT_FLOAT; 570 break; 571 #endif 572 573 case 'S': 574 flags |= LONG; 575 /* FALLTHROUGH */ 576 case 's': 577 c = CT_STRING; 578 break; 579 580 case '[': 581 ccl.start = fmt; 582 if (*fmt == '^') { 583 ccl.compl = 1; 584 fmt++; 585 } else 586 ccl.compl = 0; 587 if (*fmt == ']') 588 fmt++; 589 while (*fmt != '\0' && *fmt != ']') 590 fmt++; 591 ccl.end = fmt; 592 fmt++; 593 flags |= NOSKIP; 594 c = CT_CCL; 595 break; 596 597 case 'C': 598 flags |= LONG; 599 /* FALLTHROUGH */ 600 case 'c': 601 flags |= NOSKIP; 602 c = CT_CHAR; 603 break; 604 605 case 'p': /* pointer format is like hex */ 606 flags |= POINTER | PFXOK; 607 c = CT_INT; /* assumes sizeof(uintmax_t) */ 608 flags |= UNSIGNED; /* >= sizeof(uintptr_t) */ 609 base = 16; 610 break; 611 612 case 'n': 613 if (flags & SUPPRESS) /* ??? */ 614 continue; 615 if (flags & SHORTSHORT) 616 *va_arg(ap, char *) = nread; 617 else if (flags & SHORT) 618 *va_arg(ap, short *) = nread; 619 else if (flags & LONG) 620 *va_arg(ap, long *) = nread; 621 else if (flags & LONGLONG) 622 *va_arg(ap, long long *) = nread; 623 else if (flags & INTMAXT) 624 *va_arg(ap, intmax_t *) = nread; 625 else if (flags & SIZET) 626 *va_arg(ap, size_t *) = nread; 627 else if (flags & PTRDIFFT) 628 *va_arg(ap, ptrdiff_t *) = nread; 629 else 630 *va_arg(ap, int *) = nread; 631 continue; 632 633 default: 634 goto match_failure; 635 636 /* 637 * Disgusting backwards compatibility hack. XXX 638 */ 639 case '\0': /* compat */ 640 return (EOF); 641 } 642 643 /* 644 * Consume leading white space, except for formats 645 * that suppress this. 646 */ 647 if ((flags & NOSKIP) == 0) { 648 while ((wi = __fgetwc(fp, locale)) != WEOF && iswspace(wi)) 649 nread++; 650 if (wi == WEOF) 651 goto input_failure; 652 __ungetwc(wi, fp, locale); 653 } 654 655 /* 656 * Do the conversion. 657 */ 658 switch (c) { 659 660 case CT_CHAR: 661 /* scan arbitrary characters (sets NOSKIP) */ 662 if (width == 0) 663 width = 1; 664 if (flags & LONG) { 665 nr = convert_wchar(fp, GETARG(wchar_t *), width, 666 locale); 667 } else { 668 nr = convert_char(fp, GETARG(char *), width, 669 locale); 670 } 671 if (nr < 0) 672 goto input_failure; 673 break; 674 675 case CT_CCL: 676 /* scan a (nonempty) character class (sets NOSKIP) */ 677 if (width == 0) 678 width = (size_t)~0; /* `infinity' */ 679 /* take only those things in the class */ 680 if (flags & LONG) { 681 nr = convert_wccl(fp, GETARG(wchar_t *), width, 682 &ccl, locale); 683 } else { 684 nr = convert_ccl(fp, GETARG(char *), width, 685 &ccl, locale); 686 } 687 if (nr <= 0) { 688 if (nr < 0) 689 goto input_failure; 690 else /* nr == 0 */ 691 goto match_failure; 692 } 693 break; 694 695 case CT_STRING: 696 /* like CCL, but zero-length string OK, & no NOSKIP */ 697 if (width == 0) 698 width = (size_t)~0; 699 if (flags & LONG) { 700 nr = convert_wstring(fp, GETARG(wchar_t *), 701 width, locale); 702 } else { 703 nr = convert_string(fp, GETARG(char *), width, 704 locale); 705 } 706 if (nr < 0) 707 goto input_failure; 708 break; 709 710 case CT_INT: 711 /* scan an integer as if by the conversion function */ 712 if (width == 0 || width > sizeof(buf) / 713 sizeof(*buf) - 1) 714 width = sizeof(buf) / sizeof(*buf) - 1; 715 716 nr = parseint(fp, buf, width, base, flags, locale); 717 if (nr == 0) 718 goto match_failure; 719 if ((flags & SUPPRESS) == 0) { 720 uintmax_t res; 721 722 buf[nr] = L'\0'; 723 if ((flags & UNSIGNED) == 0) 724 res = wcstoimax(buf, NULL, base); 725 else 726 res = wcstoumax(buf, NULL, base); 727 if (flags & POINTER) 728 *va_arg(ap, void **) = 729 (void *)(uintptr_t)res; 730 else if (flags & SHORTSHORT) 731 *va_arg(ap, char *) = res; 732 else if (flags & SHORT) 733 *va_arg(ap, short *) = res; 734 else if (flags & LONG) 735 *va_arg(ap, long *) = res; 736 else if (flags & LONGLONG) 737 *va_arg(ap, long long *) = res; 738 else if (flags & INTMAXT) 739 *va_arg(ap, intmax_t *) = res; 740 else if (flags & PTRDIFFT) 741 *va_arg(ap, ptrdiff_t *) = res; 742 else if (flags & SIZET) 743 *va_arg(ap, size_t *) = res; 744 else 745 *va_arg(ap, int *) = res; 746 } 747 break; 748 749 #ifndef NO_FLOATING_POINT 750 case CT_FLOAT: 751 /* scan a floating point number as if by strtod */ 752 if (width == 0 || width > sizeof(buf) / 753 sizeof(*buf) - 1) 754 width = sizeof(buf) / sizeof(*buf) - 1; 755 nr = parsefloat(fp, buf, buf + width, locale); 756 if (nr == 0) 757 goto match_failure; 758 if ((flags & SUPPRESS) == 0) { 759 if (flags & LONGDBL) { 760 long double res = wcstold(buf, NULL); 761 *va_arg(ap, long double *) = res; 762 } else if (flags & LONG) { 763 double res = wcstod(buf, NULL); 764 *va_arg(ap, double *) = res; 765 } else { 766 float res = wcstof(buf, NULL); 767 *va_arg(ap, float *) = res; 768 } 769 } 770 break; 771 #endif /* !NO_FLOATING_POINT */ 772 } 773 if (!(flags & SUPPRESS)) 774 nassigned++; 775 nread += nr; 776 nconversions++; 777 } 778 input_failure: 779 return (nconversions != 0 ? nassigned : EOF); 780 match_failure: 781 return (nassigned); 782 } 783 784 #ifndef NO_FLOATING_POINT 785 static int 786 parsefloat(FILE *fp, wchar_t *buf, wchar_t *end, locale_t locale) 787 { 788 mbstate_t mbs; 789 size_t nconv; 790 wchar_t *commit, *p; 791 int infnanpos = 0; 792 enum { 793 S_START, S_GOTSIGN, S_INF, S_NAN, S_DONE, S_MAYBEHEX, 794 S_DIGITS, S_FRAC, S_EXP, S_EXPDIGITS 795 } state = S_START; 796 wchar_t c; 797 wchar_t decpt; 798 _Bool gotmantdig = 0, ishex = 0; 799 800 mbs = initial_mbs; 801 nconv = mbrtowc(&decpt, localeconv()->decimal_point, MB_CUR_MAX, &mbs); 802 if (nconv == (size_t)-1 || nconv == (size_t)-2) 803 decpt = '.'; /* failsafe */ 804 805 /* 806 * We set commit = p whenever the string we have read so far 807 * constitutes a valid representation of a floating point 808 * number by itself. At some point, the parse will complete 809 * or fail, and we will ungetc() back to the last commit point. 810 * To ensure that the file offset gets updated properly, it is 811 * always necessary to read at least one character that doesn't 812 * match; thus, we can't short-circuit "infinity" or "nan(...)". 813 */ 814 commit = buf - 1; 815 c = WEOF; 816 for (p = buf; p < end; ) { 817 if ((c = __fgetwc(fp, locale)) == WEOF) 818 break; 819 reswitch: 820 switch (state) { 821 case S_START: 822 state = S_GOTSIGN; 823 if (c == '-' || c == '+') 824 break; 825 else 826 goto reswitch; 827 case S_GOTSIGN: 828 switch (c) { 829 case '0': 830 state = S_MAYBEHEX; 831 commit = p; 832 break; 833 case 'I': 834 case 'i': 835 state = S_INF; 836 break; 837 case 'N': 838 case 'n': 839 state = S_NAN; 840 break; 841 default: 842 state = S_DIGITS; 843 goto reswitch; 844 } 845 break; 846 case S_INF: 847 if (infnanpos > 6 || 848 (c != "nfinity"[infnanpos] && 849 c != "NFINITY"[infnanpos])) 850 goto parsedone; 851 if (infnanpos == 1 || infnanpos == 6) 852 commit = p; /* inf or infinity */ 853 infnanpos++; 854 break; 855 case S_NAN: 856 switch (infnanpos) { 857 case 0: 858 if (c != 'A' && c != 'a') 859 goto parsedone; 860 break; 861 case 1: 862 if (c != 'N' && c != 'n') 863 goto parsedone; 864 else 865 commit = p; 866 break; 867 case 2: 868 if (c != '(') 869 goto parsedone; 870 break; 871 default: 872 if (c == ')') { 873 commit = p; 874 state = S_DONE; 875 } else if (!iswalnum(c) && c != '_') 876 goto parsedone; 877 break; 878 } 879 infnanpos++; 880 break; 881 case S_DONE: 882 goto parsedone; 883 case S_MAYBEHEX: 884 state = S_DIGITS; 885 if (c == 'X' || c == 'x') { 886 ishex = 1; 887 break; 888 } else { /* we saw a '0', but no 'x' */ 889 gotmantdig = 1; 890 goto reswitch; 891 } 892 case S_DIGITS: 893 if ((ishex && iswxdigit(c)) || iswdigit(c)) 894 gotmantdig = 1; 895 else { 896 state = S_FRAC; 897 if (c != decpt) 898 goto reswitch; 899 } 900 if (gotmantdig) 901 commit = p; 902 break; 903 case S_FRAC: 904 if (((c == 'E' || c == 'e') && !ishex) || 905 ((c == 'P' || c == 'p') && ishex)) { 906 if (!gotmantdig) 907 goto parsedone; 908 else 909 state = S_EXP; 910 } else if ((ishex && iswxdigit(c)) || iswdigit(c)) { 911 commit = p; 912 gotmantdig = 1; 913 } else 914 goto parsedone; 915 break; 916 case S_EXP: 917 state = S_EXPDIGITS; 918 if (c == '-' || c == '+') 919 break; 920 else 921 goto reswitch; 922 case S_EXPDIGITS: 923 if (iswdigit(c)) 924 commit = p; 925 else 926 goto parsedone; 927 break; 928 default: 929 abort(); 930 } 931 *p++ = c; 932 c = WEOF; 933 } 934 935 parsedone: 936 if (c != WEOF) 937 __ungetwc(c, fp, locale); 938 while (commit < --p) 939 __ungetwc(*p, fp, locale); 940 *++commit = '\0'; 941 return (commit - buf); 942 } 943 #endif 944