Context Navigation

source: mainline/uspace/lib/c/generic/stdio/scanf.c@ d73d992

Visit:

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export

Last change on this file since d73d992 was 80f345c, checked in by Jiri Svoboda <jiri@…>, 7 years ago
Need to carefully pass va_list around by reference to be portable.
Property mode set to `100644`
File size: 24.5 KB

Rev	Line
[ed18e14]	1	/*
	2	* Copyright (c) 2018 Jiri Svoboda
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	*
	9	* - Redistributions of source code must retain the above copyright
	10	* notice, this list of conditions and the following disclaimer.
	11	* - Redistributions in binary form must reproduce the above copyright
	12	* notice, this list of conditions and the following disclaimer in the
	13	* documentation and/or other materials provided with the distribution.
	14	* - The name of the author may not be used to endorse or promote products
	15	* derived from this software without specific prior written permission.
	16	*
	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	27	*/
	28
	29	/** @addtogroup libc
	30	* @{
	31	*/
	32	/**
	33	* @file
	34	* @brief Formatted input (scanf family)
	35	*/
	36
	37	#include <assert.h>
	38	#include <_bits/ssize_t.h>
	39	#include <ctype.h>
	40	#include <errno.h>
	41	#include <limits.h>
	42	#include <stdarg.h>
	43	#include <stdbool.h>
	44	#include <stddef.h>
	45	#include <stdint.h>
	46	#include <stdio.h>
	47	#include <stdlib.h>
	48
	49	typedef enum {
	50	/** No length modifier */
	51	lm_none,
	52	/** 'hh' */
	53	lm_hh,
	54	/** 'h' */
	55	lm_h,
	56	/** 'l' */
	57	lm_l,
	58	/** 'll' */
	59	lm_ll,
	60	/** 'j' */
	61	lm_j,
	62	/** 'z' */
	63	lm_z,
	64	/** 't' */
	65	lm_t,
	66	/** 'L' */
	67	lm_L
	68	} lenmod_t;
	69
	70	typedef enum {
	71	/** Unknown */
	72	cs_unknown,
	73	/** 'd' */
	74	cs_decimal,
	75	/** 'i' */
	76	cs_int,
	77	/** 'o' */
	78	cs_octal,
	79	/** 'u' */
	80	cs_udecimal,
	81	/** 'x', 'X' */
	82	cs_hex,
	83	/** 'a', 'e', 'f', 'g', 'A', 'E', 'F', 'G' */
	84	cs_float,
	85	/** 'c' */
	86	cs_char,
	87	/** 's' */
	88	cs_str,
	89	/* [...] */
	90	cs_set,
	91	/* 'p' */
	92	cs_ptr,
	93	/* 'n' */
	94	cs_numchar,
	95	/* '%' */
	96	cs_percent
	97	} cvtspcr_t;
	98
	99	/** Conversion specification */
	100	typedef struct {
	101	/** Suppress assignment */
	102	bool noassign;
	103	/** Allocate memory for string (GNU extension) */
	104	bool memalloc;
	105	/** @c true if width field is valid */
	106	bool have_width;
	107	/** Width */
	108	size_t width;
	109	/** Length modifier */
	110	lenmod_t lenmod;
	111	/** Conversion specifier */
	112	cvtspcr_t spcr;
	113	/** Scan set (if spc == cs_set) */
	114	const char *scanset;
	115	} cvtspec_t;
	116
	117	/** Buffer for writing strings */
	118	typedef struct {
	119	/** Buffer */
	120	char *buf;
	121	/** Place where to store pointer to the buffer */
	122	char **pptr;
	123	/** Allocating memory for caller */
	124	bool memalloc;
	125	/** Current size of allocated buffer */
	126	size_t size;
	127	} strbuf_t;
	128
[80f345c]	129	/** Wrapper needed to pass va_list around by reference in a portable fashion */
	130	typedef struct {
	131	va_list ap;
	132	} va_encaps_t;
	133
