Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/printf/printf.c	Lines:	90	187	48.1 %
Date:	2017-11-07	Branches:	65	222	29.3 %


/*	$OpenBSD: printf.c,v 1.26 2016/11/18 15:53:16 schwarze Exp $	*/

/*
 * Copyright (c) 1989 The Regents of the University of California.
 * All rights reserved.
 *
 * 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. Neither the name of the University 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 REGENTS 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 REGENTS 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.
 */

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

static int	 print_escape_str(const char *);
static int	 print_escape(const char *);

static int	 getchr(void);
static double	 getdouble(void);
static int	 getint(void);
static long	 getlong(void);
static unsigned long getulong(void);
static char	*getstr(void);
static char	*mklong(const char *, int);
static void      check_conversion(const char *, const char *);
static void __dead usage(void);

static int	rval;
static char  **gargv;

#define isodigit(c)	((c) >= '0' && (c) <= '7')
#define octtobin(c)	((c) - '0')
#define hextobin(c)	((c) >= 'A' && (c) <= 'F' ? c - 'A' + 10 : (c) >= 'a' && (c) <= 'f' ? c - 'a' + 10 : c - '0')

#define PF(f, func) { \
	if (havefieldwidth) \
		if (haveprecision) \
			(void)printf(f, fieldwidth, precision, func); \
		else \
			(void)printf(f, fieldwidth, func); \
	else if (haveprecision) \
		(void)printf(f, precision, func); \
	else \
		(void)printf(f, func); \
}

int
main(int argc, char *argv[])
{
	char *fmt, *start;
	int havefieldwidth, haveprecision;
	int fieldwidth, precision;
	char convch, nextch;
	char *format;

	if (pledge("stdio flock rpath cpath wpath", NULL) == -1)
		err(1, "pledge");

	/* Need to accept/ignore "--" option. */
	if (argc > 1 && strcmp(argv[1], "--") == 0) {
		argc--;
		argv++;
	}

	if (argc < 2)
		usage();

	format = *++argv;
	gargv = ++argv;

#define SKIP1	"#-+ 0"
#define SKIP2	"0123456789"
	do {
		/*
		 * Basic algorithm is to scan the format string for conversion
		 * specifications -- once one is found, find out if the field
		 * width or precision is a '*'; if it is, gather up value.
		 * Note, format strings are reused as necessary to use up the
		 * provided arguments, arguments of zero/null string are
		 * provided to use up the format string.
		 */

		/* find next format specification */
		for (fmt = format; *fmt; fmt++) {
			switch (*fmt) {
			case '%':
				start = fmt++;

				if (*fmt == '%') {
					putchar ('%');
					break;
				} else if (*fmt == 'b') {
					char *p = getstr();
					if (print_escape_str(p)) {
						return (rval);
					}
					break;
				}

				/* skip to field width */
				for (; strchr(SKIP1, *fmt); ++fmt)
					;
				if (*fmt == '*') {
					++fmt;
					havefieldwidth = 1;
					fieldwidth = getint();
				} else
					havefieldwidth = 0;

				/* skip to field precision */
				for (; strchr(SKIP2, *fmt); ++fmt)
					;
				haveprecision = 0;
				if (*fmt == '.') {
					++fmt;
					if (*fmt == '*') {
						++fmt;
						haveprecision = 1;
						precision = getint();
					}
					for (; strchr(SKIP2, *fmt); ++fmt)
						;
				}

				if (!*fmt) {
					warnx ("missing format character");
					return(1);
				}

				convch = *fmt;
				nextch = *(fmt + 1);
				*(fmt + 1) = '\0';
				switch(convch) {
				case 'c': {
					char p = getchr();
					PF(start, p);
					break;
				}
				case 's': {
					char *p = getstr();
					PF(start, p);
					break;
				}
				case 'd':
				case 'i': {
					long p;
					char *f = mklong(start, convch);
					if (!f) {
						warnx("out of memory");
						return (1);
					}
					p = getlong();
					PF(f, p);
					break;
				}
				case 'o':
				case 'u':
				case 'x':
				case 'X': {
					unsigned long p;
					char *f = mklong(start, convch);
					if (!f) {
						warnx("out of memory");
						return (1);
					}
					p = getulong();
					PF(f, p);
					break;
				}
				case 'a':
				case 'A':
				case 'e':
				case 'E':
				case 'f':
				case 'F':
				case 'g':
				case 'G': {
					double p = getdouble();
					PF(start, p);
					break;
				}
				default:
					warnx ("%s: invalid directive", start);
					return(1);
				}
				*(fmt + 1) = nextch;
				break;

			case '\\':
				fmt += print_escape(fmt);
				break;

			default:
				putchar (*fmt);
				break;
			}
		}
	} while (gargv > argv && *gargv);

	return (rval);
}


/*
 * Print SysV echo(1) style escape string
 *	Halts processing string and returns 1 if a \c escape is encountered.
 */
static int
print_escape_str(const char *str)
{
	int value;
	int c;

	while (*str) {
		if (*str == '\\') {
			str++;
			/*
			 * %b string octal constants are not like those in C.
			 * They start with a \0, and are followed by 0, 1, 2,
			 * or 3 octal digits.
			 */
			if (*str == '0') {
				str++;
				for (c = 3, value = 0; c-- && isodigit(*str); str++) {
					value <<= 3;
					value += octtobin(*str);
				}
				putchar (value);
				str--;
			} else if (*str == 'c') {
				return 1;
			} else {
				str--;
				str += print_escape(str);
			}
		} else {
			putchar (*str);
		}
		str++;
	}

	return 0;
}

/*
 * Print "standard" escape characters
 */
static int
print_escape(const char *str)
{
	const char *start = str;
	int value;
	int c;

	str++;

	switch (*str) {
	case '0': case '1': case '2': case '3':
	case '4': case '5': case '6': case '7':
		for (c = 3, value = 0; c-- && isodigit(*str); str++) {
			value <<= 3;
			value += octtobin(*str);
		}
		putchar(value);
		return str - start - 1;
		/* NOTREACHED */

	case 'x':
		str++;
		for (value = 0; isxdigit((unsigned char)*str); str++) {
			value <<= 4;
			value += hextobin(*str);
		}
		if (value > UCHAR_MAX) {
			warnx ("escape sequence out of range for character");
			rval = 1;
		}
		putchar (value);
		return str - start - 1;
		/* NOTREACHED */

	case '\\':			/* backslash */
		putchar('\\');
		break;

	case '\'':			/* single quote */
		putchar('\'');
		break;

	case '"':			/* double quote */
		putchar('"');
		break;

	case 'a':			/* alert */
		putchar('\a');
		break;

	case 'b':			/* backspace */
		putchar('\b');
		break;

	case 'e':			/* escape */
#ifdef __GNUC__
		putchar('\e');
#else
		putchar(033);
#endif
		break;

	case 'f':			/* form-feed */
		putchar('\f');
		break;

	case 'n':			/* newline */
		putchar('\n');
		break;

	case 'r':			/* carriage-return */
		putchar('\r');
		break;

	case 't':			/* tab */
		putchar('\t');
		break;

	case 'v':			/* vertical-tab */
		putchar('\v');
		break;

	case '\0':
		warnx("null escape sequence");
		rval = 1;
		return 0;

	default:
		putchar(*str);
		warnx("unknown escape sequence `\\%c'", *str);
		rval = 1;
	}

	return 1;
}

static char *
mklong(const char *str, int ch)
{
	static char *copy;
	static int copysize;
	int len;

	len = strlen(str) + 2;
	if (copysize < len) {
		char *newcopy;
		copysize = len + 256;

		newcopy = realloc(copy, copysize);
		if (newcopy == NULL) {
			copysize = 0;
			free(copy);
			copy = NULL;
			return (NULL);
		}
		copy = newcopy;
	}
	(void) memmove(copy, str, len - 3);
	copy[len - 3] = 'l';
	copy[len - 2] = ch;
	copy[len - 1] = '\0';
	return (copy);
}

static int
getchr(void)
{
	if (!*gargv)
		return((int)'\0');
	return((int)**gargv++);
}

static char *
getstr(void)
{
	if (!*gargv)
		return("");
	return(*gargv++);
}

static char *number = "+-.0123456789";
static int
getint(void)
{
	if (!*gargv)
		return(0);

	if (strchr(number, **gargv))
		return(atoi(*gargv++));

	return 0;
}

static long
getlong(void)
{
	long val;
	char *ep;

	if (!*gargv)
		return(0L);

	if (**gargv == '\"' || **gargv == '\'')
		return (unsigned char) *((*gargv++)+1);

	errno = 0;
	val = strtol (*gargv, &ep, 0);
	check_conversion(*gargv++, ep);
	return val;
}

static unsigned long
getulong(void)
{
	unsigned long val;
	char *ep;

	if (!*gargv)
		return(0UL);

	if (**gargv == '\"' || **gargv == '\'')
		return (unsigned char) *((*gargv++)+1);

	errno = 0;
	val = strtoul (*gargv, &ep, 0);
	check_conversion(*gargv++, ep);
	return val;
}

