[apple/libc.git] / gen / FreeBSD / fmtcheck.c

/*-
 * Copyright (c) 2000 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code was contributed to The NetBSD Foundation by Allen Briggs.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *        This product includes software developed by the NetBSD
 *        Foundation, Inc. and its contributors.
 * 4. Neither the name of The NetBSD Foundation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*	$NetBSD: fmtcheck.c,v 1.2 2000/11/01 01:17:20 briggs Exp $	*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD: src/lib/libc/gen/fmtcheck.c,v 1.7 2004/05/02 10:55:05 das Exp $");

#include <stdio.h>
#include <string.h>
#include <ctype.h>

__weak_reference(__fmtcheck, fmtcheck);

enum __e_fmtcheck_types {
	FMTCHECK_START,
	FMTCHECK_SHORT,
	FMTCHECK_INT,
	FMTCHECK_LONG,
	FMTCHECK_QUAD,
	FMTCHECK_PTRDIFFT,
	FMTCHECK_SIZET,
	FMTCHECK_SHORTPOINTER,
	FMTCHECK_INTPOINTER,
	FMTCHECK_LONGPOINTER,
	FMTCHECK_QUADPOINTER,
	FMTCHECK_PTRDIFFTPOINTER,
	FMTCHECK_SIZETPOINTER,
#ifndef NO_FLOATING_POINT
	FMTCHECK_DOUBLE,
	FMTCHECK_LONGDOUBLE,
#endif
	FMTCHECK_STRING,
	FMTCHECK_WIDTH,
	FMTCHECK_PRECISION,
	FMTCHECK_DONE,
	FMTCHECK_UNKNOWN
};
typedef enum __e_fmtcheck_types EFT;

#define RETURN(pf,f,r) do { \
			*(pf) = (f); \
			return r; \
		       } /*NOTREACHED*/ /*CONSTCOND*/ while (0)

static EFT
get_next_format_from_precision(const char **pf)
{
	int		sh, lg, quad, longdouble, ptrdifft, sizet;
	const char	*f;

	sh = lg = quad = longdouble = ptrdifft = sizet = 0;

	f = *pf;
	switch (*f) {
	case 'h':
		f++;
		sh = 1;
		break;
	case 'l':
		f++;
		if (!*f) RETURN(pf,f,FMTCHECK_UNKNOWN);
		if (*f == 'l') {
			f++;
			quad = 1;
		} else {
			lg = 1;
		}
		break;
	case 'q':
		f++;
		quad = 1;
		break;
	case 't':
		f++;
		ptrdifft = 1;
		break;
	case 'z':
		f++;
		sizet = 1;
		break;
	case 'L':
		f++;
		longdouble = 1;
		break;
	default:
		break;
	}
	if (!*f) RETURN(pf,f,FMTCHECK_UNKNOWN);
	if (strchr("diouxX", *f)) {
		if (longdouble)
			RETURN(pf,f,FMTCHECK_UNKNOWN);
		if (lg)
			RETURN(pf,f,FMTCHECK_LONG);
		if (quad)
			RETURN(pf,f,FMTCHECK_QUAD);
		if (ptrdifft)
			RETURN(pf,f,FMTCHECK_PTRDIFFT);
		if (sizet)
			RETURN(pf,f,FMTCHECK_SIZET);
		RETURN(pf,f,FMTCHECK_INT);
	}
	if (*f == 'n') {
		if (longdouble)
			RETURN(pf,f,FMTCHECK_UNKNOWN);
		if (sh)
			RETURN(pf,f,FMTCHECK_SHORTPOINTER);
		if (lg)
			RETURN(pf,f,FMTCHECK_LONGPOINTER);
		if (quad)
			RETURN(pf,f,FMTCHECK_QUADPOINTER);
		if (ptrdifft)
			RETURN(pf,f,FMTCHECK_PTRDIFFTPOINTER);
		if (sizet)
			RETURN(pf,f,FMTCHECK_SIZETPOINTER);
		RETURN(pf,f,FMTCHECK_INTPOINTER);
	}
	if (strchr("DOU", *f)) {
		if (sh + lg + quad + longdouble + ptrdifft + sizet)
			RETURN(pf,f,FMTCHECK_UNKNOWN);
		RETURN(pf,f,FMTCHECK_LONG);
	}
#ifndef NO_FLOATING_POINT
	if (strchr("aAeEfFgG", *f)) {
		if (longdouble)
			RETURN(pf,f,FMTCHECK_LONGDOUBLE);
		if (sh + lg + quad + ptrdifft + sizet)
			RETURN(pf,f,FMTCHECK_UNKNOWN);
		RETURN(pf,f,FMTCHECK_DOUBLE);
	}
#endif
	if (*f == 'c') {
		if (sh + lg + quad + longdouble + ptrdifft + sizet)
			RETURN(pf,f,FMTCHECK_UNKNOWN);
		RETURN(pf,f,FMTCHECK_INT);
	}
	if (*f == 's') {
		if (sh + lg + quad + longdouble + ptrdifft + sizet)
			RETURN(pf,f,FMTCHECK_UNKNOWN);
		RETURN(pf,f,FMTCHECK_STRING);
	}
	if (*f == 'p') {
		if (sh + lg + quad + longdouble + ptrdifft + sizet)
			RETURN(pf,f,FMTCHECK_UNKNOWN);
		RETURN(pf,f,FMTCHECK_LONG);
	}
	RETURN(pf,f,FMTCHECK_UNKNOWN);
	/*NOTREACHED*/
}