[ed18e14]	134	static int digit_value(char digit)
	135	{
	136	switch (digit) {
	137	case '0':
	138	return 0;
	139	case '1':
	140	return 1;
	141	case '2':
	142	return 2;
	143	case '3':
	144	return 3;
	145	case '4':
	146	return 4;
	147	case '5':
	148	return 5;
	149	case '6':
	150	return 6;
	151	case '7':
	152	return 7;
	153	case '8':
	154	return 8;
	155	case '9':
	156	return 9;
	157	case 'a':
	158	case 'A':
	159	return 10;
	160	case 'b':
	161	case 'B':
	162	return 11;
	163	case 'c':
	164	case 'C':
	165	return 12;
	166	case 'd':
	167	case 'D':
	168	return 13;
	169	case 'e':
	170	case 'E':
	171	return 14;
	172	case 'f':
	173	case 'F':
	174	return 15;
	175	default:
	176	assert(false);
	177	}
	178	}
	179
	180	static void cvtspec_parse(const char *fmt, cvtspec_t spec)
	181	{
	182	spec->scanset = NULL;
	183	spec->width = 0;
	184
	185	/* Assignment suppresion */
	186
	187	if (*fmt == '') {
	188	spec->noassign = true;
	189	++(*fmt);
	190	} else {
	191	spec->noassign = false;
	192	}
	193
	194	/* Memory allocation */
	195
	196	if (**fmt == 'm') {
	197	spec->memalloc = true;
	198	++(*fmt);
	199	} else {
	200	spec->memalloc = false;
	201	}
	202
	203	/* Width specifier */
	204
	205	if (isdigit(**fmt)) {
	206	spec->have_width = true;
	207	assert(**fmt != '0');
	208	spec->width = 0;
	209	while (isdigit(**fmt)) {
	210	spec->width *= 10;
	211	spec->width += digit_value(**fmt);
	212	++(*fmt);
	213	}
	214	} else {
	215	spec->have_width = false;
	216	}
	217
	218	/* Length modifier */
	219
	220	switch (**fmt) {
	221	case 'h':
	222	++(*fmt);
	223	if (**fmt == 'h') {
	224	spec->lenmod = lm_hh;
	225	++(*fmt);
	226	} else {
	227	spec->lenmod = lm_h;
	228	}
	229	break;
	230	case 'l':
	231	++(*fmt);
	232	if (**fmt == 'l') {
	233	spec->lenmod = lm_ll;
	234	++(*fmt);
	235	} else {
	236	spec->lenmod = lm_l;
	237	}
	238	break;
	239	case 'j':
	240	++(*fmt);
	241	spec->lenmod = lm_j;
	242	break;
	243	case 'z':
	244	++(*fmt);
	245	spec->lenmod = lm_z;
	246	break;
	247	case 't':
	248	++(*fmt);
	249	spec->lenmod = lm_t;
	250	break;
	251	case 'L':
	252	++(*fmt);
	253	spec->lenmod = lm_L;
	254	break;
	255	default:
	256	spec->lenmod = lm_none;
	257	break;
	258	}
	259
	260	/* Conversion specifier */
	261
	262	switch (**fmt) {
	263	case 'd':
	264	++(*fmt);
	265	spec->spcr = cs_decimal;
	266	break;
	267	case 'i':
	268	++(*fmt);
	269	spec->spcr = cs_int;
	270	break;
	271	case 'o':
	272	++(*fmt);
	273	spec->spcr = cs_octal;
	274	break;
	275	case 'u':
	276	++(*fmt);
	277	spec->spcr = cs_udecimal;
	278	break;
	279	case 'x':
	280	case 'X':
	281	++(*fmt);
	282	spec->spcr = cs_hex;
	283	break;
	284	case 'a':
	285	case 'e':
	286	case 'f':
	287	case 'g':
	288	case 'A':
	289	case 'E':
	290	case 'F':
	291	case 'G':
	292	++(*fmt);
	293	spec->spcr = cs_float;
	294	break;
	295	case 'c':
	296	++(*fmt);
	297	spec->spcr = cs_char;
	298	break;
	299	case 's':
	300	++(*fmt);
	301	spec->spcr = cs_str;
	302	break;
	303	case '[':
	304	++(*fmt);
	305	spec->spcr = cs_set;
	306	spec->scanset = *fmt;
	307	while (fmt != ']' && fmt != '\0')
	308	++(*fmt);
	309	if (**fmt == ']')
	310	++(*fmt);
	311	break;
	312	case 'p':
	313	++(*fmt);
	314	spec->spcr = cs_ptr;
	315	break;
	316	case 'n':
	317	++(*fmt);
	318	spec->spcr = cs_numchar;
	319	break;
	320	case '%':
	321	++(*fmt);
	322	spec->spcr = cs_percent;
	323	break;
	324	default:
	325	assert(false);
	326	spec->spcr = cs_unknown;
	327	break;
	328	}
	329	}
	330
	331	/** Initialize string buffer.
	332	*
	333	* String buffer is used to write characters from a string conversion.
	334	* The buffer can be provided by caller or dynamically allocated
	335	* (and grown).
	336	*
	337	* Initialize the string buffer @a strbuf. If @a spec->noassign,is true,
	338	* set the buffer pointer to NULL. Otherwise, if @a spec->memalloc is true,
	339	* allocate a buffer and read an argument of type char ** designating
	340	* a place where the pointer should be stored. If @a spec->memalloc is false,
	341	* read an argument of type char * and use it as a destination to write
	342	* the characters to.
	343	*
	344	* @param strbuf String buffer to initialize
	345	* @param cvtspec Conversion specification (noassign, memalloc)
	346	* @param ap Argument list to read pointer from
	347	*
	348	* @return EOK on success, ENOMEM if out of memory
	349	*/
