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