static EFT
get_next_format_from_width(const char **pf)
{
	const char	*f;

	f = *pf;
	if (*f == '.') {
		f++;
		if (*f == '*') {
			RETURN(pf,f,FMTCHECK_PRECISION);
		}
		/* eat any precision (empty is allowed) */
		while (isdigit(*f)) f++;
		if (!*f) RETURN(pf,f,FMTCHECK_UNKNOWN);
	}
	RETURN(pf,f,get_next_format_from_precision(pf));
	/*NOTREACHED*/
}

static EFT
get_next_format(const char **pf, EFT eft)
{
	int		infmt;
	const char	*f;

	if (eft == FMTCHECK_WIDTH) {
		(*pf)++;
		return get_next_format_from_width(pf);
	} else if (eft == FMTCHECK_PRECISION) {
		(*pf)++;
		return get_next_format_from_precision(pf);
	}

	f = *pf;
	infmt = 0;
	while (!infmt) {
		f = strchr(f, '%');
		if (f == NULL)
			RETURN(pf,f,FMTCHECK_DONE);
		f++;
		if (!*f)
			RETURN(pf,f,FMTCHECK_UNKNOWN);
		if (*f != '%')
			infmt = 1;
		else
			f++;
	}

	/* Eat any of the flags */
	while (*f && (strchr("#0- +", *f)))
		f++;

	if (*f == '*') {
		RETURN(pf,f,FMTCHECK_WIDTH);
	}
	/* eat any width */
	while (isdigit(*f)) f++;
	if (!*f) {
		RETURN(pf,f,FMTCHECK_UNKNOWN);
	}

	RETURN(pf,f,get_next_format_from_width(pf));
	/*NOTREACHED*/
}

__const char *
__fmtcheck(const char *f1, const char *f2)
{
	const char	*f1p, *f2p;
	EFT		f1t, f2t;

	if (!f1) return f2;
	
	f1p = f1;
	f1t = FMTCHECK_START;
	f2p = f2;
	f2t = FMTCHECK_START;
	while ((f1t = get_next_format(&f1p, f1t)) != FMTCHECK_DONE) {
		if (f1t == FMTCHECK_UNKNOWN)
			return f2;
		f2t = get_next_format(&f2p, f2t);
		if (f1t != f2t)
			return f2;
	}
	return f1;
}
Commit	Line	Data
9385eb3d A	1	/*-
	2	* Copyright (c) 2000 The NetBSD Foundation, Inc.
	3	* All rights reserved.
	4	*
	5	* This code was contributed to The NetBSD Foundation by Allen Briggs.
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions
	9	* are met:
	10	* 1. Redistributions of source code must retain the above copyright
	11	* notice, this list of conditions and the following disclaimer.
	12	* 2. Redistributions in binary form must reproduce the above copyright
	13	* notice, this list of conditions and the following disclaimer in the
	14	* documentation and/or other materials provided with the distribution.
	15	* 3. All advertising materials mentioning features or use of this software
	16	* must display the following acknowledgement:
	17	* This product includes software developed by the NetBSD
	18	* Foundation, Inc. and its contributors.
	19	* 4. Neither the name of The NetBSD Foundation nor the names of its
	20	* contributors may be used to endorse or promote products derived
	21	* from this software without specific prior written permission.
	22	*
	23	* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
	24	* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
	25	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	26	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
	27	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	28	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	29	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	30	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	31	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	32	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	33	* POSSIBILITY OF SUCH DAMAGE.
	34	*/
	35
	36	/* $NetBSD: fmtcheck.c,v 1.2 2000/11/01 01:17:20 briggs Exp $ */
	37	#include <sys/cdefs.h>