static double
getdouble(void)
{
	double val;
	char *ep;

	if (!*gargv)
		return(0.0);

	if (**gargv == '\"' || **gargv == '\'')
		return (unsigned char) *((*gargv++)+1);

	errno = 0;
	val = strtod (*gargv, &ep);
	check_conversion(*gargv++, ep);
	return val;
}

static void
check_conversion(const char *s, const char *ep)
{
	if (*ep) {
		if (ep == s)
			warnx ("%s: expected numeric value", s);
		else
			warnx ("%s: not completely converted", s);
		rval = 1;
	} else if (errno == ERANGE) {
		warnc(ERANGE, "%s", s);
		rval = 1;
	}
}

static void __dead
usage(void)
{
	(void)fprintf(stderr, "usage: printf format [argument ...]\n");
	exit(1);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: printf.c,v 1.26 2016/11/18 15:53:16 schwarze Exp $ */
2
3			/*
4			* Copyright (c) 1989 The Regents of the University of California.
5			* All rights reserved.
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. Neither the name of the University nor the names of its contributors
16			* may be used to endorse or promote products derived from this software
17			* without specific prior written permission.
18			*
19			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29			* SUCH DAMAGE.
30			*/
31
32			#include <ctype.h>
33			#include <err.h>
34			#include <errno.h>
35			#include <limits.h>
36			#include <stdio.h>
37			#include <stdlib.h>
38			#include <string.h>
39			#include <unistd.h>
40
41			static int print_escape_str(const char *);
42			static int print_escape(const char *);
43
44			static int getchr(void);
45			static double getdouble(void);
46			static int getint(void);
47			static long getlong(void);
48			static unsigned long getulong(void);
49			static char *getstr(void);
50			static char mklong(const char , int);
51			static void check_conversion(const char , const char );
52			static void __dead usage(void);
53
54			static int rval;
55			static char **gargv;
56
57			#define isodigit(c) ((c) >= '0' && (c) <= '7')
58			#define octtobin(c) ((c) - '0')
59			#define hextobin(c) ((c) >= 'A' && (c) <= 'F' ? c - 'A' + 10 : (c) >= 'a' && (c) <= 'f' ? c - 'a' + 10 : c - '0')
60
61			#define PF(f, func) { \
62			if (havefieldwidth) \
63			if (haveprecision) \
64			(void)printf(f, fieldwidth, precision, func); \
65			else \
66			(void)printf(f, fieldwidth, func); \
67			else if (haveprecision) \
68			(void)printf(f, precision, func); \
69			else \
70			(void)printf(f, func); \
71			}
72
73			int
74			main(int argc, char *argv[])
75			{
76			char fmt, start;
77			int havefieldwidth, haveprecision;
78			int fieldwidth, precision;
79			char convch, nextch;
80			char *format;
81
82	✗✓	8838	if (pledge("stdio flock rpath cpath wpath", NULL) == -1)
83			err(1, "pledge");
84
85			/* Need to accept/ignore "--" option. */
86	✓✗✗✓	8838	if (argc > 1 && strcmp(argv[1], "--") == 0) {
87			argc--;
88			argv++;
89			}
90
91	✗✓	4419	if (argc < 2)
92			usage();
93
94		4419	format = *++argv;
95		4419	gargv = ++argv;
96
97			#define SKIP1 "#-+ 0"
98			#define SKIP2 "0123456789"
99		4419	do {
100			/*
101			* Basic algorithm is to scan the format string for conversion
102			* specifications -- once one is found, find out if the field
103			* width or precision is a '*'; if it is, gather up value.
104			* Note, format strings are reused as necessary to use up the
105			* provided arguments, arguments of zero/null string are
106			* provided to use up the format string.
107			*/
108
109			/* find next format specification */
110	✓✓	200944	for (fmt = format; *fmt; fmt++) {
111	✓✓✓	96053	switch (*fmt) {
112			case '%':
113		2181	start = fmt++;
114
115	✓✓	2181	if (*fmt == '%') {
116	✓✗	28	putchar ('%');
117			break;
118	✗✓	2167	} else if (*fmt == 'b') {
119			char *p = getstr();
120			if (print_escape_str(p)) {
121			return (rval);
122			}
123			break;
124			}
125
126			/* skip to field width */
127	✓✓	2351	for (; strchr(SKIP1, *fmt); ++fmt)
128			;
129	✗✓	2167	if (fmt == '') {
130			++fmt;
131			havefieldwidth = 1;
132			fieldwidth = getint();
133			} else
134			havefieldwidth = 0;
135
136			/* skip to field precision */
137	✓✓	4393	for (; strchr(SKIP2, *fmt); ++fmt)
138			;
139			haveprecision = 0;
140	✓✓	2167	if (*fmt == '.') {
141		476	++fmt;
142	✗✓	476	if (fmt == '') {
143			++fmt;
144			haveprecision = 1;
145			precision = getint();
146			}
147	✓✓	2380	for (; strchr(SKIP2, *fmt); ++fmt)
148			;
149			}
150
151	✗✓	2167	if (!*fmt) {
152			warnx ("missing format character");
153			return(1);
154			}
155
156			convch = *fmt;
157		2167	nextch = *(fmt + 1);
158		2167	*(fmt + 1) = '\0';
159	✗✓✗✓ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗	2167	switch(convch) {
160			case 'c': {
161			char p = getchr();
162			PF(start, p);
163			break;
164			}
165			case 's': {
166		1044	char *p = getstr();
167	✗✓✗✗ ✗✓	3132	PF(start, p);
168			break;
169			}
170			case 'd':
171			case 'i': {
172			long p;
173		23	char *f = mklong(start, convch);
174	✗✓	23	if (!f) {
175			warnx("out of memory");
176			return (1);
177			}
178		23	p = getlong();
179	✗✓✗✗ ✗✓	69	PF(f, p);
180	✓✗	23	break;
181			}
182			case 'o':
183			case 'u':
184			case 'x':
185			case 'X': {
186			unsigned long p;
187		1100	char *f = mklong(start, convch);
188	✗✓	1100	if (!f) {
189			warnx("out of memory");
190			return (1);
191			}
192		1100	p = getulong();
193	✗✓✗✗ ✗✓	3300	PF(f, p);
194	✓✗	1100	break;
195			}
196			case 'a':
197			case 'A':
198			case 'e':
199			case 'E':
200			case 'f':
201			case 'F':
202			case 'g':
203			case 'G': {
204			double p = getdouble();
205			PF(start, p);
206			break;
207			}
208			default:
209			warnx ("%s: invalid directive", start);
210			return(1);
211			}
212		2167	*(fmt + 1) = nextch;
213		2167	break;
214
215			case '\\':
216		7859	fmt += print_escape(fmt);
217		7859	break;
218
219			default:
220	✓✗	172026	putchar (*fmt);
221			break;
222			}
223			}
224	✓✓✗✓	6110	} while (gargv > argv && *gargv);
225
226		4419	return (rval);
227		4419	}
228
229
230			/*
231			* Print SysV echo(1) style escape string
232			* Halts processing string and returns 1 if a \c escape is encountered.
233			*/
234			static int
235			print_escape_str(const char *str)
236			{
237			int value;
238			int c;
239
240			while (*str) {
241			if (*str == '\\') {
242			str++;
243			/*
244			* %b string octal constants are not like those in C.
245			* They start with a \0, and are followed by 0, 1, 2,
246			* or 3 octal digits.
247			*/
248			if (*str == '0') {
249			str++;
250			for (c = 3, value = 0; c-- && isodigit(*str); str++) {
251			value <<= 3;
252			value += octtobin(*str);
253			}
254			putchar (value);
255			str--;
256			} else if (*str == 'c') {
257			return 1;
258			} else {
259			str--;
260			str += print_escape(str);
261			}
262			} else {
263			putchar (*str);
264			}
265			str++;
266			}
267
268			return 0;
269			}
270
271			/*
272			* Print "standard" escape characters
273			*/
274			static int
275			print_escape(const char *str)
276			{
277			const char *start = str;
278			int value;
279			int c;
280
281		15718	str++;
282
283	✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗	7859	switch (*str) {
284			case '0': case '1': case '2': case '3':
285			case '4': case '5': case '6': case '7':
286	✓✗✓✗ ✓✓	952	for (c = 3, value = 0; c-- && isodigit(*str); str++) {
287		119	value <<= 3;
288		119	value += octtobin(*str);
289			}
290	✓✗	238	putchar(value);
291		119	return str - start - 1;
292			/* NOTREACHED */
293
294			case 'x':
295			str++;
296			for (value = 0; isxdigit((unsigned char)*str); str++) {
297			value <<= 4;
298			value += hextobin(*str);
299			}
300			if (value > UCHAR_MAX) {
301			warnx ("escape sequence out of range for character");
302			rval = 1;
303			}
304			putchar (value);
305			return str - start - 1;
306			/* NOTREACHED */
307
308			case '\\': /* backslash */
309	✓✗	700	putchar('\\');
310			break;
311
312			case '\'': /* single quote */
313			putchar('\'');
314			break;
315
316			case '"': /* double quote */
317			putchar('"');
318			break;
319
320			case 'a': /* alert */
321			putchar('\a');
322			break;
323
324			case 'b': /* backspace */
325			putchar('\b');
326			break;
327
328			case 'e': /* escape */
329			#ifdef __GNUC__
330			putchar('\e');
331			#else
332			putchar(033);
333			#endif
334			break;
335
336			case 'f': /* form-feed */
337			putchar('\f');
338			break;
339
340			case 'n': /* newline */
341	✓✗	12322	putchar('\n');
342			break;
343
344			case 'r': /* carriage-return */
345			putchar('\r');
346			break;
347
348			case 't': /* tab */
349	✓✗	2458	putchar('\t');
350			break;
351
352			case 'v': /* vertical-tab */
353			putchar('\v');
354			break;
355
356			case '\0':
357			warnx("null escape sequence");
358			rval = 1;
359			return 0;
360
361			default:
362			putchar(*str);
363			warnx("unknown escape sequence `\\%c'", *str);
364			rval = 1;
365			}
366
367		7740	return 1;
368		7859	}
369
370			static char *
371			mklong(const char *str, int ch)
372			{
373			static char *copy;
374			static int copysize;
375			int len;
376
377		2246	len = strlen(str) + 2;
378	✓✗	1123	if (copysize < len) {
379			char *newcopy;
380		1123	copysize = len + 256;
381
382		1123	newcopy = realloc(copy, copysize);
383	✗✓	1123	if (newcopy == NULL) {
384			copysize = 0;
385			free(copy);
386			copy = NULL;
387			return (NULL);
388			}
389		1123	copy = newcopy;
390	✓✗	1123	}
391		1123	(void) memmove(copy, str, len - 3);
392		1123	copy[len - 3] = 'l';
393		1123	copy[len - 2] = ch;
394		1123	copy[len - 1] = '\0';
395		1123	return (copy);
396		1123	}
397
398			static int
399			getchr(void)
400			{
401			if (!*gargv)
402			return((int)'\0');
403			return((int)**gargv++);
404			}
405
406			static char *
407			getstr(void)
408			{
409	✗✓	2088	if (!*gargv)
410			return("");
411		1044	return(*gargv++);
412		1044	}
413
414			static char *number = "+-.0123456789";
415			static int
416			getint(void)
417			{
418			if (!*gargv)
419			return(0);
420
421			if (strchr(number, **gargv))
422			return(atoi(*gargv++));
423
424			return 0;
425			}
426
427			static long
428			getlong(void)
429			{
430			long val;
431		46	char *ep;
432
433	✗✓	23	if (!*gargv)
434			return(0L);
435
436	✓✗✗✓	46	if (gargv == '\"' \|\| gargv == '\'')
437			return (unsigned char) ((gargv++)+1);
438
439		23	errno = 0;
440		23	val = strtol (*gargv, &ep, 0);
441		23	check_conversion(*gargv++, ep);
442		23	return val;
443		23	}
444
445			static unsigned long
446			getulong(void)
447			{
448			unsigned long val;
449		2200	char *ep;
450
451	✗✓	1100	if (!*gargv)
452			return(0UL);
453
454	✓✗✗✓	2200	if (gargv == '\"' \|\| gargv == '\'')
455			return (unsigned char) ((gargv++)+1);
456
457		1100	errno = 0;
458		1100	val = strtoul (*gargv, &ep, 0);
459		1100	check_conversion(*gargv++, ep);
460		1100	return val;
461		1100	}
462
463			static double
464			getdouble(void)
465			{
466			double val;
467			char *ep;
468
469			if (!*gargv)
470			return(0.0);
471
472			if (gargv == '\"' \|\| gargv == '\'')
473			return (unsigned char) ((gargv++)+1);
474
475			errno = 0;
476			val = strtod (*gargv, &ep);
477			check_conversion(*gargv++, ep);
478			return val;
479			}
480
481			static void
482			check_conversion(const char s, const char ep)
483			{
484	✗✓	2246	if (*ep) {
485			if (ep == s)
486			warnx ("%s: expected numeric value", s);
487			else
488			warnx ("%s: not completely converted", s);
489			rval = 1;
490	✗✓	1123	} else if (errno == ERANGE) {
491			warnc(ERANGE, "%s", s);
492			rval = 1;
493			}
494		1123	}
495
496			static void __dead
497			usage(void)
498			{
499			(void)fprintf(stderr, "usage: printf format [argument ...]\n");
500			exit(1);
501			}