xref: /illumos-gate/usr/src/boot/lib/libstand/printf.c (revision 8eef2ab6)
14c528395SToomas Soome /*
2199767f8SToomas Soome  * Copyright (c) 1986, 1988, 1991, 1993
3199767f8SToomas Soome  *	The Regents of the University of California.  All rights reserved.
4199767f8SToomas Soome  * (c) UNIX System Laboratories, Inc.
5199767f8SToomas Soome  * All or some portions of this file are derived from material licensed
6199767f8SToomas Soome  * to the University of California by American Telephone and Telegraph
7199767f8SToomas Soome  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8199767f8SToomas Soome  * the permission of UNIX System Laboratories, Inc.
9199767f8SToomas Soome  *
10199767f8SToomas Soome  * Redistribution and use in source and binary forms, with or without
11199767f8SToomas Soome  * modification, are permitted provided that the following conditions
12199767f8SToomas Soome  * are met:
13199767f8SToomas Soome  * 1. Redistributions of source code must retain the above copyright
14199767f8SToomas Soome  *    notice, this list of conditions and the following disclaimer.
15199767f8SToomas Soome  * 2. Redistributions in binary form must reproduce the above copyright
16199767f8SToomas Soome  *    notice, this list of conditions and the following disclaimer in the
17199767f8SToomas Soome  *    documentation and/or other materials provided with the distribution.
181974da4bSToomas Soome  * 3. Neither the name of the University nor the names of its contributors
19199767f8SToomas Soome  *    may be used to endorse or promote products derived from this software
20199767f8SToomas Soome  *    without specific prior written permission.
21199767f8SToomas Soome  *
22199767f8SToomas Soome  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23199767f8SToomas Soome  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24199767f8SToomas Soome  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25199767f8SToomas Soome  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26199767f8SToomas Soome  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27199767f8SToomas Soome  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28199767f8SToomas Soome  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29199767f8SToomas Soome  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30199767f8SToomas Soome  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31199767f8SToomas Soome  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32199767f8SToomas Soome  * SUCH DAMAGE.
33199767f8SToomas Soome  *
34199767f8SToomas Soome  *	@(#)subr_prf.c	8.3 (Berkeley) 1/21/94
35199767f8SToomas Soome  */
36199767f8SToomas Soome 
37199767f8SToomas Soome #include <sys/cdefs.h>
38199767f8SToomas Soome 
39199767f8SToomas Soome /*
40199767f8SToomas Soome  * Standaloneified version of the FreeBSD kernel printf family.
41199767f8SToomas Soome  */
42199767f8SToomas Soome 
43199767f8SToomas Soome #include <sys/types.h>
44199767f8SToomas Soome #include <sys/stddef.h>
45199767f8SToomas Soome #include <sys/stdint.h>
46199767f8SToomas Soome #include <limits.h>
47199767f8SToomas Soome #include <string.h>
48199767f8SToomas Soome #include "stand.h"
49199767f8SToomas Soome 
50199767f8SToomas Soome /*
51199767f8SToomas Soome  * Note that stdarg.h and the ANSI style va_start macro is used for both
52199767f8SToomas Soome  * ANSI and traditional C compilers.
53199767f8SToomas Soome  */
54199767f8SToomas Soome #include <machine/stdarg.h>
55199767f8SToomas Soome 
564c528395SToomas Soome #define	MAXNBUF (sizeof (intmax_t) * CHAR_BIT + 1)
57199767f8SToomas Soome 
58199767f8SToomas Soome typedef void (kvprintf_fn_t)(int, void *);
59199767f8SToomas Soome 
604c528395SToomas Soome static char *ksprintn(char *, uintmax_t, int, int *, int);
614c528395SToomas Soome static int kvprintf(char const *, kvprintf_fn_t *, void *, int, va_list);
62199767f8SToomas Soome 
63199767f8SToomas Soome static void
putchar_wrapper(int cc,void * arg __unused)64*8eef2ab6SToomas Soome putchar_wrapper(int cc, void *arg __unused)
65199767f8SToomas Soome {
66199767f8SToomas Soome 
67199767f8SToomas Soome 	putchar(cc);
68199767f8SToomas Soome }
69199767f8SToomas Soome 
70199767f8SToomas Soome int
printf(const char * fmt,...)71199767f8SToomas Soome printf(const char *fmt, ...)
72199767f8SToomas Soome {
73199767f8SToomas Soome 	va_list ap;
74199767f8SToomas Soome 	int retval;
75199767f8SToomas Soome 
76199767f8SToomas Soome 	va_start(ap, fmt);
77199767f8SToomas Soome 	retval = kvprintf(fmt, putchar_wrapper, NULL, 10, ap);
78199767f8SToomas Soome 	va_end(ap);
794c528395SToomas Soome 	return (retval);
80199767f8SToomas Soome }
81199767f8SToomas Soome 
82199767f8SToomas Soome void
vprintf(const char * fmt,va_list ap)83199767f8SToomas Soome vprintf(const char *fmt, va_list ap)
84199767f8SToomas Soome {
85199767f8SToomas Soome 
86199767f8SToomas Soome 	kvprintf(fmt, putchar_wrapper, NULL, 10, ap);
87199767f8SToomas Soome }
88199767f8SToomas Soome 
89199767f8SToomas Soome int
sprintf(char * buf,const char * cfmt,...)90199767f8SToomas Soome sprintf(char *buf, const char *cfmt, ...)
91199767f8SToomas Soome {
92199767f8SToomas Soome 	int retval;
93199767f8SToomas Soome 	va_list ap;
94199767f8SToomas Soome 
95199767f8SToomas Soome 	va_start(ap, cfmt);
96199767f8SToomas Soome 	retval = kvprintf(cfmt, NULL, (void *)buf, 10, ap);
97199767f8SToomas Soome 	buf[retval] = '\0';
98199767f8SToomas Soome 	va_end(ap);
994c528395SToomas Soome 	return (retval);
100199767f8SToomas Soome }
101199767f8SToomas Soome 
102199767f8SToomas Soome struct print_buf {
103199767f8SToomas Soome 	char *buf;
104199767f8SToomas Soome 	size_t size;
105199767f8SToomas Soome };
106199767f8SToomas Soome 
107199767f8SToomas Soome static void
snprint_func(int ch,void * arg)108199767f8SToomas Soome snprint_func(int ch, void *arg)
109199767f8SToomas Soome {
110199767f8SToomas Soome 	struct print_buf *pbuf = arg;
111199767f8SToomas Soome 
112199767f8SToomas Soome 	if (pbuf->size < 2) {
113199767f8SToomas Soome 		/*
114199767f8SToomas Soome 		 * Reserve last buffer position for the terminating
115199767f8SToomas Soome 		 * character:
116199767f8SToomas Soome 		 */
117199767f8SToomas Soome 		return;
118199767f8SToomas Soome 	}
119199767f8SToomas Soome 	*(pbuf->buf)++ = ch;
120199767f8SToomas Soome 	pbuf->size--;
121199767f8SToomas Soome }
122199767f8SToomas Soome 
1236ea3a31bSToomas Soome int
asprintf(char ** buf,const char * cfmt,...)1246ea3a31bSToomas Soome asprintf(char **buf, const char *cfmt, ...)
1256ea3a31bSToomas Soome {
1266ea3a31bSToomas Soome 	int retval;
1276ea3a31bSToomas Soome 	struct print_buf arg;
1286ea3a31bSToomas Soome 	va_list ap;
1296ea3a31bSToomas Soome 
1306ea3a31bSToomas Soome 	*buf = NULL;
1316ea3a31bSToomas Soome 	va_start(ap, cfmt);
1326ea3a31bSToomas Soome 	retval = kvprintf(cfmt, NULL, NULL, 10, ap);
1336ea3a31bSToomas Soome 	va_end(ap);
1346ea3a31bSToomas Soome 	if (retval <= 0)
1356ea3a31bSToomas Soome 		return (-1);
1366ea3a31bSToomas Soome 
1376ea3a31bSToomas Soome 	arg.size = retval + 1;
1386ea3a31bSToomas Soome 	arg.buf = *buf = malloc(arg.size);
1396ea3a31bSToomas Soome 	if (*buf == NULL)
1406ea3a31bSToomas Soome 		return (-1);
1416ea3a31bSToomas Soome 
1426ea3a31bSToomas Soome 	va_start(ap, cfmt);
1436ea3a31bSToomas Soome 	retval = kvprintf(cfmt, &snprint_func, &arg, 10, ap);
1446ea3a31bSToomas Soome 	va_end(ap);
1456ea3a31bSToomas Soome 
1466ea3a31bSToomas Soome 	if (arg.size >= 1)
1476ea3a31bSToomas Soome 		*(arg.buf)++ = 0;
1486ea3a31bSToomas Soome 	return (retval);
1496ea3a31bSToomas Soome }
1506ea3a31bSToomas Soome 
151199767f8SToomas Soome int
snprintf(char * buf,size_t size,const char * cfmt,...)152199767f8SToomas Soome snprintf(char *buf, size_t size, const char *cfmt, ...)
153199767f8SToomas Soome {
154199767f8SToomas Soome 	int retval;
155199767f8SToomas Soome 	va_list ap;
156199767f8SToomas Soome 	struct print_buf arg;
157199767f8SToomas Soome 
158199767f8SToomas Soome 	arg.buf = buf;
159199767f8SToomas Soome 	arg.size = size;
160199767f8SToomas Soome 
161199767f8SToomas Soome 	va_start(ap, cfmt);
162199767f8SToomas Soome 	retval = kvprintf(cfmt, &snprint_func, &arg, 10, ap);
163199767f8SToomas Soome 	va_end(ap);
164199767f8SToomas Soome 
165199767f8SToomas Soome 	if (arg.size >= 1)
166199767f8SToomas Soome 		*(arg.buf)++ = 0;
1674c528395SToomas Soome 	return (retval);
168199767f8SToomas Soome }
169199767f8SToomas Soome 
170199767f8SToomas Soome void
vsprintf(char * buf,const char * cfmt,va_list ap)171199767f8SToomas Soome vsprintf(char *buf, const char *cfmt, va_list ap)
172199767f8SToomas Soome {
173199767f8SToomas Soome 	int	retval;
1744c528395SToomas Soome 
175199767f8SToomas Soome 	retval = kvprintf(cfmt, NULL, (void *)buf, 10, ap);
176199767f8SToomas Soome 	buf[retval] = '\0';
177199767f8SToomas Soome }
178199767f8SToomas Soome 
179199767f8SToomas Soome void
vsnprintf(char * buf,size_t size,const char * cfmt,va_list ap)180199767f8SToomas Soome vsnprintf(char *buf, size_t size, const char *cfmt, va_list ap)
181199767f8SToomas Soome {
182199767f8SToomas Soome 	int	retval;
183199767f8SToomas Soome 	struct print_buf arg;
184199767f8SToomas Soome 
185199767f8SToomas Soome 	arg.buf = buf;
186199767f8SToomas Soome 	arg.size = size;
187199767f8SToomas Soome 
188199767f8SToomas Soome 	retval = kvprintf(cfmt, &snprint_func, &arg, 10, ap);
189199767f8SToomas Soome 	buf[retval] = '\0';
190199767f8SToomas Soome }
191199767f8SToomas Soome 
192199767f8SToomas Soome /*
193199767f8SToomas Soome  * Put a NUL-terminated ASCII number (base <= 36) in a buffer in reverse
194199767f8SToomas Soome  * order; return an optional length and a pointer to the last character
195199767f8SToomas Soome  * written in the buffer (i.e., the first character of the string).
196199767f8SToomas Soome  * The buffer pointed to by `nbuf' must have length >= MAXNBUF.
197199767f8SToomas Soome  */
198199767f8SToomas Soome static char *
ksprintn(char * nbuf,uintmax_t num,int base,int * lenp,int upper)199199767f8SToomas Soome ksprintn(char *nbuf, uintmax_t num, int base, int *lenp, int upper)
200199767f8SToomas Soome {
201199767f8SToomas Soome 	char *p, c;
202199767f8SToomas Soome 
203199767f8SToomas Soome 	p = nbuf;
204199767f8SToomas Soome 	*p = '\0';
205199767f8SToomas Soome 	do {
206199767f8SToomas Soome 		c = hex2ascii(num % base);
207199767f8SToomas Soome 		*++p = upper ? toupper(c) : c;
208199767f8SToomas Soome 	} while (num /= base);
209199767f8SToomas Soome 	if (lenp)
210199767f8SToomas Soome 		*lenp = p - nbuf;
211199767f8SToomas Soome 	return (p);
212199767f8SToomas Soome }
213199767f8SToomas Soome 
214199767f8SToomas Soome /*
215199767f8SToomas Soome  * Scaled down version of printf(3).
216199767f8SToomas Soome  *
217199767f8SToomas Soome  * Two additional formats:
218199767f8SToomas Soome  *
219199767f8SToomas Soome  * The format %b is supported to decode error registers.
220199767f8SToomas Soome  * Its usage is:
221199767f8SToomas Soome  *
222199767f8SToomas Soome  *	printf("reg=%b\n", regval, "<base><arg>*");
223199767f8SToomas Soome  *
224199767f8SToomas Soome  * where <base> is the output base expressed as a control character, e.g.
225199767f8SToomas Soome  * \10 gives octal; \20 gives hex.  Each arg is a sequence of characters,
226199767f8SToomas Soome  * the first of which gives the bit number to be inspected (origin 1), and
227199767f8SToomas Soome  * the next characters (up to a control character, i.e. a character <= 32),
228199767f8SToomas Soome  * give the name of the register.  Thus:
229199767f8SToomas Soome  *
230199767f8SToomas Soome  *	kvprintf("reg=%b\n", 3, "\10\2BITTWO\1BITONE");
231199767f8SToomas Soome  *
232199767f8SToomas Soome  * would produce output:
233199767f8SToomas Soome  *
234199767f8SToomas Soome  *	reg=3<BITTWO,BITONE>
235199767f8SToomas Soome  *
236199767f8SToomas Soome  * XXX:  %D  -- Hexdump, takes pointer and separator string:
237199767f8SToomas Soome  *		("%6D", ptr, ":")   -> XX:XX:XX:XX:XX:XX
238199767f8SToomas Soome  *		("%*D", len, ptr, " " -> XX XX XX XX ...
239199767f8SToomas Soome  */
240199767f8SToomas Soome static int
kvprintf(char const * fmt,kvprintf_fn_t * func,void * arg,int radix,va_list ap)241199767f8SToomas Soome kvprintf(char const *fmt, kvprintf_fn_t *func, void *arg, int radix, va_list ap)
242199767f8SToomas Soome {
2436ea3a31bSToomas Soome #define	PCHAR(c) { \
2446ea3a31bSToomas Soome 	int cc = (c);				\
2456ea3a31bSToomas Soome 						\
2466ea3a31bSToomas Soome 	if (func) {				\
2476ea3a31bSToomas Soome 		(*func)(cc, arg);		\
2486ea3a31bSToomas Soome 	} else if (d != NULL) {			\
2496ea3a31bSToomas Soome 		*d++ = cc;			\
2506ea3a31bSToomas Soome 	}					\
2516ea3a31bSToomas Soome 	retval++;				\
2526ea3a31bSToomas Soome 	}
2536ea3a31bSToomas Soome 
254199767f8SToomas Soome 	char nbuf[MAXNBUF];
255199767f8SToomas Soome 	char *d;
256199767f8SToomas Soome 	const char *p, *percent, *q;
257cfba4bc6SToomas Soome 	uint16_t *S;
2584c528395SToomas Soome 	uchar_t *up;
259199767f8SToomas Soome 	int ch, n;
260199767f8SToomas Soome 	uintmax_t num;
261199767f8SToomas Soome 	int base, lflag, qflag, tmp, width, ladjust, sharpflag, neg, sign, dot;
262199767f8SToomas Soome 	int cflag, hflag, jflag, tflag, zflag;
263199767f8SToomas Soome 	int dwidth, upper;
264199767f8SToomas Soome 	char padc;
265199767f8SToomas Soome 	int stop = 0, retval = 0;
266199767f8SToomas Soome 
267199767f8SToomas Soome 	num = 0;
268199767f8SToomas Soome 	if (!func)
2694c528395SToomas Soome 		d = (char *)arg;
270199767f8SToomas Soome 	else
271199767f8SToomas Soome 		d = NULL;
272199767f8SToomas Soome 
273199767f8SToomas Soome 	if (fmt == NULL)
274199767f8SToomas Soome 		fmt = "(fmt null)\n";
275199767f8SToomas Soome 
276199767f8SToomas Soome 	if (radix < 2 || radix > 36)
277199767f8SToomas Soome 		radix = 10;
278199767f8SToomas Soome 
279199767f8SToomas Soome 	for (;;) {
280199767f8SToomas Soome 		padc = ' ';
281199767f8SToomas Soome 		width = 0;
2824c528395SToomas Soome 		while ((ch = (uchar_t)*fmt++) != '%' || stop) {
283199767f8SToomas Soome 			if (ch == '\0')
284199767f8SToomas Soome 				return (retval);
285199767f8SToomas Soome 			PCHAR(ch);
286199767f8SToomas Soome 		}
287199767f8SToomas Soome 		percent = fmt - 1;
288199767f8SToomas Soome 		qflag = 0; lflag = 0; ladjust = 0; sharpflag = 0; neg = 0;
289199767f8SToomas Soome 		sign = 0; dot = 0; dwidth = 0; upper = 0;
290199767f8SToomas Soome 		cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0;
2914c528395SToomas Soome reswitch:	switch (ch = (uchar_t)*fmt++) {
292199767f8SToomas Soome 		case '.':
293199767f8SToomas Soome 			dot = 1;
294199767f8SToomas Soome 			goto reswitch;
295199767f8SToomas Soome 		case '#':
296199767f8SToomas Soome 			sharpflag = 1;
297199767f8SToomas Soome 			goto reswitch;
298199767f8SToomas Soome 		case '+':
299199767f8SToomas Soome 			sign = 1;
300199767f8SToomas Soome 			goto reswitch;
301199767f8SToomas Soome 		case '-':
302199767f8SToomas Soome 			ladjust = 1;
303199767f8SToomas Soome 			goto reswitch;
304199767f8SToomas Soome 		case '%':
305199767f8SToomas Soome 			PCHAR(ch);
306199767f8SToomas Soome 			break;
307199767f8SToomas Soome 		case '*':
308199767f8SToomas Soome 			if (!dot) {
309199767f8SToomas Soome 				width = va_arg(ap, int);
310199767f8SToomas Soome 				if (width < 0) {
311199767f8SToomas Soome 					ladjust = !ladjust;
312199767f8SToomas Soome 					width = -width;
313199767f8SToomas Soome 				}
314199767f8SToomas Soome 			} else {
315199767f8SToomas Soome 				dwidth = va_arg(ap, int);
316199767f8SToomas Soome 			}
317199767f8SToomas Soome 			goto reswitch;
318199767f8SToomas Soome 		case '0':
319199767f8SToomas Soome 			if (!dot) {
320199767f8SToomas Soome 				padc = '0';
321199767f8SToomas Soome 				goto reswitch;
322199767f8SToomas Soome 			}
3234c528395SToomas Soome 			/* FALLTHROUGH */
324199767f8SToomas Soome 		case '1': case '2': case '3': case '4':
325199767f8SToomas Soome 		case '5': case '6': case '7': case '8': case '9':
3264c528395SToomas Soome 				for (n = 0; ; ++fmt) {
327199767f8SToomas Soome 					n = n * 10 + ch - '0';
328199767f8SToomas Soome 					ch = *fmt;
329199767f8SToomas Soome 					if (ch < '0' || ch > '9')
330199767f8SToomas Soome 						break;
331199767f8SToomas Soome 				}
332199767f8SToomas Soome 			if (dot)
333199767f8SToomas Soome 				dwidth = n;
334199767f8SToomas Soome 			else
335199767f8SToomas Soome 				width = n;
336199767f8SToomas Soome 			goto reswitch;
337199767f8SToomas Soome 		case 'b':
3384c528395SToomas Soome 			num = (uint_t)va_arg(ap, int);
339199767f8SToomas Soome 			p = va_arg(ap, char *);
3404c528395SToomas Soome 			for (q = ksprintn(nbuf, num, *p++, NULL, 0); *q; )
341199767f8SToomas Soome 				PCHAR(*q--);
342199767f8SToomas Soome 
343199767f8SToomas Soome 			if (num == 0)
344199767f8SToomas Soome 				break;
345199767f8SToomas Soome 
3464c528395SToomas Soome 			for (tmp = 0; *p; ) {
347199767f8SToomas Soome 				n = *p++;
348199767f8SToomas Soome 				if (num & (1 << (n - 1))) {
349199767f8SToomas Soome 					PCHAR(tmp ? ',' : '<');
350199767f8SToomas Soome 					for (; (n = *p) > ' '; ++p)
351199767f8SToomas Soome 						PCHAR(n);
352199767f8SToomas Soome 					tmp = 1;
353199767f8SToomas Soome 				} else
354199767f8SToomas Soome 					for (; *p > ' '; ++p)
355199767f8SToomas Soome 						continue;
356199767f8SToomas Soome 			}
357199767f8SToomas Soome 			if (tmp)
358199767f8SToomas Soome 				PCHAR('>');
359199767f8SToomas Soome 			break;
360199767f8SToomas Soome 		case 'c':
361199767f8SToomas Soome 			PCHAR(va_arg(ap, int));
362199767f8SToomas Soome 			break;
363199767f8SToomas Soome 		case 'D':
3644c528395SToomas Soome 			up = va_arg(ap, uchar_t *);
365199767f8SToomas Soome 			p = va_arg(ap, char *);
366199767f8SToomas Soome 			if (!width)
367199767f8SToomas Soome 				width = 16;
3684c528395SToomas Soome 			while (width--) {
369199767f8SToomas Soome 				PCHAR(hex2ascii(*up >> 4));
370199767f8SToomas Soome 				PCHAR(hex2ascii(*up & 0x0f));
371199767f8SToomas Soome 				up++;
372199767f8SToomas Soome 				if (width)
3734c528395SToomas Soome 					for (q = p; *q; q++)
374199767f8SToomas Soome 						PCHAR(*q);
375199767f8SToomas Soome 			}
376199767f8SToomas Soome 			break;
377199767f8SToomas Soome 		case 'd':
378199767f8SToomas Soome 		case 'i':
379199767f8SToomas Soome 			base = 10;
380199767f8SToomas Soome 			sign = 1;
381199767f8SToomas Soome 			goto handle_sign;
382199767f8SToomas Soome 		case 'h':
383199767f8SToomas Soome 			if (hflag) {
384199767f8SToomas Soome 				hflag = 0;
385199767f8SToomas Soome 				cflag = 1;
386199767f8SToomas Soome 			} else
387199767f8SToomas Soome 				hflag = 1;
388199767f8SToomas Soome 			goto reswitch;
389199767f8SToomas Soome 		case 'j':
390199767f8SToomas Soome 			jflag = 1;
391199767f8SToomas Soome 			goto reswitch;
392199767f8SToomas Soome 		case 'l':
393199767f8SToomas Soome 			if (lflag) {
394199767f8SToomas Soome 				lflag = 0;
395199767f8SToomas Soome 				qflag = 1;
396199767f8SToomas Soome 			} else
397199767f8SToomas Soome 				lflag = 1;
398199767f8SToomas Soome 			goto reswitch;
399199767f8SToomas Soome 		case 'n':
400199767f8SToomas Soome 			if (jflag)
401199767f8SToomas Soome 				*(va_arg(ap, intmax_t *)) = retval;
402199767f8SToomas Soome 			else if (qflag)
403199767f8SToomas Soome 				*(va_arg(ap, quad_t *)) = retval;
404199767f8SToomas Soome 			else if (lflag)
405199767f8SToomas Soome 				*(va_arg(ap, long *)) = retval;
406199767f8SToomas Soome 			else if (zflag)
407199767f8SToomas Soome 				*(va_arg(ap, size_t *)) = retval;
408199767f8SToomas Soome 			else if (hflag)
409199767f8SToomas Soome 				*(va_arg(ap, short *)) = retval;
410199767f8SToomas Soome 			else if (cflag)
411199767f8SToomas Soome 				*(va_arg(ap, char *)) = retval;
412199767f8SToomas Soome 			else
413199767f8SToomas Soome 				*(va_arg(ap, int *)) = retval;
414199767f8SToomas Soome 			break;
415199767f8SToomas Soome 		case 'o':
416199767f8SToomas Soome 			base = 8;
417199767f8SToomas Soome 			goto handle_nosign;
418199767f8SToomas Soome 		case 'p':
419199767f8SToomas Soome 			base = 16;
420199767f8SToomas Soome 			sharpflag = (width == 0);
421199767f8SToomas Soome 			sign = 0;
422199767f8SToomas Soome 			num = (uintptr_t)va_arg(ap, void *);
423199767f8SToomas Soome 			goto number;
424199767f8SToomas Soome 		case 'q':
425199767f8SToomas Soome 			qflag = 1;
426199767f8SToomas Soome 			goto reswitch;
427199767f8SToomas Soome 		case 'r':
428199767f8SToomas Soome 			base = radix;
429199767f8SToomas Soome 			if (sign)
430199767f8SToomas Soome 				goto handle_sign;
431199767f8SToomas Soome 			goto handle_nosign;
432199767f8SToomas Soome 		case 's':
433199767f8SToomas Soome 			p = va_arg(ap, char *);
434199767f8SToomas Soome 			if (p == NULL)
435199767f8SToomas Soome 				p = "(null)";
436199767f8SToomas Soome 			if (!dot)
4374c528395SToomas Soome 				n = strlen(p);
438199767f8SToomas Soome 			else
439199767f8SToomas Soome 				for (n = 0; n < dwidth && p[n]; n++)
440199767f8SToomas Soome 					continue;
441199767f8SToomas Soome 
442199767f8SToomas Soome 			width -= n;
443199767f8SToomas Soome 
444199767f8SToomas Soome 			if (!ladjust && width > 0)
445199767f8SToomas Soome 				while (width--)
446199767f8SToomas Soome 					PCHAR(padc);
447199767f8SToomas Soome 			while (n--)
448199767f8SToomas Soome 				PCHAR(*p++);
449199767f8SToomas Soome 			if (ladjust && width > 0)
450199767f8SToomas Soome 				while (width--)
451199767f8SToomas Soome 					PCHAR(padc);
452199767f8SToomas Soome 			break;
453cfba4bc6SToomas Soome 		case 'S':	/* Assume console can cope with wide chars */
454cfba4bc6SToomas Soome 			S = va_arg(ap, uint16_t *);
455cfba4bc6SToomas Soome 			if (S == NULL)
456cfba4bc6SToomas Soome 				S = (uint16_t *)L"(null)";
457cfba4bc6SToomas Soome 			if (!dot) {
458cfba4bc6SToomas Soome 				for (n = 0; S[n] != 0; n++)
459cfba4bc6SToomas Soome 					continue;
460cfba4bc6SToomas Soome 			} else {
461cfba4bc6SToomas Soome 				for (n = 0; n < dwidth && S[n]; n++)
462cfba4bc6SToomas Soome 					continue;
463cfba4bc6SToomas Soome 			}
464cfba4bc6SToomas Soome 
465cfba4bc6SToomas Soome 			width -= n;
466cfba4bc6SToomas Soome 
467cfba4bc6SToomas Soome 			if (!ladjust && width > 0)
468cfba4bc6SToomas Soome 				while (width--)
469cfba4bc6SToomas Soome 					PCHAR(padc);
470cfba4bc6SToomas Soome 			while (n--)
471cfba4bc6SToomas Soome 				PCHAR(*S++);
472cfba4bc6SToomas Soome 			if (ladjust && width > 0)
473cfba4bc6SToomas Soome 				while (width--)
474cfba4bc6SToomas Soome 					PCHAR(padc);
475cfba4bc6SToomas Soome 			break;
476199767f8SToomas Soome 		case 't':
477199767f8SToomas Soome 			tflag = 1;
478199767f8SToomas Soome 			goto reswitch;
479199767f8SToomas Soome 		case 'u':
480199767f8SToomas Soome 			base = 10;
481199767f8SToomas Soome 			goto handle_nosign;
482199767f8SToomas Soome 		case 'X':
483199767f8SToomas Soome 			upper = 1;
4844c528395SToomas Soome 			/* FALLTHROUGH */
485199767f8SToomas Soome 		case 'x':
486199767f8SToomas Soome 			base = 16;
487199767f8SToomas Soome 			goto handle_nosign;
488199767f8SToomas Soome 		case 'y':
489199767f8SToomas Soome 			base = 16;
490199767f8SToomas Soome 			sign = 1;
491199767f8SToomas Soome 			goto handle_sign;
492199767f8SToomas Soome 		case 'z':
493199767f8SToomas Soome 			zflag = 1;
494199767f8SToomas Soome 			goto reswitch;
495199767f8SToomas Soome handle_nosign:
496199767f8SToomas Soome 			sign = 0;
497199767f8SToomas Soome 			if (jflag)
498199767f8SToomas Soome 				num = va_arg(ap, uintmax_t);
499199767f8SToomas Soome 			else if (qflag)
5004c528395SToomas Soome 				num = va_arg(ap, uint64_t);
501199767f8SToomas Soome 			else if (tflag)
502199767f8SToomas Soome 				num = va_arg(ap, ptrdiff_t);
503199767f8SToomas Soome 			else if (lflag)
5044c528395SToomas Soome 				num = va_arg(ap, ulong_t);
505199767f8SToomas Soome 			else if (zflag)
506199767f8SToomas Soome 				num = va_arg(ap, size_t);
507199767f8SToomas Soome 			else if (hflag)
5084c528395SToomas Soome 				num = (ushort_t)va_arg(ap, int);
509199767f8SToomas Soome 			else if (cflag)
5104c528395SToomas Soome 				num = (uchar_t)va_arg(ap, int);
511199767f8SToomas Soome 			else
5124c528395SToomas Soome 				num = va_arg(ap, uint_t);
513199767f8SToomas Soome 			goto number;
514199767f8SToomas Soome handle_sign:
515199767f8SToomas Soome 			if (jflag)
516199767f8SToomas Soome 				num = va_arg(ap, intmax_t);
517199767f8SToomas Soome 			else if (qflag)
518199767f8SToomas Soome 				num = va_arg(ap, quad_t);
519199767f8SToomas Soome 			else if (tflag)
520199767f8SToomas Soome 				num = va_arg(ap, ptrdiff_t);
521199767f8SToomas Soome 			else if (lflag)
522199767f8SToomas Soome 				num = va_arg(ap, long);
523199767f8SToomas Soome 			else if (zflag)
524199767f8SToomas Soome 				num = va_arg(ap, ssize_t);
525199767f8SToomas Soome 			else if (hflag)
526199767f8SToomas Soome 				num = (short)va_arg(ap, int);
527199767f8SToomas Soome 			else if (cflag)
528199767f8SToomas Soome 				num = (char)va_arg(ap, int);
529199767f8SToomas Soome 			else
530199767f8SToomas Soome 				num = va_arg(ap, int);
531199767f8SToomas Soome number:
532199767f8SToomas Soome 			if (sign && (intmax_t)num < 0) {
533199767f8SToomas Soome 				neg = 1;
534199767f8SToomas Soome 				num = -(intmax_t)num;
535199767f8SToomas Soome 			}
536199767f8SToomas Soome 			p = ksprintn(nbuf, num, base, &n, upper);
537199767f8SToomas Soome 			tmp = 0;
538199767f8SToomas Soome 			if (sharpflag && num != 0) {
539199767f8SToomas Soome 				if (base == 8)
540199767f8SToomas Soome 					tmp++;
541199767f8SToomas Soome 				else if (base == 16)
542199767f8SToomas Soome 					tmp += 2;
543199767f8SToomas Soome 			}
544199767f8SToomas Soome 			if (neg)
545199767f8SToomas Soome 				tmp++;
546199767f8SToomas Soome 
547199767f8SToomas Soome 			if (!ladjust && padc == '0')
548199767f8SToomas Soome 				dwidth = width - tmp;
549199767f8SToomas Soome 			width -= tmp + imax(dwidth, n);
550199767f8SToomas Soome 			dwidth -= n;
551199767f8SToomas Soome 			if (!ladjust)
552199767f8SToomas Soome 				while (width-- > 0)
553199767f8SToomas Soome 					PCHAR(' ');
554199767f8SToomas Soome 			if (neg)
555199767f8SToomas Soome 				PCHAR('-');
556199767f8SToomas Soome 			if (sharpflag && num != 0) {
557199767f8SToomas Soome 				if (base == 8) {
558199767f8SToomas Soome 					PCHAR('0');
559199767f8SToomas Soome 				} else if (base == 16) {
560199767f8SToomas Soome 					PCHAR('0');
561199767f8SToomas Soome 					PCHAR('x');
562199767f8SToomas Soome 				}
563199767f8SToomas Soome 			}
564199767f8SToomas Soome 			while (dwidth-- > 0)
565199767f8SToomas Soome 				PCHAR('0');
566199767f8SToomas Soome 
567199767f8SToomas Soome 			while (*p)
568199767f8SToomas Soome 				PCHAR(*p--);
569199767f8SToomas Soome 
570199767f8SToomas Soome 			if (ladjust)
571199767f8SToomas Soome 				while (width-- > 0)
572199767f8SToomas Soome 					PCHAR(' ');
573199767f8SToomas Soome 
574199767f8SToomas Soome 			break;
575199767f8SToomas Soome 		default:
576199767f8SToomas Soome 			while (percent < fmt)
577199767f8SToomas Soome 				PCHAR(*percent++);
578199767f8SToomas Soome 			/*
579199767f8SToomas Soome 			 * Since we ignore a formatting argument it is no
580199767f8SToomas Soome 			 * longer safe to obey the remaining formatting
581199767f8SToomas Soome 			 * arguments as the arguments will no longer match
582199767f8SToomas Soome 			 * the format specs.
583199767f8SToomas Soome 			 */
584199767f8SToomas Soome 			stop = 1;
585199767f8SToomas Soome 			break;
586199767f8SToomas Soome 		}
587199767f8SToomas Soome 	}
588199767f8SToomas Soome #undef PCHAR
589199767f8SToomas Soome }
590