]>
git.proxmox.com Git - mirror_edk2.git/blob - StdLib/LibC/Stdio/vfwscanf.c
2 Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
3 This program and the accompanying materials are licensed and made available under
4 the terms and conditions of the BSD License that accompanies this distribution.
5 The full text of the license may be found at
6 http://opensource.org/licenses/bsd-license.
8 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
9 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11 * Copyright (c) 1990, 1993
12 * The Regents of the University of California. All rights reserved.
14 * This code is derived from software contributed to Berkeley by
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions
20 * 1. Redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer.
22 * 2. Redistributions in binary form must reproduce the above copyright
23 * notice, this list of conditions and the following disclaimer in the
24 * documentation and/or other materials provided with the distribution.
25 * 3. All advertising materials mentioning features or use of this software
26 * must display the following acknowledgement:
27 * This product includes software developed by the University of
28 * California, Berkeley and its contributors.
29 * 4. Neither the name of the University nor the names of its contributors
30 * may be used to endorse or promote products derived from this software
31 * without specific prior written permission.
33 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
34 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
35 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
36 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
37 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
38 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
39 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
40 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
41 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
42 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
45 FreeBSD: src/lib/libc/stdio/vfwscanf.c,v 1.12 2004/05/02 20:13:29 obrien Exp
46 NetBSD: vfwscanf.c,v 1.2 2005/06/12 05:48:41 lukem Exp
48 #include <LibConfig.h>
49 #include <sys/EfiCdefs.h>
51 #include "namespace.h"
63 #include "reentrant.h"
66 #ifndef NO_FLOATING_POINT
70 #if defined(_MSC_VER) /* Handle Microsoft VC++ compiler specifics. */
71 #pragma warning ( disable : 4244 ) // Allow wint_t to wchar_t conversions
72 #pragma warning ( disable : 4305 ) // Allow truncation from UINT64 to void*
73 #pragma warning ( disable : 4701 ) // Disable false warning for local variable p near line 375
77 #define BUF 513 /* Maximum length of numeric string. */
80 * Flags used during conversion.
82 #define LONG 0x01 /* l: long or double */
83 #define LONGDBL 0x02 /* L: long double */
84 #define SHORT 0x04 /* h: short */
85 #define SUPPRESS 0x08 /* *: suppress assignment */
86 #define POINTER 0x10 /* p: void * (as hex) */
87 #define NOSKIP 0x20 /* [ or c: do not skip blanks */
88 #define LONGLONG 0x400 /* ll: quad_t (+ deprecated q: quad) */
89 #define INTMAXT 0x800 /* j: intmax_t */
90 #define PTRDIFFT 0x1000 /* t: ptrdiff_t */
91 #define SIZET 0x2000 /* z: size_t */
92 #define SHORTSHORT 0x4000 /* hh: char */
93 #define UNSIGNED 0x8000 /* %[oupxX] conversions */
96 * The following are used in integral conversions only:
97 * SIGNOK, NDIGITS, PFXOK, and NZDIGITS
99 #define SIGNOK 0x40 /* +/- is (still) legal */
100 #define NDIGITS 0x80 /* no digits detected */
101 #define PFXOK 0x100 /* 0x prefix is (still) legal */
102 #define NZDIGITS 0x200 /* no zero digits detected */
103 #define HAVESIGN 0x10000 /* sign detected */
108 #define CT_CHAR 0 /* %c conversion */
109 #define CT_CCL 1 /* %[...] conversion */
110 #define CT_STRING 2 /* %s conversion */
111 #define CT_INT 3 /* %[dioupxX] conversion */
112 #define CT_FLOAT 4 /* %[efgEFG] conversion */
114 static int parsefloat(FILE *, wchar_t *, wchar_t *);
117 (cclcompl ? (wmemchr(ccls, (_c), (size_t)(ccle - ccls)) == NULL) : \
118 (wmemchr(ccls, (_c), (size_t)(ccle - ccls)) != NULL))
124 vfwscanf(FILE * __restrict fp
, const wchar_t * __restrict fmt
, va_list ap
)
129 _SET_ORIENTATION(fp
, 1);
130 ret
= __vfwscanf_unlocked(fp
, fmt
, ap
);
136 * Non-MT-safe version.
139 __vfwscanf_unlocked(FILE * __restrict fp
, const wchar_t * __restrict fmt
, va_list ap
)
141 wint_t c
; /* character from format, or conversion */
142 size_t width
; /* field width, or 0 */
143 wchar_t *p
; /* points into all kinds of strings */
144 int n
; /* handy integer */
145 int flags
; /* flags as defined above */
146 wchar_t *p0
; /* saves original value of p when necessary */
147 int nassigned
; /* number of fields assigned */
148 int nconversions
; /* number of conversions */
149 int nread
; /* number of characters consumed from fp */
150 int base
; /* base argument to conversion function */
151 wchar_t buf
[BUF
]; /* buffer for numeric conversions */
152 const wchar_t *ccls
; /* character class start */
153 const wchar_t *ccle
; /* character class end */
154 int cclcompl
; /* ccl is complemented? */
155 wint_t wi
; /* handy wint_t */
156 char *mbp
; /* multibyte string pointer for %c %s %[ */
157 size_t nconv
; /* number of bytes in mb. conversion */
158 char mbbuf
[MB_LEN_MAX
]; /* temporary mb. character buffer */
159 static const mbstate_t initial
= { 0 };
162 /* `basefix' is used to avoid `if' tests in the integer scanner */
163 static short basefix
[17] =
164 { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
178 while ((c
= __fgetwc_unlock(fp
)) != WEOF
&&
190 * switch on the format. continue if done;
191 * break once format type is derived.
197 if ((wi
= __fgetwc_unlock(fp
)) == WEOF
)
220 flags
|= LONGLONG
; /* not quite */
239 case '0': case '1': case '2': case '3': case '4':
240 case '5': case '6': case '7': case '8': case '9':
241 width
= width
* 10 + c
- '0';
271 flags
|= PFXOK
; /* enable 0x prefixing */
277 #ifndef NO_FLOATING_POINT
279 case 'E': case 'F': case 'G':
281 case 'e': case 'f': case 'g':
302 while (*fmt
!= '\0' && *fmt
!= ']')
318 case 'p': /* pointer format is like hex */
319 flags
|= POINTER
| PFXOK
;
320 c
= CT_INT
; /* assumes sizeof(uintmax_t) */
321 flags
|= UNSIGNED
; /* >= sizeof(uintptr_t) */
327 if (flags
& SUPPRESS
) /* ??? */
329 if (flags
& SHORTSHORT
)
330 *va_arg(ap
, char *) = (char)nread
;
331 else if (flags
& SHORT
)
332 *va_arg(ap
, short *) = (short)nread
;
333 else if (flags
& LONG
)
334 *va_arg(ap
, long *) = (long)nread
;
335 else if (flags
& LONGLONG
)
336 *va_arg(ap
, INT64
*) = (INT64
)nread
; // was quad_t
337 else if (flags
& INTMAXT
)
338 *va_arg(ap
, intmax_t *) = (intmax_t)nread
;
339 else if (flags
& SIZET
)
340 *va_arg(ap
, size_t *) = (size_t)nread
;
341 else if (flags
& PTRDIFFT
)
342 *va_arg(ap
, ptrdiff_t *) = (ptrdiff_t)nread
;
344 *va_arg(ap
, int *) = nread
;
351 * Disgusting backwards compatibility hack. XXX
353 case '\0': /* compat */
358 * Consume leading white space, except for formats
359 * that suppress this.
361 if ((flags
& NOSKIP
) == 0) {
362 while ((wi
= __fgetwc_unlock(fp
)) != WEOF
&& iswspace(wi
))
375 /* scan arbitrary characters (sets NOSKIP) */
379 if (!(flags
& SUPPRESS
))
380 p
= va_arg(ap
, wchar_t *);
382 while (width
-- != 0 &&
383 (wi
= __fgetwc_unlock(fp
)) != WEOF
) {
384 if (!(flags
& SUPPRESS
))
391 if (!(flags
& SUPPRESS
))
394 if (!(flags
& SUPPRESS
))
395 mbp
= va_arg(ap
, char *);
399 (wi
= __fgetwc_unlock(fp
)) != WEOF
) {
400 if (width
>= MB_CUR_MAX
&&
401 !(flags
& SUPPRESS
)) {
402 nconv
= wcrtomb(mbp
, (wchar_t)wi
, &mbs
);
403 if (nconv
== (size_t)-1)
406 nconv
= wcrtomb(mbbuf
, (wchar_t)wi
,
408 if (nconv
== (size_t)-1)
414 if (!(flags
& SUPPRESS
))
418 if (!(flags
& SUPPRESS
))
426 if (!(flags
& SUPPRESS
))
433 /* scan a (nonempty) character class (sets NOSKIP) */
435 width
= (size_t)~0; /* `infinity' */
436 /* take only those things in the class */
437 if ((flags
& SUPPRESS
) && (flags
& LONG
)) {
439 while ((wi
= __fgetwc_unlock(fp
)) != WEOF
&&
440 width
-- != 0 && INCCL(wi
))
446 } else if (flags
& LONG
) {
447 p0
= p
= va_arg(ap
, wchar_t *);
448 while ((wi
= __fgetwc_unlock(fp
)) != WEOF
&&
449 width
-- != 0 && INCCL(wi
))
459 if (!(flags
& SUPPRESS
))
460 mbp
= va_arg(ap
, char *);
463 while ((wi
= __fgetwc_unlock(fp
)) != WEOF
&&
464 width
!= 0 && INCCL(wi
)) {
465 if (width
>= MB_CUR_MAX
&&
466 !(flags
& SUPPRESS
)) {
467 nconv
= wcrtomb(mbp
, wi
, &mbs
);
468 if (nconv
== (size_t)-1)
471 nconv
= wcrtomb(mbbuf
, wi
,
473 if (nconv
== (size_t)-1)
477 if (!(flags
& SUPPRESS
))
481 if (!(flags
& SUPPRESS
))
488 if (!(flags
& SUPPRESS
)) {
498 /* like CCL, but zero-length string OK, & no NOSKIP */
501 if ((flags
& SUPPRESS
) && (flags
& LONG
)) {
502 while ((wi
= __fgetwc_unlock(fp
)) != WEOF
&&
508 } else if (flags
& LONG
) {
509 p0
= p
= va_arg(ap
, wchar_t *);
510 while ((wi
= __fgetwc_unlock(fp
)) != WEOF
&&
521 if (!(flags
& SUPPRESS
))
522 mbp
= va_arg(ap
, char *);
524 while ((wi
= __fgetwc_unlock(fp
)) != WEOF
&&
527 if (width
>= MB_CUR_MAX
&&
528 !(flags
& SUPPRESS
)) {
529 nconv
= wcrtomb(mbp
, wi
, &mbs
);
530 if (nconv
== (size_t)-1)
533 nconv
= wcrtomb(mbbuf
, wi
,
535 if (nconv
== (size_t)-1)
539 if (!(flags
& SUPPRESS
))
543 if (!(flags
& SUPPRESS
))
550 if (!(flags
& SUPPRESS
)) {
559 /* scan an integer as if by the conversion function */
560 if (width
== 0 || width
> sizeof(buf
) /
562 width
= sizeof(buf
) / sizeof(*buf
) - 1;
563 flags
|= SIGNOK
| NDIGITS
| NZDIGITS
;
564 for (p
= buf
; width
; width
--) {
565 c
= __fgetwc_unlock(fp
);
567 * Switch on the character; `goto ok'
568 * if we accept it as a part of number.
573 * The digit 0 is always legal, but is
574 * special. For %i conversions, if no
575 * digits (zero or nonzero) have been
576 * scanned (only signs), we will have
577 * base==0. In that case, we should set
578 * it to 8 and enable 0x prefixing.
579 * Also, if we have not scanned zero digits
580 * before this, do not turn off prefixing
581 * (someone else will turn it off if we
582 * have scanned any nonzero digits).
589 if (flags
& NZDIGITS
)
590 flags
&= ~(SIGNOK
|NZDIGITS
|NDIGITS
);
592 flags
&= ~(SIGNOK
|PFXOK
|NDIGITS
);
595 /* 1 through 7 always legal */
596 case '1': case '2': case '3':
597 case '4': case '5': case '6': case '7':
598 base
= basefix
[base
];
599 flags
&= ~(SIGNOK
| PFXOK
| NDIGITS
);
602 /* digits 8 and 9 ok iff decimal or hex */
604 base
= basefix
[base
];
606 break; /* not legal here */
607 flags
&= ~(SIGNOK
| PFXOK
| NDIGITS
);
610 /* letters ok iff hex */
611 case 'A': case 'B': case 'C':
612 case 'D': case 'E': case 'F':
613 case 'a': case 'b': case 'c':
614 case 'd': case 'e': case 'f':
615 /* no need to fix base here */
617 break; /* not legal here */
618 flags
&= ~(SIGNOK
| PFXOK
| NDIGITS
);
621 /* sign ok only as first character */
623 if (flags
& SIGNOK
) {
631 * x ok iff flag still set & 2nd char (or
632 * 3rd char if we have a sign).
635 if (flags
& PFXOK
&& p
==
636 buf
+ 1 + !!(flags
& HAVESIGN
)) {
637 base
= 16; /* if %i */
645 * If we got here, c is not a legal character
646 * for a number. Stop accumulating digits.
653 * c is legal: store it and look at the next.
658 * If we had only a sign, it is no good; push
659 * back the sign. If the number ends in `x',
660 * it was [sign] '0' 'x', so push back the x
661 * and treat it as [sign] '0'.
663 if (flags
& NDIGITS
) {
669 if (c
== 'x' || c
== 'X') {
673 if ((flags
& SUPPRESS
) == 0) {
677 if ((flags
& UNSIGNED
) == 0)
678 res
= wcstoimax(buf
, NULL
, base
);
680 res
= wcstoumax(buf
, NULL
, base
);
682 if (flags
& POINTER
) {
683 *va_arg(ap
, void **) = (void *)res
;
685 else if (flags
& SHORTSHORT
) {
686 *va_arg(ap
, char *) = (char)res
;
688 else if (flags
& SHORT
) {
689 *va_arg(ap
, short *) = (short)res
;
691 else if (flags
& LONG
) {
692 *va_arg(ap
, long *) = (long)res
;
694 else if (flags
& LONGLONG
) {
695 *va_arg(ap
, INT64
*) = res
; // was quad_t
697 else if (flags
& INTMAXT
) {
698 *va_arg(ap
, intmax_t *) = res
;
700 else if (flags
& PTRDIFFT
) {
701 *va_arg(ap
, ptrdiff_t *) = (ptrdiff_t)res
;
703 else if (flags
& SIZET
) {
704 *va_arg(ap
, size_t *) = (size_t)res
;
707 *va_arg(ap
, int *) = (int)res
;
715 #ifndef NO_FLOATING_POINT
717 /* scan a floating point number as if by strtod */
718 if (width
== 0 || width
> sizeof(buf
) /
720 width
= sizeof(buf
) / sizeof(*buf
) - 1;
721 if ((width
= parsefloat(fp
, buf
, buf
+ width
)) == 0)
723 if ((flags
& SUPPRESS
) == 0) {
724 #ifdef REAL_LONG_DOUBLE_SUPPORT
725 if (flags
& LONGDBL
) {
726 long double res
= wcstold(buf
, &p
);
727 *va_arg(ap
, long double *) = res
;
730 if (flags
& (LONG
| LONGDBL
)) {
731 double res
= wcstod(buf
, &p
);
732 *va_arg(ap
, double *) = res
;
735 float res
= wcstof(buf
, &p
);
736 *va_arg(ap
, float *) = res
;
739 if (p
- buf
!= width
)
747 #endif /* !NO_FLOATING_POINT */
751 return (nconversions
!= 0 ? nassigned
: EOF
);
756 #ifndef NO_FLOATING_POINT
758 parsefloat(FILE *fp
, wchar_t *buf
, wchar_t *end
)
763 S_START
, S_GOTSIGN
, S_INF
, S_NAN
, S_MAYBEHEX
,
764 S_DIGITS
, S_FRAC
, S_EXP
, S_EXPDIGITS
767 wchar_t decpt
= (wchar_t)(unsigned char)*localeconv()->decimal_point
;
768 int gotmantdig
= 0, ishex
= 0;
771 * We set commit = p whenever the string we have read so far
772 * constitutes a valid representation of a floating point
773 * number by itself. At some point, the parse will complete
774 * or fail, and we will ungetc() back to the last commit point.
775 * To ensure that the file offset gets updated properly, it is
776 * always necessary to read at least one character that doesn't
777 * match; thus, we can't short-circuit "infinity" or "nan(...)".
781 for (p
= buf
; p
< end
; ) {
782 if ((wint_t)(c
= __fgetwc_unlock(fp
)) == WEOF
)
788 if (c
== '-' || c
== '+')
813 (c
!= "nfinity"[infnanpos
] &&
814 c
!= "NFINITY"[infnanpos
]))
816 if (infnanpos
== 1 || infnanpos
== 6)
817 commit
= p
; /* inf or infinity */
822 case -1: /* XXX kludge to deal with nan(...) */
825 if (c
!= 'A' && c
!= 'a')
829 if (c
!= 'N' && c
!= 'n')
842 } else if (!iswalnum(c
) && c
!= '_')
850 if (c
== 'X' || c
== 'x') {
853 } else { /* we saw a '0', but no 'x' */
858 if ((ishex
&& iswxdigit(c
)) || iswdigit(c
))
869 if (((c
== 'E' || c
== 'e') && !ishex
) ||
870 ((c
== 'P' || c
== 'p') && ishex
)) {
875 } else if ((ishex
&& iswxdigit(c
)) || iswdigit(c
)) {
883 if (c
== '-' || c
== '+')
901 if ((wint_t)c
!= WEOF
)
906 return (commit
- buf
);