vfwscanf.c@ 77599

最後變更在這個檔案從77599是 58459,由 vboxsync 提交於 9 年前
EFI/Firmware: 'svn merge ^{/vendor/edk2/UDK2010.SR1}/vendor/edk2/current .', reverting and removing files+dirs listed in ReadMe.vbox, resolving conflicts with help from ../UDK2014.SP1/. This is a raw untested merge.
屬性 svn:eol-style 設為 `native`
檔案大小: 25.1 KB

行
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

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/StdLib/LibC/Stdio/vfwscanf.c@ 77599

以其他格式下載: