vfscanf.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`
檔案大小: 30.0 KB

行
1	/** @file
2	Implementation of scanf internals for <stdio.h>.
3
4	Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
5	This program and the accompanying materials are licensed and made available
6	under the terms and conditions of the BSD License that accompanies this
7	distribution. 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	- Redistributions of source code must retain the above copyright
23	notice, this list of conditions and the following disclaimer.
24	- 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	- Neither the name of the University nor the names of its contributors
28	may be used to endorse or promote products derived from this software
29	without specific prior written permission.
30
31	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
32	AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
33	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
34	ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
35	LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
36	CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
37	SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
38	INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
39	CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
40	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41	POSSIBILITY OF SUCH DAMAGE.
42
43	NetBSD: vfscanf.c,v 1.37.4.1 2007/05/07 19:49:08 pavel Exp
44	FreeBSD: src/lib/libc/stdio/vfscanf.c,v 1.41 2007/01/09 00:28:07 imp Exp
45	vfscanf.c 8.1 (Berkeley) 6/4/93
46	**/
47	#include <LibConfig.h>
48
49	#include "namespace.h"
50	#include <assert.h>
51	#include <ctype.h>
52	#include <errno.h>
53	#include <inttypes.h>
54	#include <stdio.h>
55	#include <stdlib.h>
56	#include <stddef.h>
57	#include <stdarg.h>
58	#include <string.h>
59	#include <sys/types.h>
60	#include <wchar.h>
61	#include <wctype.h>
62
63	#include "reentrant.h"
64	#include "local.h"
65
66	#ifndef NO_FLOATING_POINT
67	#include <locale.h>
68	#endif
69
70	/*
71	* Provide an external name for vfscanf. Note, EFI uses the normal
72	* namespace.h method; stdio routines explicitly use the internal name
73	* __svfscanf.
74	*/
75	#ifdef __weak_alias
76	__weak_alias(vfscanf,__svfscanf)
77	#endif
78
79	#define BUF 513 /* Maximum length of numeric string. */
80
81	/*
82	* Flags used during conversion.
83	*/
84	#define LONG 0x0001 /* l: long or double */
85	#define LONGDBL 0x0002 /* L: long double */
86	#define SHORT 0x0004 /* h: short */
87	#define SUPPRESS 0x0008 /* : suppress assignment /
88	#define POINTER 0x0010 /* p: void * (as hex) */
89	#define NOSKIP 0x0020 /* [ or c: do not skip blanks */
90	#define LONGLONG 0x0400 /* ll: long long (+ deprecated q: quad) */
91	#define INTMAXT 0x0800 /* 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 0x00040 /* +/- is (still) legal */
102	#define NDIGITS 0x00080 /* no digits detected */
103	#define PFXOK 0x00100 /* 0x prefix is (still) legal */
104	#define NZDIGITS 0x00200 /* 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 const u_char __sccl(char , const u_char *);
117	#ifndef NO_FLOATING_POINT
118	static int parsefloat(FILE , char , char *);
119	#endif
120
121	int __scanfdebug = 0;
122
123	#define __collate_load_error /CONSTCOND/0
124	static int
125	__collate_range_cmp(int c1, int c2)
126	{
127	static char s1[2] = { 0 };
128	static char s2[2] = { 0 };
129
130	s1[0] = (char)c1;
131	s2[0] = (char)c2;
132	return strcoll(s1, s2);
133	}
134
135
136	/*
137	* __svfscanf - MT-safe version
138	*/
139	int
140	__svfscanf(FILE fp, char const fmt0, va_list ap)
141	{
142	int ret;
143
144	if(fp == NULL) {
145	errno = EINVAL;
146	return (EOF);
147	}
148	FLOCKFILE(fp);
149	ret = __svfscanf_unlocked(fp, fmt0, ap);
150	FUNLOCKFILE(fp);
151	return (ret);
152	}
153
154	/*
155	* __svfscanf_unlocked - non-MT-safe version of __svfscanf
156	*/
157	int
158	__svfscanf_unlocked(FILE fp, const char fmt0, va_list ap)
159	{
160	const u_char fmt = (const u_char )fmt0;
161	int c; /* character from format, or conversion */
162	size_t width; /* field width, or 0 */
163	char p; / points into all kinds of strings */
164	size_t n; /* handy size_t */
165	int flags; /* flags as defined above */
166	char p0; / saves original value of p when necessary */
167	int nassigned; /* number of fields assigned */
168	int nconversions; /* number of conversions */
169	int nread; /* number of characters consumed from fp */
170	int base; /* base argument to conversion function */
171	char ccltab[256]; /* character class table for %[...] */
172	char buf[BUF]; /* buffer for numeric and mb conversions */
173	wchar_t wcp; / handy wide character pointer */
174	size_t nconv; /* length of multibyte sequence converted */
175	static const mbstate_t initial = { 0 };
176	mbstate_t mbs;
177
178	/* `basefix' is used to avoid `if' tests in the integer scanner */
179	static const short basefix[17] =
180	{ 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
181
182	_DIAGASSERT(fp != NULL);
183	_DIAGASSERT(fmt0 != NULL);
184	if(fp == NULL) {
185	errno = EINVAL;
186	return (EOF);
187	}
188
189	_SET_ORIENTATION(fp, -1);
190
191	//Print(L"%a( %d, \"%a\", ...)\n", __func__, fp->_file, fmt0);
192	nassigned = 0;
193	nconversions = 0;
194	nread = 0;
195	base = 0;
196	for (;;) {
197	c = (unsigned char)*fmt++;
198	if (c == 0)
199	return (nassigned);
200	if (isspace(c)) {
201	while ((fp->_r > 0 \|\| __srefill(fp) == 0) &&
202	isspace(*fp->_p))
203	nread++, fp->_r--, fp->_p++;
204	continue;
205	}
206	//Print(L"%a: %d\n", __func__, __LINE__);
207	if (c != '%')
208	goto literal;
209	width = 0;
210	flags = 0;
211	/*
212	* switch on the format. continue if done;
213	* break once format type is derived.
214	*/
215	again: c = *fmt++;
216	//Print(L"%a: %d\n", __func__, __LINE__);
217	switch (c) {
218	case '%':
219	literal:
220	//Print(L"%a: %d\n", __func__, __LINE__);
221	if (fp->_r <= 0 && __srefill(fp))
222	goto input_failure;
223	if (*fp->_p != c)
224	goto match_failure;
225	fp->_r--, fp->_p++;
226	nread++;
227	continue;
228
229	case '*':
230	flags \|= SUPPRESS;
231	goto again;
232	case 'j':
233	flags \|= INTMAXT;
234	goto again;
235	case 'l':
236	if (flags & LONG) {
237	flags &= ~LONG;
238	flags \|= LONGLONG;
239	} else
240	flags \|= LONG;
241	goto again;
242	case 'q':
243	flags \|= LONGLONG; /* not quite */
244	goto again;
245	case 't':
246	flags \|= PTRDIFFT;
247	goto again;
248	case 'z':
249	flags \|= SIZET;
250	goto again;
251	case 'L':
252	flags \|= LONGDBL;
253	goto again;
254	case 'h':
255	if (flags & SHORT) {
256	flags &= ~SHORT;
257	flags \|= SHORTSHORT;
258	} else
259	flags \|= SHORT;
260	goto again;
261
262	case '0': case '1': case '2': case '3': case '4':
263	case '5': case '6': case '7': case '8': case '9':
264	width = width * 10 + c - '0';
265	goto again;
266
267	/*
268	* Conversions.
269	*/
270	case 'd':
271	c = CT_INT;
272	base = 10;
273	break;
274
275	case 'i':
276	c = CT_INT;
277	base = 0;
278	break;
279
280	case 'o':
281	c = CT_INT;
282	flags \|= UNSIGNED;
283	base = 8;
284	break;
285
286	case 'u':
287	c = CT_INT;
288	flags \|= UNSIGNED;
289	base = 10;
290	break;
291
292	case 'X':
293	case 'x':
294	flags \|= PFXOK; /* enable 0x prefixing */
295	c = CT_INT;
296	flags \|= UNSIGNED;
297	base = 16;
298	break;
299
300	#ifndef NO_FLOATING_POINT
301	case 'A': case 'E': case 'F': case 'G':
302	case 'a': case 'e': case 'f': case 'g':
303	c = CT_FLOAT;
304	break;
305	#endif
306
307	case 'S':
308	flags \|= LONG;
309	/* FALLTHROUGH */
310	case 's':
311	c = CT_STRING;
312	break;
313
314	case '[':
315	fmt = __sccl(ccltab, fmt);
316	flags \|= NOSKIP;
317	c = CT_CCL;
318	break;
319
320	case 'C':
321	flags \|= LONG;
322	/* FALLTHROUGH */
323	case 'c':
324	flags \|= NOSKIP;
325	c = CT_CHAR;
326	break;
327
328	case 'p': /* pointer format is like hex */
329	flags \|= POINTER \| PFXOK;
330	c = CT_INT; /* assumes sizeof(uintmax_t) */
331	flags \|= UNSIGNED; /* >= sizeof(uintptr_t) */
332	base = 16;
333	break;
334
335	case 'n':
336	nconversions++;
337	if (flags & SUPPRESS) /* ??? */
338	continue;
339	if (flags & SHORTSHORT)
340	va_arg(ap, char ) = (char)nread;
341	else if (flags & SHORT)
342	va_arg(ap, short ) = (short)nread;
343	else if (flags & LONG)
344	va_arg(ap, long ) = nread;
345	else if (flags & LONGLONG)
346	va_arg(ap, long long ) = nread;
347	else if (flags & INTMAXT)
348	va_arg(ap, intmax_t ) = nread;
349	else if (flags & SIZET)
350	va_arg(ap, size_t ) = nread;
351	else if (flags & PTRDIFFT)
352	va_arg(ap, ptrdiff_t ) = nread;
353	else
354	va_arg(ap, int ) = nread;
355	continue;
356
357	default:
358	goto match_failure;
359
360	/*
361	* Disgusting backwards compatibility hack. XXX
362	*/
363	case '\0': /* compat */
364	return (EOF);
365	}
366	//Print(L"%a: %d\n", __func__, __LINE__);
367
368	/*
369	* We have a conversion that requires input.
370	*/
371	if (fp->_r <= 0 && __srefill(fp))
372	{
373	//Print(L"%a: %d\n", __func__, __LINE__);
374	goto input_failure;
375	}
376
377	/*
378	* Consume leading white space, except for formats
379	* that suppress this.
380	*/
381	if ((flags & NOSKIP) == 0) {
382	while (isspace(*fp->_p)) {
383	nread++;
384	if (--fp->_r > 0)
385	fp->_p++;
386	else if (__srefill(fp))
387	{
388	//Print(L"%a: %d\n", __func__, __LINE__);
389	goto input_failure;
390	}
391	}
392	/*
393	* Note that there is at least one character in
394	* the buffer, so conversions that do not set NOSKIP
395	* ca no longer result in an input failure.
396	*/
397	}
398
399	/*
400	* Do the conversion.
401	*/
402	//Print(L"%a: %d\n", __func__, __LINE__);
403	switch (c) {
404
405	case CT_CHAR:
406	/* scan arbitrary characters (sets NOSKIP) */
407	if (width == 0)
408	width = 1;
409	if (flags & LONG) {
410	if ((flags & SUPPRESS) == 0)
411	wcp = va_arg(ap, wchar_t *);
412	else
413	wcp = NULL;
414	n = 0;
415	while (width != 0) {
416	if (n == MB_CUR_MAX) {
417	fp->_flags \|= __SERR;
418	goto input_failure;
419	}
420	buf[n++] = *fp->_p;
421	fp->_p++;
422	fp->_r--;
423	mbs = initial;
424	nconv = mbrtowc(wcp, buf, n, &mbs);
425	if (nconv == (size_t)-1) {
426	fp->_flags \|= __SERR;
427	goto input_failure;
428	}
429	if (nconv == 0 && !(flags & SUPPRESS))
430	*wcp = L'\0';
431	if (nconv != (size_t)-2) {
432	nread += (int)n;
433	width--;
434	if (!(flags & SUPPRESS))
435	wcp++;
436	n = 0;
437	}
438	if (fp->_r <= 0 && __srefill(fp)) {
439	if (n != 0) {
440	fp->_flags \|= __SERR;
441	goto input_failure;
442	}
443	break;
444	}
445	}
446	if (!(flags & SUPPRESS))
447	nassigned++;
448	} else if (flags & SUPPRESS) {
449	size_t sum = 0;
450	for (;;) {
451	if ((n = fp->_r) < width) {
452	sum += n;
453	width -= n;
454	fp->_p += n;
455	if (__srefill(fp)) {
456	if (sum == 0)
457	goto input_failure;
458	break;
459	}
460	} else {
461	sum += width;
462	fp->_r -= (int)width;
463	fp->_p += width;
464	break;
465	}
466	}
467	nread += (int)sum;
468	} else {
469	size_t r = fread(va_arg(ap, char *), 1,
470	width, fp);
471
472	if (r == 0)
473	goto input_failure;
474	nread += (int)r;
475	nassigned++;
476	}
477	nconversions++;
478	break;
479
480	case CT_CCL:
481	/* scan a (nonempty) character class (sets NOSKIP) */
482	if (width == 0)
483	width = (size_t)~0; /* `infinity' */
484	/* take only those things in the class */
485	if (flags & LONG) {
486	wchar_t twc;
487	int nchars;
488
489	if ((flags & SUPPRESS) == 0)
490	wcp = va_arg(ap, wchar_t *);
491	else
492	wcp = &twc;
493	n = 0;
494	nchars = 0;
495	while (width != 0) {
496	if (n == MB_CUR_MAX) {
497	fp->_flags \|= __SERR;
498	goto input_failure;
499	}
500	buf[n++] = *fp->_p;
501	fp->_p++;
502	fp->_r--;
503	mbs = initial;
504	nconv = mbrtowc(wcp, buf, n, &mbs);
505	if (nconv == (size_t)-1) {
506	fp->_flags \|= __SERR;
507	goto input_failure;
508	}
509	if (nconv == 0)
510	*wcp = L'\0';
511	if (nconv != (size_t)-2) {
512	if (wctob(*wcp) != EOF &&
513	!ccltab[wctob(*wcp)]) {
514	while (n != 0) {
515	n--;
516	(void)ungetc(buf[n],
517	fp);
518	}
519	break;
520	}
521	nread += (int)n;
522	width--;
523	if (!(flags & SUPPRESS))
524	wcp++;
525	nchars++;
526	n = 0;
527	}
528	if (fp->_r <= 0 && __srefill(fp)) {
529	if (n != 0) {
530	fp->_flags \|= __SERR;
531	goto input_failure;
532	}
533	break;
534	}
535	}
536	if (n != 0) {
537	fp->_flags \|= __SERR;
538	goto input_failure;
539	}
540	n = nchars;
541	if (n == 0)
542	goto match_failure;
543	if (!(flags & SUPPRESS)) {
544	*wcp = L'\0';
545	nassigned++;
546	}
547	} else if (flags & SUPPRESS) {
548	n = 0;
549	while (ccltab[*fp->_p]) {
550	n++, fp->_r--, fp->_p++;
551	if (--width == 0)
552	break;
553	if (fp->_r <= 0 && __srefill(fp)) {
554	if (n == 0)
555	goto input_failure;
556	break;
557	}
558	}
559	if (n == 0)
560	goto match_failure;
561	} else {
562	p0 = p = va_arg(ap, char *);
563	while (ccltab[*fp->_p]) {
564	fp->_r--;
565	p++ = fp->_p++;
566	if (--width == 0)
567	break;
568	if (fp->_r <= 0 && __srefill(fp)) {
569	if (p == p0)
570	goto input_failure;
571	break;
572	}
573	}
574	n = p - p0;
575	if (n == 0)
576	goto match_failure;
577	*p = 0;
578	nassigned++;
579	}
580	nread += (int)n;
581	nconversions++;
582	break;
583
584	case CT_STRING:
585	/* like CCL, but zero-length string OK, & no NOSKIP */
586	if (width == 0)
587	width = (size_t)~0;
588	if (flags & LONG) {
589	wchar_t twc;
590
591	if ((flags & SUPPRESS) == 0)
592	wcp = va_arg(ap, wchar_t *);
593	else
594	wcp = &twc;
595	n = 0;
596	while (!isspace(*fp->_p) && width != 0) {
597	if (n == MB_CUR_MAX) {
598	fp->_flags \|= __SERR;
599	goto input_failure;
600	}
601	buf[n++] = *fp->_p;
602	fp->_p++;
603	fp->_r--;
604	mbs = initial;
605	nconv = mbrtowc(wcp, buf, n, &mbs);
606	if (nconv == (size_t)-1) {
607	fp->_flags \|= __SERR;
608	goto input_failure;
609	}
610	if (nconv == 0)
611	*wcp = L'\0';
612	if (nconv != (size_t)-2) {
613	if (iswspace(*wcp)) {
614	while (n != 0) {
615	n--;
616	(void)ungetc(buf[n],
617	fp);
618	}
619	break;
620	}
621	nread += (int)n;
622	width--;
623	if (!(flags & SUPPRESS))
624	wcp++;
625	n = 0;
626	}
627	if (fp->_r <= 0 && __srefill(fp)) {
628	if (n != 0) {
629	fp->_flags \|= __SERR;
630	goto input_failure;
631	}
632	break;
633	}
634	}
635	if (!(flags & SUPPRESS)) {
636	*wcp = L'\0';
637	nassigned++;
638	}
639	} else if (flags & SUPPRESS) {
640	n = 0;
641	while (!isspace(*fp->_p)) {
642	n++, fp->_r--, fp->_p++;
643	if (--width == 0)
644	break;
645	if (fp->_r <= 0 && __srefill(fp))
646	break;
647	}
648	nread += (int)n;
649	} else {
650	p0 = p = va_arg(ap, char *);
651	while (!isspace(*fp->_p)) {
652	fp->_r--;
653	p++ = fp->_p++;
654	if (--width == 0)
655	break;
656	if (fp->_r <= 0 && __srefill(fp))
657	break;
658	}
659	*p = 0;
660	nread += (int)(p - p0);
661	nassigned++;
662	}
663	nconversions++;
664	continue;
665
666	case CT_INT:
667	//Print(L"%a: %d\n", __func__, __LINE__);
668	/* scan an integer as if by the conversion function */
669	#ifdef hardway
670	if (width == 0 \|\| width > sizeof(buf) - 1)
671	width = sizeof(buf) - 1;
672	#else
673	/* size_t is unsigned, hence this optimisation */
674	if (--width > sizeof(buf) - 2)
675	width = sizeof(buf) - 2;
676	width++;
677	#endif
678	flags \|= SIGNOK \| NDIGITS \| NZDIGITS;
679	for (p = buf; width; width--) {
680	c = *fp->_p;
681	/*
682	* Switch on the character; `goto ok'
683	* if we accept it as a part of number.
684	*/
685	switch (c) {
686
687	/*
688	* The digit 0 is always legal, but is
689	* special. For %i conversions, if no
690	* digits (zero or nonzero) have been
691	* scanned (only signs), we will have
692	* base==0. In that case, we should set
693	* it to 8 and enable 0x prefixing.
694	* Also, if we have not scanned zero digits
695	* before this, do not turn off prefixing
696	* (someone else will turn it off if we
697	* have scanned any nonzero digits).
698	*/
699	case '0':
700	if (base == 0) {
701	base = 8;
702	flags \|= PFXOK;
703	}
704	if (flags & NZDIGITS)
705	flags &= ~(SIGNOK\|NZDIGITS\|NDIGITS);
706	else
707	flags &= ~(SIGNOK\|PFXOK\|NDIGITS);
708	goto ok;
709
710	/* 1 through 7 always legal */
711	case '1': case '2': case '3':
712	case '4': case '5': case '6': case '7':
713	base = basefix[base];
714	flags &= ~(SIGNOK \| PFXOK \| NDIGITS);
715	goto ok;
716
717	/* digits 8 and 9 ok iff decimal or hex */
718	case '8': case '9':
719	base = basefix[base];
720	if (base <= 8)
721	break; /* not legal here */
722	flags &= ~(SIGNOK \| PFXOK \| NDIGITS);
723	goto ok;
724
725	/* letters ok iff hex */
726	case 'A': case 'B': case 'C':
727	case 'D': case 'E': case 'F':
728	case 'a': case 'b': case 'c':
729	case 'd': case 'e': case 'f':
730	/* no need to fix base here */
731	if (base <= 10)
732	break; /* not legal here */
733	flags &= ~(SIGNOK \| PFXOK \| NDIGITS);
734	goto ok;
735
736	/* sign ok only as first character */
737	case '+': case '-':
738	if (flags & SIGNOK) {
739	flags &= ~SIGNOK;
740	flags \|= HAVESIGN;
741	goto ok;
742	}
743	break;
744
745	/*
746	* x ok iff flag still set & 2nd char (or
747	* 3rd char if we have a sign).
748	*/
749	case 'x': case 'X':
750	if (flags & PFXOK && p ==
751	buf + 1 + !!(flags & HAVESIGN)) {
752	base = 16; /* if %i */
753	flags &= ~PFXOK;
754	goto ok;
755	}
756	break;
757	}
758
759	/*
760	* If we got here, c is not a legal character
761	* for a number. Stop accumulating digits.
762	*/
763	break;
764	ok:
765	/*
766	* c is legal: store it and look at the next.
767	*/
768	*p++ = (char)c;
769	if (--fp->_r > 0)
770	fp->_p++;
771	else if (__srefill(fp))
772	break; /* EOF */
773	}
774	/*
775	* If we had only a sign, it is no good; push
776	* back the sign. If the number ends in `x',
777	* it was [sign] '0' 'x', so push back the x
778	* and treat it as [sign] '0'.
779	*/
780	if (flags & NDIGITS) {
781	if (p > buf)
782	(void)ungetc((u_char )--p, fp);
783	goto match_failure;
784	}
785	c = ((u_char *)p)[-1];
786	if (c == 'x' \|\| c == 'X') {
787	--p;
788	(void)ungetc(c, fp);
789	}
790	if ((flags & SUPPRESS) == 0) {
791	//uintmax_t res;
792	// Use a union to get around the truncation warnings.
793	union {
794	uintmax_t umax;
795	intmax_t imax;
796	void *vp;
797	ptrdiff_t pdt;
798	size_t sz;
799	long long ll;
800	long lo;
801	int in;
802	short hw;
803	char ch;
804	} res;
805
806	*p = 0;
807	if ((flags & UNSIGNED) == 0)
808	res.imax = strtoimax(buf, (char **)NULL, base);
809	else
810	res.umax = strtoumax(buf, (char **)NULL, base);
811	if (flags & POINTER)
812	va_arg(ap, void *) = res.vp;
813	//(void *)((uintptr_t)res);
814	else if (flags & SHORTSHORT)
815	va_arg(ap, char ) = res.ch;
816	else if (flags & SHORT)
817	va_arg(ap, short ) = res.hw;
818	else if (flags & LONG)
819	va_arg(ap, long ) = res.lo;
820	else if (flags & LONGLONG)
821	va_arg(ap, long long ) = res.ll;
822	else if (flags & INTMAXT)
823	va_arg(ap, intmax_t ) = res.imax;
824	else if (flags & PTRDIFFT)
825	va_arg(ap, ptrdiff_t ) = res.pdt;
826	//(ptrdiff_t)res;
827	else if (flags & SIZET)
828	va_arg(ap, size_t ) = res.sz;
829	else
830	va_arg(ap, int ) = res.in;
831	nassigned++;
832	}
833	nread += (int)(p - buf);
834	nconversions++;
835	//Print(L"%a: %d\n", __func__, __LINE__);
836	break;
837
838	#ifndef NO_FLOATING_POINT
839	case CT_FLOAT:
840	/* scan a floating point number as if by strtod */
841	if (width == 0 \|\| width > sizeof(buf) - 1)
842	width = sizeof(buf) - 1;
843	if ((width = parsefloat(fp, buf, buf + width)) == 0)
844	goto match_failure;
845	if ((flags & SUPPRESS) == 0) {
846	if (flags & LONGDBL) {
847	long double res = strtold(buf, &p);
848	va_arg(ap, long double ) = res;
849	} else if (flags & LONG) {
850	double res = strtod(buf, &p);
851	va_arg(ap, double ) = res;
852	} else {
853	float res = strtof(buf, &p);
854	va_arg(ap, float ) = res;
855	}
856	if (__scanfdebug && p - buf != (ptrdiff_t)width)
857	abort();
858	nassigned++;
859	}
860	nread += (int)width;
861	nconversions++;
862	break;
863	#endif /* !NO_FLOATING_POINT */
864	}
865	}
866	input_failure:
867	//Print(L"%a: %d\n", __func__, __LINE__);
868	return (nconversions != 0 ? nassigned : EOF);
869	match_failure:
870	return (nassigned);
871	}
872
873	/*
874	* Fill in the given table from the scanset at the given format
875	* (just after `['). Return a pointer to the character past the
876	* closing `]'. The table has a 1 wherever characters should be
877	* considered part of the scanset.
878	*/
879	static const u_char *
880	__sccl(char tab, const u_char fmt)
881	{
882	int c, n, v, i;
883
884	_DIAGASSERT(tab != NULL);
885	_DIAGASSERT(fmt != NULL);
886	/* first `clear' the whole table */
887	c = fmt++; / first char hat => negated scanset */
888	if (c == '^') {
889	v = 1; /* default => accept */
890	c = fmt++; / get new first char */
891	} else
892	v = 0; /* default => reject */
893
894	/* XXX: Will not work if sizeof(tab) > sizeof(char) /
895	(void)memset(tab, v, 256);
896
897	if (c == 0)
898	return (fmt - 1);/* format ended before closing ] */
899
900	/*
901	* Now set the entries corresponding to the actual scanset
902	* to the opposite of the above.
903	*
904	* The first character may be ']' (or '-') without being special;
905	* the last character may be '-'.
906	*/
907	v = 1 - v;
908	for (;;) {
909	tab[c] = (char)v; /* take character c */
910	doswitch:
911	n = fmt++; / and examine the next */
912	switch (n) {
913
914	case 0: /* format ended too soon */
915	return (fmt - 1);
916
917	case '-':
918	/*
919	* A scanset of the form
920	* [01+-]
921	* is defined as `the digit 0, the digit 1,
922	* the character +, the character -', but
923	* the effect of a scanset such as
924	* [a-zA-Z0-9]
925	* is implementation defined. The V7 Unix
926	* scanf treats `a-z' as `the letters a through
927	* z', but treats `a-a' as `the letter a, the
928	* character -, and the letter a'.
929	*
930	* For compatibility, the `-' is not considerd
931	* to define a range if the character following
932	* it is either a close bracket (required by ANSI)
933	* or is not numerically greater than the character
934	* we just stored in the table (c).
935	*/
936	n = *fmt;
937	if (n == ']' \|\| (__collate_load_error ? n < c :
938	__collate_range_cmp(n, c) < 0)) {
939	c = '-';
940	break; /* resume the for(;;) */
941	}
942	fmt++;
943	/* fill in the range */
944	if (__collate_load_error) {
945	do
946	tab[++c] = (char)v;
947	while (c < n);
948	} else {
949	for (i = 0; i < 256; i ++)
950	if (__collate_range_cmp(c, i) < 0 &&
951	__collate_range_cmp(i, n) <= 0)
952	tab[i] = (char)v;
953	}
954	#if 1 /* XXX another disgusting compatibility hack */
955	c = n;
956	/*
957	* Alas, the V7 Unix scanf also treats formats
958	* such as [a-c-e] as `the letters a through e'.
959	* This too is permitted by the standard....
960	*/
961	goto doswitch;
962	#else
963	c = *fmt++;
964	if (c == 0)
965	return (fmt - 1);
966	if (c == ']')
967	return (fmt);
968	#endif
969
970	case ']': /* end of scanset */
971	return (fmt);
972
973	default: /* just another character */
974	c = n;
975	break;
976	}
977	}
978	/* NOTREACHED */
979	}
980
981	#ifndef NO_FLOATING_POINT
982	static int
983	parsefloat(FILE fp, char buf, char *end)
984	{
985	char commit, p;
986	int infnanpos = 0;
987	enum {
988	S_START, S_GOTSIGN, S_INF, S_NAN, S_MAYBEHEX,
989	S_DIGITS, S_FRAC, S_EXP, S_EXPDIGITS
990	} state = S_START;
991	unsigned char c;
992	char decpt = *localeconv()->decimal_point;
993	_Bool gotmantdig = 0, ishex = 0;
994
995	if(fp == NULL) {
996	errno = EINVAL;
997	return (EOF);
998	}
999
1000	/*
1001	* We set commit = p whenever the string we have read so far
1002	* constitutes a valid representation of a floating point
1003	* number by itself. At some point, the parse will complete
1004	* or fail, and we will ungetc() back to the last commit point.
1005	* To ensure that the file offset gets updated properly, it is
1006	* always necessary to read at least one character that doesn't
1007	* match; thus, we can't short-circuit "infinity" or "nan(...)".
1008	*/
1009	commit = buf - 1;
1010	for (p = buf; p < end; ) {
1011	c = *fp->_p;
1012	reswitch:
1013	switch (state) {
1014	case S_START:
1015	state = S_GOTSIGN;
1016	if (c == '-' \|\| c == '+')
1017	break;
1018	else
1019	goto reswitch;
1020	case S_GOTSIGN:
1021	switch (c) {
1022	case '0':
1023	state = S_MAYBEHEX;
1024	commit = p;
1025	break;
1026	case 'I':
1027	case 'i':
1028	state = S_INF;
1029	break;
1030	case 'N':
1031	case 'n':
1032	state = S_NAN;
1033	break;
1034	default:
1035	state = S_DIGITS;
1036	goto reswitch;
1037	}
1038	break;
1039	case S_INF:
1040	if (infnanpos > 6 \|\|
1041	(c != "nfinity"[infnanpos] &&
1042	c != "NFINITY"[infnanpos]))
1043	goto parsedone;
1044	if (infnanpos == 1 \|\| infnanpos == 6)
1045	commit = p; /* inf or infinity */
1046	infnanpos++;
1047	break;
1048	case S_NAN:
1049	switch (infnanpos) {
1050	case -1: /* XXX kludge to deal with nan(...) */
1051	goto parsedone;
1052	case 0:
1053	if (c != 'A' && c != 'a')
1054	goto parsedone;
1055	break;
1056	case 1:
1057	if (c != 'N' && c != 'n')
1058	goto parsedone;
1059	else
1060	commit = p;
1061	break;
1062	case 2:
1063	if (c != '(')
1064	goto parsedone;
1065	break;
1066	default:
1067	if (c == ')') {
1068	commit = p;
1069	infnanpos = -2;
1070	} else if (!isalnum(c) && c != '_')
1071	goto parsedone;
1072	break;
1073	}
1074	infnanpos++;
1075	break;
1076	case S_MAYBEHEX:
1077	state = S_DIGITS;
1078	if (c == 'X' \|\| c == 'x') {
1079	ishex = 1;
1080	break;
1081	} else { /* we saw a '0', but no 'x' */
1082	gotmantdig = 1;
1083	goto reswitch;
1084	}
1085	case S_DIGITS:
1086	if ((ishex && isxdigit(c)) \|\| isdigit(c))
1087	gotmantdig = 1;
1088	else {
1089	state = S_FRAC;
1090	if (c != decpt)
1091	goto reswitch;
1092	}
1093	if (gotmantdig)
1094	commit = p;
1095	break;
1096	case S_FRAC:
1097	if (((c == 'E' \|\| c == 'e') && !ishex) \|\|
1098	((c == 'P' \|\| c == 'p') && ishex)) {
1099	if (!gotmantdig)
1100	goto parsedone;
1101	else
1102	state = S_EXP;
1103	} else if ((ishex && isxdigit(c)) \|\| isdigit(c)) {
1104	commit = p;
1105	gotmantdig = 1;
1106	} else
1107	goto parsedone;
1108	break;
1109	case S_EXP:
1110	state = S_EXPDIGITS;
1111	if (c == '-' \|\| c == '+')
1112	break;
1113	else
1114	goto reswitch;
1115	case S_EXPDIGITS:
1116	if (isdigit(c))
1117	commit = p;
1118	else
1119	goto parsedone;
1120	break;
1121	default:
1122	abort();
1123	}
1124	*p++ = c;
1125	if (--fp->_r > 0)
1126	fp->_p++;
1127	else if (__srefill(fp))
1128	break; /* EOF */
1129	}
1130
1131	parsedone:
1132	while (commit < --p)
1133	(void)ungetc((u_char )p, fp);
1134	*++commit = '\0';
1135	return (int)(commit - buf);
1136	}
1137	#endif

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

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

以其他格式下載: