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