3d9156a7	38	__FBSDID("$FreeBSD: src/lib/libc/gen/fmtcheck.c,v 1.7 2004/05/02 10:55:05 das Exp $");
9385eb3d A	39
	40	#include <stdio.h>
	41	#include <string.h>
	42	#include <ctype.h>
	43
	44	__weak_reference(__fmtcheck, fmtcheck);
	45
	46	enum __e_fmtcheck_types {
	47	FMTCHECK_START,
	48	FMTCHECK_SHORT,
	49	FMTCHECK_INT,
	50	FMTCHECK_LONG,
	51	FMTCHECK_QUAD,
3d9156a7 A	52	FMTCHECK_PTRDIFFT,
3d9156a7 A	53	FMTCHECK_SIZET,
9385eb3d A	54	FMTCHECK_SHORTPOINTER,
	55	FMTCHECK_INTPOINTER,
	56	FMTCHECK_LONGPOINTER,
	57	FMTCHECK_QUADPOINTER,
3d9156a7 A	58	FMTCHECK_PTRDIFFTPOINTER,
	59	FMTCHECK_SIZETPOINTER,
	60	#ifndef NO_FLOATING_POINT
9385eb3d A	61	FMTCHECK_DOUBLE,
9385eb3d A	62	FMTCHECK_LONGDOUBLE,
3d9156a7	63	#endif
9385eb3d A	64	FMTCHECK_STRING,
	65	FMTCHECK_WIDTH,
	66	FMTCHECK_PRECISION,
	67	FMTCHECK_DONE,
	68	FMTCHECK_UNKNOWN
	69	};
	70	typedef enum __e_fmtcheck_types EFT;
	71
	72	#define RETURN(pf,f,r) do { \
	73	*(pf) = (f); \
	74	return r; \
	75	} /NOTREACHED/ /CONSTCOND/ while (0)
	76
	77	static EFT
	78	get_next_format_from_precision(const char **pf)
	79	{
3d9156a7	80	int sh, lg, quad, longdouble, ptrdifft, sizet;
9385eb3d A	81	const char *f;
9385eb3d A	82
3d9156a7	83	sh = lg = quad = longdouble = ptrdifft = sizet = 0;
9385eb3d A	84
	85	f = *pf;
	86	switch (*f) {
	87	case 'h':
	88	f++;
	89	sh = 1;
	90	break;
	91	case 'l':
	92	f++;
	93	if (!*f) RETURN(pf,f,FMTCHECK_UNKNOWN);
	94	if (*f == 'l') {
	95	f++;
	96	quad = 1;
	97	} else {
	98	lg = 1;
	99	}
	100	break;
	101	case 'q':
	102	f++;
	103	quad = 1;
	104	break;
3d9156a7 A	105	case 't':
	106	f++;
	107	ptrdifft = 1;
	108	break;
	109	case 'z':
	110	f++;
	111	sizet = 1;
	112	break;
9385eb3d A	113	case 'L':
	114	f++;
	115	longdouble = 1;
	116	break;
	117	default:
	118	break;
	119	}
	120	if (!*f) RETURN(pf,f,FMTCHECK_UNKNOWN);
	121	if (strchr("diouxX", *f)) {
	122	if (longdouble)
	123	RETURN(pf,f,FMTCHECK_UNKNOWN);
	124	if (lg)
	125	RETURN(pf,f,FMTCHECK_LONG);
	126	if (quad)
	127	RETURN(pf,f,FMTCHECK_QUAD);
3d9156a7 A	128	if (ptrdifft)
	129	RETURN(pf,f,FMTCHECK_PTRDIFFT);
	130	if (sizet)
	131	RETURN(pf,f,FMTCHECK_SIZET);
9385eb3d A	132	RETURN(pf,f,FMTCHECK_INT);
	133	}
	134	if (*f == 'n') {
	135	if (longdouble)
	136	RETURN(pf,f,FMTCHECK_UNKNOWN);
	137	if (sh)
	138	RETURN(pf,f,FMTCHECK_SHORTPOINTER);
	139	if (lg)
	140	RETURN(pf,f,FMTCHECK_LONGPOINTER);
	141	if (quad)
	142	RETURN(pf,f,FMTCHECK_QUADPOINTER);
3d9156a7 A	143	if (ptrdifft)
	144	RETURN(pf,f,FMTCHECK_PTRDIFFTPOINTER);
	145	if (sizet)
	146	RETURN(pf,f,FMTCHECK_SIZETPOINTER);
9385eb3d A	147	RETURN(pf,f,FMTCHECK_INTPOINTER);
	148	}
	149	if (strchr("DOU", *f)) {
3d9156a7	150	if (sh + lg + quad + longdouble + ptrdifft + sizet)
9385eb3d A	151	RETURN(pf,f,FMTCHECK_UNKNOWN);
	152	RETURN(pf,f,FMTCHECK_LONG);
	153	}
3d9156a7 A	154	#ifndef NO_FLOATING_POINT
3d9156a7 A	155	if (strchr("aAeEfFgG", *f)) {
9385eb3d A	156	if (longdouble)
9385eb3d A	157	RETURN(pf,f,FMTCHECK_LONGDOUBLE);
3d9156a7	158	if (sh + lg + quad + ptrdifft + sizet)
9385eb3d A	159	RETURN(pf,f,FMTCHECK_UNKNOWN);
	160	RETURN(pf,f,FMTCHECK_DOUBLE);
	161	}
3d9156a7	162	#endif
9385eb3d	163	if (*f == 'c') {
3d9156a7	164	if (sh + lg + quad + longdouble + ptrdifft + sizet)
9385eb3d A	165	RETURN(pf,f,FMTCHECK_UNKNOWN);
	166	RETURN(pf,f,FMTCHECK_INT);
	167	}
	168	if (*f == 's') {
3d9156a7	169	if (sh + lg + quad + longdouble + ptrdifft + sizet)
9385eb3d A	170	RETURN(pf,f,FMTCHECK_UNKNOWN);
	171	RETURN(pf,f,FMTCHECK_STRING);
	172	}
	173	if (*f == 'p') {
3d9156a7	174	if (sh + lg + quad + longdouble + ptrdifft + sizet)
9385eb3d A	175	RETURN(pf,f,FMTCHECK_UNKNOWN);
	176	RETURN(pf,f,FMTCHECK_LONG);
	177	}
	178	RETURN(pf,f,FMTCHECK_UNKNOWN);
	179	/NOTREACHED/
	180	}
	181
	182	static EFT
	183	get_next_format_from_width(const char **pf)
	184	{
	185	const char *f;
	186
	187	f = *pf;
	188	if (*f == '.') {
	189	f++;
	190	if (f == '') {
	191	RETURN(pf,f,FMTCHECK_PRECISION);
	192	}
	193	/* eat any precision (empty is allowed) */
	194	while (isdigit(*f)) f++;
	195	if (!*f) RETURN(pf,f,FMTCHECK_UNKNOWN);
	196	}
	197	RETURN(pf,f,get_next_format_from_precision(pf));
	198	/NOTREACHED/
	199	}
	200
	201	static EFT
	202	get_next_format(const char **pf, EFT eft)
	203	{
	204	int infmt;
	205	const char *f;
	206
	207	if (eft == FMTCHECK_WIDTH) {
	208	(*pf)++;
	209	return get_next_format_from_width(pf);
	210	} else if (eft == FMTCHECK_PRECISION) {
	211	(*pf)++;
	212	return get_next_format_from_precision(pf);
	213	}
	214
	215	f = *pf;
	216	infmt = 0;
	217	while (!infmt) {
	218	f = strchr(f, '%');
	219	if (f == NULL)
	220	RETURN(pf,f,FMTCHECK_DONE);
	221	f++;
	222	if (!*f)
	223	RETURN(pf,f,FMTCHECK_UNKNOWN);
	224	if (*f != '%')
	225	infmt = 1;
	226	else
	227	f++;
	228	}
	229
	230	/* Eat any of the flags */
	231	while (f && (strchr("#0- +", f)))
	232	f++;
	233
	234	if (f == '') {
	235	RETURN(pf,f,FMTCHECK_WIDTH);
	236	}
	237	/* eat any width */
	238	while (isdigit(*f)) f++;
239	if (!*f) {
240	RETURN(pf,f,FMTCHECK_UNKNOWN);
241	}
242
243	RETURN(pf,f,get_next_format_from_width(pf));
244	/NOTREACHED/
245	}
246
247	__const char *
248	__fmtcheck(const char f1, const char f2)
249	{
250	const char f1p, f2p;
251	EFT f1t, f2t;
252
253	if (!f1) return f2;
254
255	f1p = f1;
256	f1t = FMTCHECK_START;
257	f2p = f2;
258	f2t = FMTCHECK_START;
259	while ((f1t = get_next_format(&f1p, f1t)) != FMTCHECK_DONE) {
260	if (f1t == FMTCHECK_UNKNOWN)
261	return f2;
262	f2t = get_next_format(&f2p, f2t);
263	if (f1t != f2t)
264	return f2;
265	}
266	return f1;
267	}