WebSVN - shark - Blame - Rev 2 - /shark/branches/pj/libc/stdio/vfscanf.c

Rev	Author	Line No.	Line
2	pj	1	/*-
		2	* Copyright (c) 1990, 1993
		3	* The Regents of the University of California. All rights reserved.
		4	*
		5	* This code is derived from software contributed to Berkeley by
		6	* Chris Torek.
		7	*
		8	* Redistribution and use in source and binary forms, with or without
		9	* modification, are permitted provided that the following conditions
		10	* are met:
		11	* 1. Redistributions of source code must retain the above copyright
		12	* notice, this list of conditions and the following disclaimer.
		13	* 2. Redistributions in binary form must reproduce the above copyright
		14	* notice, this list of conditions and the following disclaimer in the
		15	* documentation and/or other materials provided with the distribution.
		16	* 3. All advertising materials mentioning features or use of this software
		17	* must display the following acknowledgement:
		18	* This product includes software developed by the University of
		19	* California, Berkeley and its contributors.
		20	* 4. Neither the name of the University nor the names of its contributors
		21	* may be used to endorse or promote products derived from this software
		22	* without specific prior written permission.
		23	*
		24	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
		25	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
		27	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
		28	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
		29	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
		30	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
		31	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
		32	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
		33	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
		34	* SUCH DAMAGE.
		35	*/
		36
		37	#if defined(LIBC_SCCS) && !defined(lint)
		38	#if 0
		39	static char sccsid[] = "@(#)vfscanf.c 8.1 (Berkeley) 6/4/93";
		40	#endif
		41	static const char rcsid[] =
		42	"$\Id: vfscanf.c,v 1.3.2.2 1997/03/07 09:12:11 joerg Exp $";
		43	#endif /* LIBC_SCCS and not lint */
		44
		45	#include <stdio.h>
		46	#include <stdlib.h>
		47	#include <ctype.h>
		48	#if __STDC__
		49	#include <stdarg.h>
		50	#else
		51	#include <varargs.h>
		52	#endif
		53	#include <string.h>
		54
		55	#include "collate.h"
		56	#include "local.h"
		57
		58	#define FLOATING_POINT
		59
		60	#include "floatio.h"
		61	#define BUF 513 /* Maximum length of numeric string. */
		62
		63	/*
		64	* Flags used during conversion.
		65	*/
		66	#define LONG 0x01 /* l: long or double */
		67	#define LONGDBL 0x02 /* L: long double; unimplemented */
		68	#define SHORT 0x04 /* h: short */
		69	#define SUPPRESS 0x08 /* suppress assignment */
		70	#define POINTER 0x10 /* weird %p pointer (`fake hex') */
		71	#define NOSKIP 0x20 /* do not skip blanks */
		72
		73	/*
		74	* The following are used in numeric conversions only:
		75	* SIGNOK, NDIGITS, DPTOK, and EXPOK are for floating point;
		76	* SIGNOK, NDIGITS, PFXOK, and NZDIGITS are for integral.
		77	*/
		78	#define SIGNOK 0x40 /* +/- is (still) legal */
		79	#define NDIGITS 0x80 /* no digits detected */
		80
		81	#define DPTOK 0x100 /* (float) decimal point is still legal */
		82	#define EXPOK 0x200 /* (float) exponent (e+3, etc) still legal */
		83
		84	#define PFXOK 0x100 /* 0x prefix is (still) legal */
		85	#define NZDIGITS 0x200 /* no zero digits detected */
		86
		87	/*
		88	* Conversion types.
		89	*/
		90	#define CT_CHAR 0 /* %c conversion */
		91	#define CT_CCL 1 /* %[...] conversion */
		92	#define CT_STRING 2 /* %s conversion */
		93	#define CT_INT 3 /* integer, i.e., strtol or strtoul */
		94	#define CT_FLOAT 4 /* floating, i.e., strtod */
		95
		96	//#define u_char unsigned char
		97	//#define u_long unsigned long
		98
		99	static u_char __sccl(char , u_char *);
		100
		101	/*
		102	* vfscanf
		103	*/
		104	int
		105	__svfscanf(fp, fmt0, ap)
		106	register FILE *fp;
		107	char const *fmt0;
		108	va_list ap;
		109	{
		110	register u_char fmt = (u_char )fmt0;
		111	register int c; /* character from format, or conversion */
		112	register size_t width; /* field width, or 0 */
		113	register char p; / points into all kinds of strings */
		114	register int n; /* handy integer */
		115	register int flags; /* flags as defined above */
		116	register char p0; / saves original value of p when necessary */
		117	int nassigned; /* number of fields assigned */
		118	int nconversions; /* number of conversions */
		119	int nread; /* number of characters consumed from fp */
		120	int base; /* base argument to strtol/strtoul */
		121	u_long (ccfn)(); / conversion function (strtol/strtoul) */
		122	char ccltab[256]; /* character class table for %[...] */
		123	char buf[BUF]; /* buffer for numeric conversions */
		124
		125	/* `basefix' is used to avoid `if' tests in the integer scanner */
		126	static short basefix[17] =
		127	{ 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
		128
		129	nassigned = 0;
		130	nconversions = 0;
		131	nread = 0;
		132	base = 0; /* XXX just to keep gcc happy */
		133	ccfn = NULL; /* XXX just to keep gcc happy */
		134	for (;;) {
		135	c = *fmt++;
		136	if (c == 0)
		137	return (nassigned);
		138	if (isspace(c)) {
		139	for (;;) {
		140	if (fp->_r <= 0 && __srefill(fp))
		141	goto input_failure;
		142	if (!isspace(*fp->_p))
		143	break;
		144	nread++, fp->_r--, fp->_p++;
		145	}
		146	continue;
		147	}
		148	if (c != '%')
		149	goto literal;
		150	width = 0;
		151	flags = 0;
		152	/*
		153	* switch on the format. continue if done;
		154	* break once format type is derived.
		155	*/
		156	again: c = *fmt++;
		157	switch (c) {
		158	case '%':
		159	literal:
		160	if (fp->_r <= 0 && __srefill(fp))
		161	goto input_failure;
		162	if (*fp->_p != c)
		163	goto match_failure;
		164	fp->_r--, fp->_p++;
		165	nread++;
		166	continue;
		167
		168	case '*':
		169	flags \|= SUPPRESS;
		170	goto again;
		171	case 'l':
		172	flags \|= LONG;
		173	goto again;
		174	case 'L':
		175	flags \|= LONGDBL;
		176	goto again;
		177	case 'h':
		178	flags \|= SHORT;
		179	goto again;
		180
		181	case '0': case '1': case '2': case '3': case '4':
		182	case '5': case '6': case '7': case '8': case '9':
		183	width = width * 10 + c - '0';
		184	goto again;
		185
		186	/*
		187	* Conversions.
		188	* Those marked `compat' are for 4.[123]BSD compatibility.
		189	*
		190	* (According to ANSI, E and X formats are supposed
		191	* to the same as e and x. Sorry about that.)
		192	*/
		193	case 'D': /* compat */
		194	flags \|= LONG;
		195	/* FALLTHROUGH */
		196	case 'd':
		197	c = CT_INT;
		198	ccfn = (u_long (*)())strtol;
		199	base = 10;
		200	break;
		201
		202	case 'i':
		203	c = CT_INT;
		204	ccfn = (u_long (*)())strtol;
		205	base = 0;
		206	break;
		207
		208	case 'O': /* compat */
		209	flags \|= LONG;
		210	/* FALLTHROUGH */
		211	case 'o':
		212	c = CT_INT;
		213	ccfn = strtoul;
		214	base = 8;
		215	break;
		216
		217	case 'u':
		218	c = CT_INT;
		219	ccfn = strtoul;
		220	base = 10;
		221	break;
		222
		223	case 'X': /* compat XXX */
		224	flags \|= LONG;
		225	/* FALLTHROUGH */
		226	case 'x':
		227	flags \|= PFXOK; /* enable 0x prefixing */
		228	c = CT_INT;
		229	ccfn = strtoul;
		230	base = 16;
		231	break;
		232
		233	#ifdef FLOATING_POINT
		234	case 'E': /* compat XXX */
		235	case 'F': /* compat */
		236	flags \|= LONG;
		237	/* FALLTHROUGH */
		238	case 'e': case 'f': case 'g':
		239	c = CT_FLOAT;
		240	break;
		241	#endif
		242
		243	case 's':
		244	c = CT_STRING;
		245	break;
		246
		247	case '[':
		248	fmt = __sccl(ccltab, fmt);
		249	flags \|= NOSKIP;
		250	c = CT_CCL;
		251	break;
		252
		253	case 'c':
		254	flags \|= NOSKIP;
		255	c = CT_CHAR;
		256	break;
		257
		258	case 'p': /* pointer format is like hex */
		259	flags \|= POINTER \| PFXOK;
		260	c = CT_INT;
		261	ccfn = strtoul;
		262	base = 16;
		263	break;
		264
		265	case 'n':
		266	nconversions++;
		267	if (flags & SUPPRESS) /* ??? */
		268	continue;
		269	if (flags & SHORT)
		270	va_arg(ap, short ) = nread;
		271	else if (flags & LONG)
		272	va_arg(ap, long ) = nread;
		273	else
		274	va_arg(ap, int ) = nread;
		275	continue;
		276
		277	/*
		278	* Disgusting backwards compatibility hacks. XXX
		279	*/
		280	case '\0': /* compat */
		281	return (EOF);
		282
		283	default: /* compat */
		284	if (isupper(c))
		285	flags \|= LONG;
		286	c = CT_INT;
		287	ccfn = (u_long (*)())strtol;
		288	base = 10;
		289	break;
		290	}
		291
		292	/*
		293	* We have a conversion that requires input.
		294	*/
		295	if (fp->_r <= 0 && __srefill(fp))
		296	goto input_failure;
		297
		298	/*
		299	* Consume leading white space, except for formats
		300	* that suppress this.
		301	*/
		302	if ((flags & NOSKIP) == 0) {
		303	while (isspace(*fp->_p)) {
		304	nread++;
		305	if (--fp->_r > 0)
		306	fp->_p++;
		307	else if (__srefill(fp))
		308	goto input_failure;
		309	}
		310	/*
		311	* Note that there is at least one character in
		312	* the buffer, so conversions that do not set NOSKIP
		313	* ca no longer result in an input failure.
		314	*/
		315	}
		316
		317	/*
		318	* Do the conversion.
		319	*/
		320	switch (c) {
		321
		322	case CT_CHAR:
		323	/* scan arbitrary characters (sets NOSKIP) */
		324	if (width == 0)
		325	width = 1;
		326	if (flags & SUPPRESS) {
		327	size_t sum = 0;
		328	for (;;) {
		329	if ((n = fp->_r) < width) {
		330	sum += n;
		331	width -= n;
		332	fp->_p += n;
		333	if (__srefill(fp)) {
		334	if (sum == 0)
		335	goto input_failure;
		336	break;
		337	}
		338	} else {
		339	sum += width;
		340	fp->_r -= width;
		341	fp->_p += width;
		342	break;
		343	}
		344	}
		345	nread += sum;
		346	} else {
		347	size_t r = fread((void )va_arg(ap, char ), 1,
		348	width, fp);
		349
		350	if (r == 0)
		351	goto input_failure;
		352	nread += r;
		353	nassigned++;
		354	}
		355	nconversions++;
		356	break;
		357
		358	case CT_CCL:
		359	/* scan a (nonempty) character class (sets NOSKIP) */
		360	if (width == 0)
		361	width = (size_t)~0; /* `infinity' */
		362	/* take only those things in the class */
		363	if (flags & SUPPRESS) {
		364	n = 0;
		365	while (ccltab[*fp->_p]) {
		366	n++, fp->_r--, fp->_p++;
		367	if (--width == 0)
		368	break;
		369	if (fp->_r <= 0 && __srefill(fp)) {
		370	if (n == 0)
		371	goto input_failure;
		372	break;
		373	}
		374	}
		375	if (n == 0)
		376	goto match_failure;
		377	} else {
		378	p0 = p = va_arg(ap, char *);
		379	while (ccltab[*fp->_p]) {
		380	fp->_r--;
		381	p++ = fp->_p++;
		382	if (--width == 0)
		383	break;
		384	if (fp->_r <= 0 && __srefill(fp)) {
		385	if (p == p0)
		386	goto input_failure;
		387	break;
		388	}
		389	}
		390	n = p - p0;
		391	if (n == 0)
		392	goto match_failure;
		393	*p = 0;
		394	nassigned++;
		395	}
		396	nread += n;
		397	nconversions++;
		398	break;
		399
		400	case CT_STRING:
		401	/* like CCL, but zero-length string OK, & no NOSKIP */
		402	if (width == 0)
		403	width = (size_t)~0;
		404	if (flags & SUPPRESS) {
		405	n = 0;
		406	while (!isspace(*fp->_p)) {
		407	n++, fp->_r--, fp->_p++;
		408	if (--width == 0)
		409	break;
		410	if (fp->_r <= 0 && __srefill(fp))
		411	break;
		412	}
		413	nread += n;
		414	} else {
		415	p0 = p = va_arg(ap, char *);
		416	while (!isspace(*fp->_p)) {
		417	fp->_r--;
		418	p++ = fp->_p++;
		419	if (--width == 0)
		420	break;
		421	if (fp->_r <= 0 && __srefill(fp))
		422	break;
		423	}
		424	*p = 0;
		425	nread += p - p0;
		426	nassigned++;
		427	}
		428	nconversions++;
		429	continue;
		430
		431	case CT_INT:
		432	/* scan an integer as if by strtol/strtoul */
		433	#ifdef hardway
		434	if (width == 0 \|\| width > sizeof(buf) - 1)
		435	width = sizeof(buf) - 1;
		436	#else
		437	/* size_t is unsigned, hence this optimisation */
		438	if (--width > sizeof(buf) - 2)
		439	width = sizeof(buf) - 2;
		440	width++;
		441	#endif
		442	flags \|= SIGNOK \| NDIGITS \| NZDIGITS;
		443	for (p = buf; width; width--) {
		444	c = *fp->_p;
		445	/*
		446	* Switch on the character; `goto ok'
		447	* if we accept it as a part of number.
		448	*/
		449	switch (c) {
		450
		451	/*
		452	* The digit 0 is always legal, but is
		453	* special. For %i conversions, if no
		454	* digits (zero or nonzero) have been
		455	* scanned (only signs), we will have
		456	* base==0. In that case, we should set
		457	* it to 8 and enable 0x prefixing.
		458	* Also, if we have not scanned zero digits
		459	* before this, do not turn off prefixing
		460	* (someone else will turn it off if we
		461	* have scanned any nonzero digits).
		462	*/
		463	case '0':
		464	if (base == 0) {
		465	base = 8;
		466	flags \|= PFXOK;
		467	}
		468	if (flags & NZDIGITS)
		469	flags &= ~(SIGNOK\|NZDIGITS\|NDIGITS);
		470	else
		471	flags &= ~(SIGNOK\|PFXOK\|NDIGITS);
		472	goto ok;
		473
		474	/* 1 through 7 always legal */
		475	case '1': case '2': case '3':
		476	case '4': case '5': case '6': case '7':
		477	base = basefix[base];
		478	flags &= ~(SIGNOK \| PFXOK \| NDIGITS);
		479	goto ok;
		480
		481	/* digits 8 and 9 ok iff decimal or hex */
		482	case '8': case '9':
		483	base = basefix[base];
		484	if (base <= 8)
		485	break; /* not legal here */
		486	flags &= ~(SIGNOK \| PFXOK \| NDIGITS);
		487	goto ok;
		488
		489	/* letters ok iff hex */
		490	case 'A': case 'B': case 'C':
		491	case 'D': case 'E': case 'F':
		492	case 'a': case 'b': case 'c':
		493	case 'd': case 'e': case 'f':
		494	/* no need to fix base here */
		495	if (base <= 10)
		496	break; /* not legal here */
		497	flags &= ~(SIGNOK \| PFXOK \| NDIGITS);
		498	goto ok;
		499
		500	/* sign ok only as first character */
		501	case '+': case '-':
		502	if (flags & SIGNOK) {
		503	flags &= ~SIGNOK;
		504	goto ok;
		505	}
		506	break;
		507
		508	/* x ok iff flag still set & 2nd char */
		509	case 'x': case 'X':
		510	if (flags & PFXOK && p == buf + 1) {
		511	base = 16; /* if %i */
		512	flags &= ~PFXOK;
		513	goto ok;
		514	}
		515	break;
		516	}
		517
		518	/*
		519	* If we got here, c is not a legal character
		520	* for a number. Stop accumulating digits.
		521	*/
		522	break;
		523	ok:
		524	/*
		525	* c is legal: store it and look at the next.
		526	*/
		527	*p++ = c;
		528	if (--fp->_r > 0)
		529	fp->_p++;
		530	else if (__srefill(fp))
		531	break; /* EOF */
		532	}
		533	/*
		534	* If we had only a sign, it is no good; push
		535	* back the sign. If the number ends in `x',
		536	* it was [sign] '0' 'x', so push back the x
		537	* and treat it as [sign] '0'.
		538	*/
		539	if (flags & NDIGITS) {
		540	if (p > buf)
		541	(void) ungetc((u_char )--p, fp);
		542	goto match_failure;
		543	}
		544	c = ((u_char *)p)[-1];
		545	if (c == 'x' \|\| c == 'X') {
		546	--p;
		547	(void) ungetc(c, fp);
		548	}
		549	if ((flags & SUPPRESS) == 0) {
		550	u_long res;
		551
		552	*p = 0;
		553	res = (ccfn)(buf, (char *)NULL, base);
		554	if (flags & POINTER)
		555	va_arg(ap, void ) = (void )res;
		556	else if (flags & SHORT)
		557	va_arg(ap, short ) = res;
		558	else if (flags & LONG)
		559	va_arg(ap, long ) = res;
		560	else
		561	va_arg(ap, int ) = res;
		562	nassigned++;
		563	}
		564	nread += p - buf;
		565	nconversions++;
		566	break;
		567
		568	#ifdef FLOATING_POINT
		569	case CT_FLOAT:
		570	/* scan a floating point number as if by strtod */
		571	#ifdef hardway
		572	if (width == 0 \|\| width > sizeof(buf) - 1)
		573	width = sizeof(buf) - 1;
		574	#else
		575	/* size_t is unsigned, hence this optimisation */
		576	if (--width > sizeof(buf) - 2)
		577	width = sizeof(buf) - 2;
		578	width++;
		579	#endif
		580	flags \|= SIGNOK \| NDIGITS \| DPTOK \| EXPOK;
		581	for (p = buf; width; width--) {
		582	c = *fp->_p;
		583	/*
		584	* This code mimicks the integer conversion
		585	* code, but is much simpler.
		586	*/
		587	switch (c) {
		588
		589	case '0': case '1': case '2': case '3':
		590	case '4': case '5': case '6': case '7':
		591	case '8': case '9':
		592	flags &= ~(SIGNOK \| NDIGITS);
		593	goto fok;
		594
		595	case '+': case '-':
		596	if (flags & SIGNOK) {
		597	flags &= ~SIGNOK;
		598	goto fok;
		599	}
		600	break;
		601	case '.':
		602	if (flags & DPTOK) {
		603	flags &= ~(SIGNOK \| DPTOK);
		604	goto fok;
		605	}
		606	break;
		607	case 'e': case 'E':
		608	/* no exponent without some digits */
		609	if ((flags&(NDIGITS\|EXPOK)) == EXPOK) {
		610	flags =
		611	(flags & ~(EXPOK\|DPTOK)) \|
		612	SIGNOK \| NDIGITS;
		613	goto fok;
		614	}
		615	break;
		616	}
		617	break;
		618	fok:
		619	*p++ = c;
		620	if (--fp->_r > 0)
		621	fp->_p++;
		622	else if (__srefill(fp))
		623	break; /* EOF */
		624	}
		625	/*
		626	* If no digits, might be missing exponent digits
		627	* (just give back the exponent) or might be missing
		628	* regular digits, but had sign and/or decimal point.
		629	*/
		630	if (flags & NDIGITS) {
		631	if (flags & EXPOK) {
		632	/* no digits at all */
		633	while (p > buf)
		634	ungetc((u_char )--p, fp);
		635	goto match_failure;
		636	}
		637	/* just a bad exponent (e and maybe sign) */
		638	c = (u_char )--p;
		639	if (c != 'e' && c != 'E') {
		640	(void) ungetc(c, fp);/* sign */
		641	c = (u_char )--p;
		642	}
		643	(void) ungetc(c, fp);
		644	}
		645	if ((flags & SUPPRESS) == 0) {
		646	double res;
		647
		648	*p = 0;
		649	res = strtod(buf,(char **) NULL);
		650	if (flags & LONG)
		651	va_arg(ap, double ) = res;
		652	else
		653	va_arg(ap, float ) = res;
		654	nassigned++;
		655	}
		656	nread += p - buf;
		657	nconversions++;
		658	break;
		659	#endif /* FLOATING_POINT */
		660	}
		661	}
		662	input_failure:
		663	return (nconversions != 0 ? nassigned : EOF);
		664	match_failure:
		665	return (nassigned);
		666	}
		667
		668	/*
		669	* Fill in the given table from the scanset at the given format
		670	* (just after `['). Return a pointer to the character past the
		671	* closing `]'. The table has a 1 wherever characters should be
		672	* considered part of the scanset.
		673	*/
		674	static u_char *
		675	__sccl(tab, fmt)
		676	register char *tab;
		677	register u_char *fmt;
		678	{
		679	register int c, n, v, i;
		680
		681	/* first `clear' the whole table */
		682	c = fmt++; / first char hat => negated scanset */
		683	if (c == '^') {
		684	v = 1; /* default => accept */
		685	c = fmt++; / get new first char */
		686	} else
		687	v = 0; /* default => reject */
		688	(void) memset(tab, v, 256);
		689	if (c == 0)
		690	return (fmt - 1);/* format ended before closing ] */
		691
		692	/*
		693	* Now set the entries corresponding to the actual scanset
		694	* to the opposite of the above.
		695	*
		696	* The first character may be ']' (or '-') without being special;
		697	* the last character may be '-'.
		698	*/
		699	v = 1 - v;
		700	for (;;) {
		701	tab[c] = v; /* take character c */
		702	doswitch:
		703	n = fmt++; / and examine the next */
		704	switch (n) {
		705
		706	case 0: /* format ended too soon */
		707	return (fmt - 1);
		708
		709	case '-':
		710	/*
		711	* A scanset of the form
		712	* [01+-]
		713	* is defined as `the digit 0, the digit 1,
		714	* the character +, the character -', but
		715	* the effect of a scanset such as
		716	* [a-zA-Z0-9]
		717	* is implementation defined. The V7 Unix
		718	* scanf treats `a-z' as `the letters a through
		719	* z', but treats `a-a' as `the letter a, the
		720	* character -, and the letter a'.
		721	*
		722	* For compatibility, the `-' is not considerd
		723	* to define a range if the character following
		724	* it is either a close bracket (required by ANSI)
		725	* or is not numerically greater than the character
		726	* we just stored in the table (c).
		727	*/
		728	n = *fmt;
		729	if (n == ']' \|\| __collate_range_cmp (n, c) < 0) {
		730	c = '-';
		731	break; /* resume the for(;;) */
		732	}
		733	fmt++;
		734	/* fill in the range */
		735	for (i = 0; i < 256; i ++)
		736	if ( __collate_range_cmp (c, i) < 0
		737	&& __collate_range_cmp (i, n) <= 0
		738	)
		739	tab[i] = v;
		740	#if 1 /* XXX another disgusting compatibility hack */
		741	c = n;
		742	/*
		743	* Alas, the V7 Unix scanf also treats formats
		744	* such as [a-c-e] as `the letters a through e'.
		745	* This too is permitted by the standard....
		746	*/
		747	goto doswitch;
		748	#else
		749	c = *fmt++;
		750	if (c == 0)
		751	return (fmt - 1);
		752	if (c == ']')
		753	return (fmt);
		754	#endif
		755	break;
		756
		757	case ']': /* end of scanset */
		758	return (fmt);
		759
		760	default: /* just another character */
		761	c = n;
		762	break;
		763	}
		764	}
		765	/* NOTREACHED */
		766	}

Subversion Repositories shark

(root)/shark/branches/pj/libc/stdio/vfscanf.c - Rev 2