[80f345c]	350	static int strbuf_init(strbuf_t strbuf, cvtspec_t spec, va_encaps_t *va)
[ed18e14]	351	{
	352	if (spec->noassign) {
	353	strbuf->memalloc = false;
	354	strbuf->buf = NULL;
	355	strbuf->pptr = NULL;
	356	strbuf->size = 0;
	357	return EOK;
	358	}
	359
	360	if (spec->memalloc) {
	361	/* Allocate memory for caller */
	362	strbuf->memalloc = true;
	363	strbuf->size = 1;
	364	strbuf->buf = malloc(strbuf->size);
	365	if (strbuf->buf == NULL)
	366	return ENOMEM;
	367
	368	/*
	369	* Save pointer to allocated buffer to caller-provided
	370	* location
	371	*/
[80f345c]	372	strbuf->pptr = va_arg(va->ap, char **);
[ed18e14]	373	*strbuf->pptr = strbuf->buf;
	374	} else {
	375	/* Caller-provided buffer */
	376	strbuf->memalloc = false;
	377	strbuf->size = 0;
[80f345c]	378	strbuf->buf = va_arg(va->ap, char *);
[ed18e14]	379	strbuf->pptr = NULL;
	380	}
	381
	382	return EOK;
	383	}
	384
	385	/** Write character at the specified position in a string buffer.
	386	*
	387	* The buffer is enlarged if necessary.
	388	*
	389	* @param strbuf String buffer
	390	* @param idx Character position (starting from 0)
	391	* @param c Character to write
	392	*
	393	* @return EOK on sucess, ENOMEM if out of memory
	394	*/
	395	static int strbuf_write(strbuf_t *strbuf, size_t idx, char c)
	396	{
	397	if (strbuf->memalloc && idx >= strbuf->size) {
	398	/* Enlarge buffer */
	399	strbuf->size = strbuf->size * 2;
	400	strbuf->buf = realloc(strbuf->buf, strbuf->size);
	401	*strbuf->pptr = strbuf->buf;
	402	if (strbuf->buf == NULL)
	403	return ENOMEM;
	404	}
	405
	406	if (strbuf->buf != NULL)
	407	strbuf->buf[idx] = c;
	408
	409	return EOK;
	410	}
	411
	412	/** Get character from stream, keeping count of number of characters read.
	413	*
	414	* @param f Stream
	415	* @param numchar Pointer to counter of characters read
	416	* @return Character on success, EOF on error
	417	*/
	418	static int __fgetc(FILE f, int numchar)
	419	{
	420	int c;
	421
	422	c = fgetc(f);
	423	if (c == EOF)
	424	return EOF;
	425
	426	++(*numchar);
	427	return c;
	428	}
	429
	430	/** Unget character to stream, keeping count of number of characters read.
	431	*
	432	* @param c Character
	433	* @param f Stream
	434	* @param numchar Pointer to counter of characters read
	435	*
	436	* @return @a c on success, EOF on failure
	437	*/
	438	static int __ungetc(int c, FILE f, int numchar)
	439	{
	440	int rc;
	441
	442	rc = ungetc(c, f);
	443	if (rc == EOF)
	444	return EOF;
	445
	446	--(*numchar);
	447	return rc;
	448	}
	449
	450	/* Skip whitespace in input stream */
	451	static int vfscanf_skip_ws(FILE f, int numchar)
	452	{
	453	int c;
	454
	455	c = __fgetc(f, numchar);
	456	if (c == EOF)
	457	return EIO;
	458
	459	while (isspace(c)) {
	460	c = __fgetc(f, numchar);
	461	if (c == EOF)
	462	return EIO;
	463	}
	464
	465	if (c == EOF)
	466	return EIO;
	467
	468	__ungetc(c, f, numchar);
	469	return EOK;
	470	}
	471
	472	/* Match whitespace. */
	473	static int vfscanf_match_ws(FILE f, int numchar, const char **fmt)
	474	{
	475	int rc;
	476
	477	rc = vfscanf_skip_ws(f, numchar);
	478	if (rc == EOF)
	479	return EIO;
	480
	481	++(*fmt);
	482	return EOK;
	483	}
	484
	485	/** Read intmax_t integer from file.
	486	*
	487	* @param f Input file
	488	* @param numchar Pointer to counter of characters read
	489	* @param base Numeric base (0 means detect using prefix)
	490	* @param width Maximum field with in characters
	491	* @param dest Place to store result
	492	* @return EOK on success, EIO on I/O error, EINVAL if input is not valid
	493	*/
	494	static int __fstrtoimax(FILE f, int numchar, int base, size_t width,
	495	intmax_t *dest)
	496	{
	497	int c;
	498	intmax_t v;
	499	int digit;
	500	int sign;
	501
	502	c = __fgetc(f, numchar);
	503	if (c == EOF)
	504	return EIO;
	505
	506	if (c == '+' \|\| c == '-') {
	507	/* Sign */
	508	sign = (c == '-') ? -1 : +1;
	509	c = __fgetc(f, numchar);
	510	if (c == EOF)
	511	return EIO;
	512	--width;
	513	} else {
	514	sign = 1;
	515	}
	516
	517	if (!isdigit(c) \|\| width < 1) {
	518	__ungetc(c, f, numchar);
	519	return EINVAL;
	520	}
	521
	522	if (base == 0) {
	523	/* Base prefix */
	524	if (c == '0') {
	525	c = __fgetc(f, numchar);
	526	if (c == EOF)
	527	return EIO;
	528	--width;
	529
	530	if (width > 0 && (c == 'x' \|\| c == 'X')) {
	531	--width;
	532	c = __fgetc(f, numchar);
	533	if (c == EOF)
	534	return EIO;
	535	if (width > 0 && isxdigit(c)) {
	536	base = 16;
	537	} else {
	538	*dest = 0;
	539	return EOK;
	540	}
	541	} else {
	542	base = 8;
	543	if (width == 0) {
	544	*dest = 0;
	545	return EOK;
	546	}
	547	}
	548	} else {
	549	base = 10;
	550	}
	551	}
	552
	553	/* Value */
	554	v = 0;
	555	do {
	556	digit = digit_value(c);
	557	if (digit >= base)
	558	break;
	559
	560	v = v * base + digit;
	561	c = __fgetc(f, numchar);
	562	--width;
	563	} while (width > 0 && isxdigit(c));
	564
	565	if (c != EOF)
	566	__ungetc(c, f, numchar);
	567
	568	dest = sign v;
	569	return EOK;
	570	}
	571
	572	/** Read uintmax_t unsigned integer from file.
	573	*
	574	* @param f Input file
	575	* @param numchar Pointer to counter of characters read
	576	* @param base Numeric base (0 means detect using prefix)
	577	* @param width Maximum field with in characters
	578	* @param dest Place to store result
	579	* @return EOK on success, EIO on I/O error, EINVAL if input is not valid
	580	*/
	581	static int __fstrtoumax(FILE f, int numchar, int base, size_t width,
	582	uintmax_t *dest)
	583	{
	584	int c;
	585	uintmax_t v;
	586	int digit;
	587
	588	c = __fgetc(f, numchar);
	589	if (c == EOF)
	590	return EIO;
	591
	592	if (!isdigit(c) \|\| width < 1) {
	593	__ungetc(c, f, numchar);
	594	return EINVAL;
	595	}
	596
	597	if (base == 0) {
	598	/* Base prefix */
	599	if (c == '0') {
	600	c = __fgetc(f, numchar);
	601	if (c == EOF)
	602	return EIO;
	603	--width;
	604
	605	if (width > 0 && (c == 'x' \|\| c == 'X')) {
	606	--width;
	607	c = __fgetc(f, numchar);
	608	if (c == EOF)
	609	return EIO;
	610	if (width > 0 && isxdigit(c)) {
	611	base = 16;
	612	} else {
	613	*dest = 0;
	614	return EOK;
	615	}
	616	} else {
	617	base = 8;
	618	if (width == 0) {
	619	*dest = 0;
	620	return EOK;
	621	}
	622	}
	623	} else {
	624	base = 10;
	625	}
	626	}
	627
	628	/* Value */
	629	v = 0;
	630	do {
[5a6c28d1]	631	digit = digit_value(c);
[ed18e14]	632	if (digit >= base)
	633	break;
	634
	635	v = v * base + digit;
	636	c = __fgetc(f, numchar);
	637	--width;
	638	} while (width > 0 && isxdigit(c));
	639
	640	if (c != EOF)
	641	__ungetc(c, f, numchar);
	642
	643	*dest = v;
	644	return EOK;
	645	}
	646
	647	/** Read long double from file.
	648	*
	649	* @param f Input file
	650	* @param numchar Pointer to counter of characters read
	651	* @param width Maximum field with in characters
	652	* @param dest Place to store result
	653	* @return EOK on success, EIO on I/O error, EINVAL if input is not valid
	654	*/
	655	static int __fstrtold(FILE f, int numchar, size_t width, long double *dest)
	656	{
	657	int c;
	658	long double v;
	659	int digit;
	660	int sign;
	661	int base;
	662	int efactor;
	663	int eadd;
	664	int eadj;
	665	int exp;
	666	int expsign;
	667
	668	c = __fgetc(f, numchar);
	669	if (c == EOF)
	670	return EIO;
	671
	672	if (c == '+' \|\| c == '-') {
	673	/* Sign */
	674	sign = (c == '-') ? -1 : +1;
	675	c = __fgetc(f, numchar);
	676	if (c == EOF)
	677	return EIO;
	678	--width;
	679	} else {
	680	sign = 1;
	681	}
	682
	683	if (!isdigit(c) \|\| width < 1) {
	684	__ungetc(c, f, numchar);
	685	return EINVAL;
	686	}
	687
	688	/*
	689	* Default is base 10
	690	*/
	691
	692	/* Significand is in base 10 */
	693	base = 10;
	694	/* e+1 multiplies number by ten */
	695	efactor = 10;
	696	/* Adjust exp. by one for each fractional digit */
	697	eadd = 1;
	698
	699	/* Base prefix */
	700	if (c == '0') {
	701	c = __fgetc(f, numchar);
	702	if (c == EOF)
	703	return EIO;
	704	--width;
	705
	706	if (width > 0 && (c == 'x' \|\| c == 'X')) {
	707	--width;
	708	c = __fgetc(f, numchar);
	709
	710	if (width > 0 && isxdigit(c)) {
	711	/* Significand is in base 16 */
	712	base = 16;
	713	/* p+1 multiplies number by two */
	714	efactor = 2;
	715	/*
	716	* Adjust exponent by 4 for each
	717	* fractional digit
	718	*/
	719	eadd = 4;
	720	} else {
	721	*dest = 0;
	722	return EOK;
	723	}
	724	}
	725	}
	726
	727	/* Value */
	728	v = 0;
	729	do {
	730	digit = digit_value(c);
	731	if (digit >= base)
	732	break;
	733
	734	v = v * base + digit;
	735	c = __fgetc(f, numchar);
	736	--width;
	737	} while (width > 0 && isxdigit(c));
	738
	739	/* Decimal-point */
	740	eadj = 0;
	741
	742	if (c == '.' && width > 1) {
	743	c = __fgetc(f, numchar);
	744	if (c == EOF)
	745	return EIO;
	746
	747	--width;
	748
	749	/* Fractional part */
	750	while (width > 0 && isxdigit(c)) {
	751	digit = digit_value(c);
	752	if (digit >= base)
	753	break;
	754
	755	v = v * base + digit;
	756	c = __fgetc(f, numchar);
	757	--width;
	758	eadj -= eadd;
	759	}
	760	}
	761
	762	exp = 0;
	763
	764	/* Exponent */
	765	if ((width > 1 && base == 10 && (c == 'e' \|\| c == 'E')) \|\|
	766	(width > 1 && base == 16 && (c == 'p' \|\| c == 'P'))) {
	767	c = __fgetc(f, numchar);
	768	if (c == EOF)
	769	return EIO;
	770
	771	--width;
	772
	773	if (width > 1 && (c == '+' \|\| c == '-')) {
	774	/* Exponent sign */
	775	if (c == '+') {
	776	expsign = 1;
	777	} else {
	778	expsign = -1;
	779	}
	780
	781	c = __fgetc(f, numchar);
	782	if (c == EOF)
	783	return EIO;
	784
	785	--width;
	786	} else {
	787	expsign = 1;
	788	}
	789
	790	while (width > 0 && isdigit(c)) {
	791	digit = digit_value(c);
	792	if (digit >= 10)
	793	break;
	794
	795	exp = exp * 10 + digit;
	796	c = __fgetc(f, numchar);
	797	--width;
	798	}
	799
	800	exp = exp * expsign;
	801	}
	802
	803	exp += eadj;
	804
	805	/* Adjust v for value of exponent */
	806
	807	while (exp > 0) {
	808	v = v * efactor;
	809	--exp;
	810	}
	811
	812	while (exp < 0) {
	813	v = v / efactor;
	814	++exp;
	815	}
	816
	817	if (c != EOF)
	818	__ungetc(c, f, numchar);
	819
	820	dest = sign v;
	821	return EOK;
	822	}
	823
	824	/* Read characters from stream */
	825	static int __fgetchars(FILE f, int numchar, size_t width, strbuf_t *strbuf,
	826	size_t *nread)
	827	{
	828	size_t cnt;
	829	int c;
	830	int rc;
	831
	832	for (cnt = 0; cnt < width; cnt++) {
	833	c = __fgetc(f, numchar);
	834	if (c == EOF) {
	835	*nread = cnt;
	836	return EIO;
	837	}
	838
	839	rc = strbuf_write(strbuf, cnt, c);
	840	if (rc != EOK) {
	841	*nread = cnt;
	842	return rc;
	843	}
	844	}
	845
	846	*nread = cnt;
	847	return EOK;
	848	}
	849
	850	/* Read non-whitespace string from stream */
	851	static int __fgetstr(FILE f, int numchar, size_t width, strbuf_t *strbuf,
	852	size_t *nread)
	853	{
	854	size_t cnt;
	855	int c;
	856	int rc;
	857	int rc2;
	858
	859	rc = EOK;
	860
	861	for (cnt = 0; cnt < width; cnt++) {
	862	c = __fgetc(f, numchar);
	863	if (c == EOF) {
	864	rc = EIO;
	865	break;
	866	}
	867
	868	if (isspace(c)) {
	869	__ungetc(c, f, numchar);
	870	break;
	871	}
	872
	873	rc = strbuf_write(strbuf, cnt, c);
	874	if (rc != EOK) {
	875	*nread = cnt;
	876	return rc;
	877	}
	878	}
	879
	880	/* Null-terminate */
	881	rc2 = strbuf_write(strbuf, cnt, '\0');
	882	if (rc2 != EOK) {
	883	*nread = cnt;
	884	return rc2;
	885	}
	886
	887	*nread = cnt;
	888	return rc;
	889	}
	890
	891	/** Determine if character is in scanset.
[39f84ce4]	892	*
	893	* Note that we support ranges, although that is a GNU extension.
[ed18e14]	894	*
	895	* @param c Character
	896	* @param scanset Pointer to scanset
	897	* @return @c true iff @a c is in scanset @a scanset.
	898	*/
	899	static bool is_in_scanset(char c, const char *scanset)
	900	{
	901	const char *p = scanset;
	902	bool inverted = false;
[39f84ce4]	903	char startc;
	904	char endc;
[ed18e14]	905
	906	/* Inverted scanset */
	907	if (*p == '^') {
	908	inverted = true;
	909	++p;
	910	}
	911
[39f84ce4]	912	/*
	913	* Either ']' or '-' at beginning or after '^' loses special meaning.
	914	* However, '-' after ']' (or vice versa) does not.
	915	*/
[ed18e14]	916	if (*p == ']') {
[39f84ce4]	917	/* ']' character in scanset */
[ed18e14]	918	if (c == ']')
	919	return !inverted;
	920	++p;
[39f84ce4]	921	} else if (*p == '-') {
	922	/* '-' character in scanset */
	923	if (c == '-')
	924	return !inverted;
	925	++p;
[ed18e14]	926	}
	927
	928	/* Remaining characters */
	929	while (p != '\0' && p != ']') {
[39f84ce4]	930	/* '-' is a range unless it's the last character in scanset */
	931	if (*p == '-' && p[1] != ']' && p[1] != '\0') {
	932	startc = p[-1];
	933	endc = p[1];
	934
	935	if (c >= startc && c <= endc)
	936	return !inverted;
	937
	938	p += 2;
	939	continue;
	940	}
	941
[ed18e14]	942	if (*p == c)
	943	return !inverted;
	944	++p;
	945	}
	946
	947	return inverted;
	948	}
	949
	950	/* Read string of characters from scanset from stream */
	951	static int __fgetscanstr(FILE f, int numchar, size_t width,
	952	const char scanset, strbuf_t strbuf, size_t *nread)
	953	{
	954	size_t cnt;
	955	int c;
	956	int rc;
	957	int rc2;
	958
	959	rc = EOK;
	960
	961	for (cnt = 0; cnt < width; cnt++) {
	962	c = __fgetc(f, numchar);
	963	if (c == EOF) {
	964	rc = EIO;
	965	break;
	966	}
	967
	968	if (!is_in_scanset(c, scanset)) {
	969	__ungetc(c, f, numchar);
	970	break;
	971	}
	972
	973	rc = strbuf_write(strbuf, cnt, c);
	974	if (rc != EOK) {
	975	*nread = cnt;
	976	break;
	977	}
	978	}
	979
	980	/* Null-terminate */
	981	rc2 = strbuf_write(strbuf, cnt, '\0');
	982	if (rc2 != EOK) {
	983	*nread = cnt;
	984	return rc2;
	985	}
	986
	987	*nread = cnt;
	988	return rc;
	989	}
	990
	991	/** Perform a single conversion. */
[80f345c]	992	static int vfscanf_cvt(FILE f, const char fmt, va_encaps_t va,
	993	int numchar, unsigned ncvt)
[ed18e14]	994	{
	995	int rc;
	996	int c;
	997	intmax_t ival;
	998	uintmax_t uval;
	999	long double fval = 0.0;
	1000	int *iptr;
	1001	short *sptr;
	1002	signed char *scptr;
	1003	long *lptr;
	1004	long long *llptr;
	1005	ssize_t *ssptr;
	1006	ptrdiff_t *pdptr;
	1007	intmax_t *imptr;
	1008	unsigned *uptr;
	1009	unsigned short *usptr;
	1010	unsigned char *ucptr;
	1011	unsigned long *ulptr;
	1012	unsigned long long *ullptr;
	1013	float *fptr;
	1014	double *dptr;
	1015	long double *ldptr;
	1016	size_t *szptr;
	1017	ptrdiff_t *updptr;
	1018	uintmax_t *umptr;
	1019	void **pptr;
	1020	size_t width;
	1021	cvtspec_t cvtspec;
	1022	strbuf_t strbuf;
	1023	size_t nread;
	1024
	1025	++(*fmt);
	1026
	1027	cvtspec_parse(fmt, &cvtspec);
	1028
	1029	if (cvtspec.spcr != cs_set && cvtspec.spcr != cs_char &&
	1030	cvtspec.spcr != cs_numchar) {
	1031	/* Skip whitespace */
	1032	rc = vfscanf_skip_ws(f, numchar);
	1033	if (rc == EIO)
	1034	return EIO;
	1035
	1036	assert(rc == EOK);
	1037	}
	1038
	1039	width = cvtspec.have_width ? cvtspec.width : SIZE_MAX;
	1040
	1041	switch (cvtspec.spcr) {
	1042	case cs_percent:
	1043	/* Match % character */
	1044	c = __fgetc(f, numchar);
	1045	if (c == EOF)
	1046	return EIO;
	1047	if (c != '%') {
	1048	__ungetc(c, f, numchar);
	1049	return EINVAL;
	1050	}
	1051	break;
	1052	case cs_decimal:
	1053	/* Decimal integer */
	1054	rc = __fstrtoimax(f, numchar, 10, width, &ival);
	1055	if (rc != EOK)
	1056	return rc;
	1057	break;
	1058	case cs_udecimal:
	1059	/* Decimal unsigned integer */
	1060	rc = __fstrtoumax(f, numchar, 10, width, &uval);
	1061	if (rc != EOK)
	1062	return rc;
	1063	break;
	1064	case cs_octal:
	1065	/* Octal unsigned integer */
	1066	rc = __fstrtoumax(f, numchar, 8, width, &uval);
	1067	if (rc != EOK)
	1068	return rc;
	1069	break;
	1070	case cs_hex:
	1071	/* Hexadecimal unsigned integer */
	1072	rc = __fstrtoumax(f, numchar, 16, width, &uval);
	1073	if (rc != EOK)
	1074	return rc;
	1075	break;
	1076	case cs_float:
	1077	/* Floating-point value */
	1078	rc = __fstrtold(f, numchar, width, &fval);
	1079	if (rc != EOK)
	1080	return rc;
	1081	break;
	1082	case cs_int:
	1083	/* Signed integer with base detection */
	1084	rc = __fstrtoimax(f, numchar, 0, width, &ival);
	1085	if (rc != EOK)
	1086	return rc;
	1087	break;
	1088	case cs_ptr:
	1089	/* Unsigned integer with base detection (need 0xXXXXX) */
	1090	rc = __fstrtoumax(f, numchar, 0, width, &uval);
	1091	if (rc != EOK)
	1092	return rc;
	1093	break;
	1094	case cs_char:
	1095	/* Characters */
[80f345c]	1096	rc = strbuf_init(&strbuf, &cvtspec, va);
[ed18e14]	1097	if (rc != EOK)
	1098	return rc;
	1099
	1100	width = cvtspec.have_width ? cvtspec.width : 1;
	1101	rc = __fgetchars(f, numchar, width, &strbuf, &nread);
	1102	if (rc != EOK) {
	1103	if (rc == ENOMEM)
	1104	return EIO;
	1105
	1106	assert(rc == EIO);
	1107	/* If we have at least one char, we succeeded */
	1108	if (nread > 0)
	1109	++(*ncvt);
	1110	return EIO;
	1111	}
	1112	break;
	1113	case cs_str:
	1114	/* Non-whitespace string */
[80f345c]	1115	rc = strbuf_init(&strbuf, &cvtspec, va);
[ed18e14]	1116	if (rc != EOK)
	1117	return rc;
	1118
	1119	width = cvtspec.have_width ? cvtspec.width : SIZE_MAX;
	1120	rc = __fgetstr(f, numchar, width, &strbuf, &nread);
	1121	if (rc != EOK) {
	1122	if (rc == ENOMEM)
	1123	return EIO;
	1124
	1125	assert(rc == EIO);
	1126	/* If we have at least one char, we succeeded */
	1127	if (nread > 0)
	1128	++(*ncvt);
	1129	return EIO;
	1130	}
	1131	break;
	1132	case cs_set:
	1133	/* String of characters from scanset */
[80f345c]	1134	rc = strbuf_init(&strbuf, &cvtspec, va);
[ed18e14]	1135	if (rc != EOK)
	1136	return rc;
	1137
	1138	width = cvtspec.have_width ? cvtspec.width : SIZE_MAX;
	1139	rc = __fgetscanstr(f, numchar, width, cvtspec.scanset,
	1140	&strbuf, &nread);
	1141	if (rc != EOK) {
	1142	if (rc == ENOMEM)
	1143	return EIO;
	1144
	1145	assert(rc == EIO);
	1146	/* If we have at least one char, we succeeded */
	1147	if (nread > 0)
	1148	++(*ncvt);
	1149	return EIO;
	1150	}
	1151	break;
	1152	case cs_numchar:
	1153	break;
	1154	default:
	1155	return EINVAL;
	1156	}
	1157
	1158	/* Assignment */
	1159
	1160	if (cvtspec.noassign)
	1161	goto skip_assign;
	1162
	1163	switch (cvtspec.spcr) {
	1164	case cs_percent:
	1165	break;
	1166	case cs_decimal:
	1167	case cs_int:
	1168	switch (cvtspec.lenmod) {
	1169	case lm_none:
[80f345c]	1170	iptr = va_arg(va->ap, int *);
[ed18e14]	1171	*iptr = ival;
	1172	break;
	1173	case lm_hh:
[80f345c]	1174	scptr = va_arg(va->ap, signed char *);
[ed18e14]	1175	*scptr = ival;
	1176	break;
	1177	case lm_h:
[80f345c]	1178	sptr = va_arg(va->ap, short *);
[ed18e14]	1179	*sptr = ival;
	1180	break;
	1181	case lm_l:
[80f345c]	1182	lptr = va_arg(va->ap, long *);
[ed18e14]	1183	*lptr = ival;
	1184	break;
	1185	case lm_ll:
[80f345c]	1186	llptr = va_arg(va->ap, long long *);
[ed18e14]	1187	*llptr = ival;
	1188	break;
	1189	case lm_j:
[80f345c]	1190	imptr = va_arg(va->ap, intmax_t *);
[ed18e14]	1191	*imptr = ival;
	1192	break;
	1193	case lm_z:
[80f345c]	1194	ssptr = va_arg(va->ap, ssize_t *);
[ed18e14]	1195	*ssptr = ival;
	1196	break;
	1197	case lm_t:
[80f345c]	1198	pdptr = va_arg(va->ap, ptrdiff_t *);
[ed18e14]	1199	*pdptr = ival;
	1200	break;
	1201	default:
	1202	assert(false);
	1203	}
	1204
	1205	++(*ncvt);
	1206	break;
	1207	case cs_udecimal:
	1208	case cs_octal:
	1209	case cs_hex:
	1210	switch (cvtspec.lenmod) {
	1211	case lm_none:
[80f345c]	1212	uptr = va_arg(va->ap, unsigned *);
[ed18e14]	1213	*uptr = uval;
	1214	break;
	1215	case lm_hh:
[80f345c]	1216	ucptr = va_arg(va->ap, unsigned char *);
[ed18e14]	1217	*ucptr = uval;
	1218	break;
	1219	case lm_h:
[80f345c]	1220	usptr = va_arg(va->ap, unsigned short *);
[ed18e14]	1221	*usptr = uval;
	1222	break;
	1223	case lm_l:
[80f345c]	1224	ulptr = va_arg(va->ap, unsigned long *);
[ed18e14]	1225	*ulptr = uval;
	1226	break;
	1227	case lm_ll:
[80f345c]	1228	ullptr = va_arg(va->ap, unsigned long long *);
[ed18e14]	1229	*ullptr = uval;
	1230	break;
	1231	case lm_j:
[80f345c]	1232	umptr = va_arg(va->ap, uintmax_t *);
[ed18e14]	1233	*umptr = uval;
	1234	break;
	1235	case lm_z:
[80f345c]	1236	szptr = va_arg(va->ap, size_t *);
[ed18e14]	1237	*szptr = uval;
	1238	break;
	1239	case lm_t:
[80f345c]	1240	updptr = va_arg(va->ap, ptrdiff_t *);
[ed18e14]	1241	*updptr = uval;
	1242	break;
	1243	default:
	1244	assert(false);
	1245	}
	1246
	1247	++(*ncvt);
	1248	break;
	1249	case cs_float:
	1250	switch (cvtspec.lenmod) {
	1251	case lm_none:
[80f345c]	1252	fptr = va_arg(va->ap, float *);
[ed18e14]	1253	*fptr = fval;
	1254	break;
	1255	case lm_l:
[80f345c]	1256	dptr = va_arg(va->ap, double *);
[ed18e14]	1257	*dptr = fval;
	1258	break;
	1259	case lm_L:
[80f345c]	1260	ldptr = va_arg(va->ap, long double *);
[ed18e14]	1261	*ldptr = fval;
	1262	break;
	1263	default:
	1264	assert(false);
	1265	}
	1266
	1267	++(*ncvt);
	1268	break;
	1269	case cs_ptr:
[80f345c]	1270	pptr = va_arg(va->ap, void *);
[ed18e14]	1271	pptr = (void )(uintptr_t)uval;
	1272	++(*ncvt);
	1273	break;
	1274	case cs_char:
	1275	++(*ncvt);
	1276	break;
	1277	case cs_str:
	1278	++(*ncvt);
	1279	break;
	1280	case cs_set:
	1281	++(*ncvt);
	1282	break;
	1283	case cs_numchar:
	1284	/* Store number of characters read so far. */
[80f345c]	1285	iptr = va_arg(va->ap, int *);
[ed18e14]	1286	iptr = numchar;
	1287	/* No incrementing of ncvt */
	1288	break;
	1289	default:
	1290	return EINVAL;
	1291	}
	1292
	1293	skip_assign:
	1294
	1295	return EOK;
	1296	}
	1297
[5a6c28d1]	1298	int vfscanf(FILE f, const char fmt, va_list ap)
[ed18e14]	1299	{
	1300	const char *cp;
	1301	int c;
	1302	unsigned ncvt;
	1303	int numchar;
	1304	bool input_error = false;
[80f345c]	1305	va_encaps_t va;
[ed18e14]	1306	int rc;
	1307
[80f345c]	1308	va_copy(va.ap, ap);
	1309
[ed18e14]	1310	ncvt = 0;
	1311	numchar = 0;
	1312	cp = fmt;
	1313	while (*cp != '\0') {
	1314	if (isspace(*cp)) {
	1315	/* Whitespace */
	1316	rc = vfscanf_match_ws(f, &numchar, &cp);
	1317	if (rc == EIO) {
	1318	input_error = true;
	1319	break;
	1320	}
	1321
	1322	assert(rc == EOK);
	1323	} else if (*cp == '%') {
	1324	/* Conversion specification */
[80f345c]	1325	rc = vfscanf_cvt(f, &cp, &va, &numchar,
	1326	&ncvt);
[ed18e14]	1327	if (rc == EIO) {
	1328	/* Input error */
	1329	input_error = true;
	1330	break;
	1331	}
	1332
	1333	/* Other error */
	1334	if (rc != EOK)
	1335	break;
	1336	} else {
	1337	/* Match specific character */
	1338	c = __fgetc(f, &numchar);
	1339	if (c == EOF) {
	1340	input_error = true;
	1341	break;
	1342	}
	1343
	1344	if (c != *cp) {
	1345	__ungetc(c, f, &numchar);
	1346	break;
	1347	}
	1348
	1349	++cp;
	1350	}
	1351	}
	1352
	1353	if (input_error && ncvt == 0)
	1354	return EOF;
	1355
	1356	return ncvt;
	1357	}
	1358
[5a6c28d1]	1359	int fscanf(FILE f, const char fmt, ...)
[ed18e14]	1360	{
	1361	va_list args;
	1362	int rc;
	1363
	1364	va_start(args, fmt);
[5a6c28d1]	1365	rc = vfscanf(f, fmt, args);
[ed18e14]	1366	va_end(args);
	1367
	1368	return rc;
	1369	}
	1370
[5a6c28d1]	1371	int vscanf(const char *fmt, va_list ap)
[f47a905]	1372	{
[5a6c28d1]	1373	return vfscanf(stdin, fmt, ap);
[f47a905]	1374	}
	1375
[5a6c28d1]	1376	int scanf(const char *fmt, ...)
[ed18e14]	1377	{
	1378	va_list args;
	1379	int rc;
	1380
	1381	va_start(args, fmt);
[5a6c28d1]	1382	rc = vscanf(fmt, args);
[ed18e14]	1383	va_end(args);
	1384
	1385	return rc;
	1386	}
[f47a905]	1387
	1388	/** @}
	1389	*/

Note: See TracBrowser for help on using the repository browser.

Download in other formats: