xref: /illumos-gate/usr/src/lib/libc/port/print/doprnt.c (revision 2829495d)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*	Copyright (c) 1988 AT&T	*/
28 /*	  All Rights Reserved	*/
29 
30 /*
31  *	_doprnt: common code for printf, fprintf, sprintf
32  */
33 
34 #include "lint.h"
35 #include "mtlib.h"
36 #include "print.h"	/* parameters & macros for doprnt */
37 #include <wchar.h>
38 #include "libc.h"
39 #include <stdlib.h>
40 #include <limits.h>
41 #include <ctype.h>
42 #include <stdarg.h>
43 #include <values.h>
44 #include <memory.h>
45 #include <string.h>
46 #include <locale.h>
47 #include <widec.h>
48 #include "../i18n/_locale.h"
49 #include <errno.h>
50 #include <sys/types.h>
51 #include <libw.h>
52 #include "mse.h"
53 #include "xpg6.h"
54 
55 static const char nullstr[] = "(null)";
56 static const wchar_t widenullstr[] = L"(null)";
57 
58 #if defined(__i386) || defined(__amd64) || defined(__sparcv9)
59 #define	GETQVAL(arg)	(va_arg(arg, long double))
60 #else /* !defined(__i386) && !defined(__sparcv9) */
61 #define	GETQVAL(arg)	*(va_arg(arg, long double *))
62 #endif /* !defined(__i386) && !defined(__sparcv9) */
63 
64 #ifdef	_WIDE
65 #define	STRCHR	wcschr
66 #define	STRSPN	wcsspn
67 #define	ATOI(x)	_watoi((wchar_t *)x)
68 #define	_P_HYPHEN	L"-"
69 #define	_P_PLUS		L"+"
70 #define	_P_BLANK	L" "
71 #define	_P_ZEROx	L"0x"
72 #define	_P_ZEROX	L"0X"
73 #define	_M_ISDIGIT(c)	(((c) >= 0) && ((c) < 256) && isdigit((c)))
74 #define	_M_ISUPPER(c)	(((c) >= 0) && ((c) < 256) && isupper((c)))
75 #else  /* _WIDE */
76 #define	STRCHR	strchr
77 #define	STRSPN	strspn
78 #define	ATOI(x)	atoi(x)
79 #define	_P_HYPHEN	"-"
80 #define	_P_PLUS		"+"
81 #define	_P_BLANK	" "
82 #define	_P_ZEROx	"0x"
83 #define	_P_ZEROX	"0X"
84 #define	_M_ISDIGIT(c)	isdigit((c))
85 #define	_M_ISUPPER(c)	isupper((c))
86 #endif /* _WIDE */
87 
88 #ifdef	_WIDE
89 #define	PUT(p, n) \
90 	{ \
91 		int	retp; \
92 		retp = put_wide(iop, &bufptr, bufferend, p, n, sflag); \
93 		if (retp == EOF) { \
94 			return ((ssize_t)EOF); \
95 		} \
96 	}
97 
98 #define	PAD(s, n) \
99 	{ \
100 		int	retp; \
101 		retp = pad_wide(iop, &bufptr, bufferend, s, n, sflag); \
102 		if (retp == EOF) { \
103 			return ((ssize_t)EOF); \
104 		} \
105 	}
106 
107 #define	FPCONV(func, val, prec, decpt, sign, cvtbuf) \
108 	{ \
109 		char	cb[DECIMAL_STRING_LENGTH]; \
110 		wchar_t	*wp; \
111 		char	*cp; \
112 		(void) func(val, prec, decpt, sign, cb); \
113 		wp = cvtbuf; \
114 		cp = cb; \
115 		while (*cp) { \
116 			*wp++ = (wchar_t)*cp++; \
117 		} \
118 		*wp = L'\0'; \
119 	}
120 
121 #else  /* _WIDE */
122 #define	PUT(p, n)	\
123 	{\
124 		/*\
125 		 * When _doprnt() is called by [v]snprintf, we need to \
126 		 * always call _dowrite().  We also need to call _dowrite() \
127 		 * if the bufptr lies beyond the end of the buffer.  This \
128 		 * is possible due to known off-by-one errors in __flsbuf() \
129 		 * and _fwrite_unlocked().  See 1235867 and 1231720 for the \
130 		 * sordid details. \
131 		 */\
132 		if (snflag || bufptr > bufferend ||\
133 		    (unsigned long)(bufferend - bufptr) < (n)) {\
134 			if (!_dowrite(p, n, iop, &bufptr)) {\
135 				return (EOF);\
136 			}\
137 		} else {\
138 			unsigned char	*fbp = bufptr;\
139 			switch (n) {\
140 			case 4:\
141 				*fbp = *p;\
142 				*(fbp + 1) = *(p + 1);\
143 				*(fbp + 2) = *(p + 2);\
144 				*(fbp + 3) = *(p + 3);\
145 				bufptr += 4;\
146 				break;\
147 			case 3:\
148 				*fbp = *p;\
149 				*(fbp + 1) = *(p + 1);\
150 				*(fbp + 2) = *(p + 2);\
151 				bufptr += 3;\
152 				break;\
153 			case 2:\
154 				*fbp = *p;\
155 				*(fbp + 1) = *(p + 1);\
156 				bufptr += 2;\
157 				break;\
158 			case 1:\
159 				*bufptr++ = *p;\
160 				break;\
161 			default:\
162 				bufptr = (unsigned char *)memcpy(fbp, p, n)\
163 					+ (n);\
164 			}\
165 		}\
166 	}
167 
168 #define	PAD(s, n)    { ssize_t nn; \
169 			for (nn = n; nn > PAD_LEN; nn -= PAD_LEN) \
170 					if (!_dowrite(s, PAD_LEN, iop, &bufptr)) \
171 						return (EOF); \
172 			PUT(s, nn); \
173 		}
174 
175 #define	FPCONV(func, val, prec, decpt, sign, cvtbuf) \
176 		(void) func(val, prec, decpt, sign, cvtbuf);
177 
178 #endif /* _WIDE */
179 
180 /* bit positions for flags used in doprnt */
181 
182 #define	LENGTH	0x1	/* l */
183 #define	FPLUS	0x2	/* + */
184 #define	FMINUS	0x4	/* - */
185 #define	FBLANK	0x8	/* blank */
186 #define	FSHARP	0x10	/* # */
187 #define	PADZERO 0x20	/* padding zeroes requested via '0' */
188 #define	DOTSEEN 0x40	/* dot appeared in format specification */
189 #define	SUFFIX	0x80	/* a suffix is to appear in the output */
190 #define	RZERO	0x100	/* there will be trailing zeros in output */
191 #define	LZERO	0x200	/* there will be leading zeroes in output */
192 #define	SHORT   0x400	/* h */
193 #define	QUAD    0x800	/* Q for long double */
194 #define	XLONG   0x1000	/* ll for long long */
195 #define	CHAR    0x2000	/* hh for char */
196 
197 #ifdef	_WIDE
198 static wchar_t *insert_decimal_point(wchar_t *ep);
199 static wchar_t *insert_thousands_sep(wchar_t *bp, wchar_t *ep);
200 #else  /* _WIDE */
201 static char *insert_decimal_point(char *ep);
202 static char *insert_thousands_sep(char *bp, char *ep);
203 #endif /* _WIDE */
204 
205 static int	_rec_scrswidth(wchar_t *, ssize_t);
206 
207 /*
208  *	Positional Parameter information
209  */
210 #define	MAXARGS	30	/* max. number of args for fast positional paramters */
211 
212 static ssize_t
213 _dowrite(const char *p, ssize_t n, FILE *iop, unsigned char **ptrptr);
214 
215 /*
216  * stva_list is used to subvert C's restriction that a variable with an
217  * array type can not appear on the left hand side of an assignment operator.
218  * By putting the array inside a structure, the functionality of assigning to
219  * the whole array through a simple assignment is achieved..
220  */
221 typedef struct stva_list {
222 	va_list	ap;
223 } stva_list;
224 
225 #ifdef	_WIDE
226 static void _wmkarglst(wchar_t *, stva_list, stva_list [], int);
227 static void _wgetarg(wchar_t *, stva_list *, long, int);
228 #else  /* _WIDE */
229 static void _mkarglst(char *, stva_list, stva_list [], int);
230 void _getarg(char *, stva_list *, long, int);
231 #endif /* _WIDE */
232 
233 
234 
235 
236 static int
_lowdigit(ssize_t * valptr)237 _lowdigit(ssize_t *valptr)
238 {
239 	/* This function computes the decimal low-order digit of the number */
240 	/* pointed to by valptr, and returns this digit after dividing   */
241 	/* *valptr by ten.  This function is called ONLY to compute the */
242 	/* low-order digit of a long whose high-order bit is set. */
243 
244 	ssize_t lowbit = *valptr & 1;
245 	long value = (*valptr >> 1) & ~HIBITL;
246 
247 	*valptr = value / 5;
248 	value = value % 5 * 2 + lowbit + '0';
249 	return ((int)value);
250 }
251 
252 static int
_lowlldigit(long long * valptr)253 _lowlldigit(long long *valptr)
254 {
255 	ssize_t lowbit = *valptr & 1;
256 	long long value = (*valptr >> 1) & ~HIBITLL;
257 		*valptr = value / 5;
258 		value = value % 5 * 2 + lowbit + '0';
259 		return ((int)value);
260 }
261 
262 /* The function _dowrite carries out buffer pointer bookkeeping surrounding */
263 /* a call to fwrite.  It is called only when the end of the file output */
264 /* buffer is approached or in other unusual situations. */
265 
266 static ssize_t
_dowrite(const char * p,ssize_t n,FILE * iop,unsigned char ** ptrptr)267 _dowrite(const char *p, ssize_t n, FILE *iop, unsigned char **ptrptr)
268 {
269 	if (!(iop->_flag & _IOREAD)) {
270 		iop->_cnt -= (*ptrptr - iop->_ptr);
271 		iop->_ptr = *ptrptr;
272 		_bufsync(iop, _bufend(iop));
273 		if (_FWRITE(p, 1, n, iop) != n) {
274 			return (0);
275 		}
276 		*ptrptr = iop->_ptr;
277 	} else {
278 		if (n > iop->_cnt)
279 			n = iop->_cnt;
280 		iop->_cnt -= n;
281 		*ptrptr = (unsigned char *)memcpy((char *)*ptrptr, p, n) + n;
282 		iop->_ptr = *ptrptr;
283 	}
284 	return (1);
285 }
286 
287 #define	PAD_LEN	20
288 	static const char _blanks[] = "                    ";
289 	static const char _zeroes[] = "00000000000000000000";
290 #ifdef	_WIDE
291 	static const wchar_t uc_digs[] = L"0123456789ABCDEF";
292 	static const wchar_t lc_digs[] = L"0123456789abcdef";
293 #else /* _WIDE */
294 	static const char uc_digs[] = "0123456789ABCDEF";
295 	static const char lc_digs[] = "0123456789abcdef";
296 #endif /* _WIDE */
297 
298 #ifdef	_WIDE
299 static int
put_wide(FILE * iop,unsigned char ** bufptr,unsigned char * bufferend,wchar_t * p,size_t n,int sflag)300 put_wide(FILE *iop, unsigned char **bufptr,
301 	unsigned char *bufferend, wchar_t *p, size_t n,
302 	int sflag)
303 {
304 	unsigned char	*newbufptr;
305 	wchar_t	*q;
306 	int	r;
307 	size_t	len, i;
308 
309 	if (sflag) {
310 		len = (wchar_t *)bufferend - (wchar_t *)*bufptr;
311 		if (n > len) {
312 			(void) wmemcpy((wchar_t *)*bufptr, p, len);
313 			iop->_ptr = bufferend;
314 			return (EOF);
315 		} else {
316 			(void) wmemcpy((wchar_t *)*bufptr, p, n);
317 			*bufptr = (unsigned char *)((wchar_t *)*bufptr + n);
318 			return (0);
319 		}
320 	} else {
321 		char *tmpp, *tmpq;
322 		size_t tsize;
323 
324 		tsize = (n + 1) * MB_LEN_MAX;
325 		tmpp = lmalloc(tsize);
326 		if (tmpp == NULL) {
327 			errno = ENOMEM;
328 			return (EOF);
329 		}
330 		q = p;
331 		tmpq = tmpp;
332 		for (len = 0, i = 0; i < n; i++) {
333 			r = wctomb(tmpq, *q++);
334 			if (r == -1) {
335 				lfree(tmpp, tsize);
336 				errno = EILSEQ;
337 				return (EOF);
338 			}
339 			len += r;
340 			tmpq += r;
341 		}
342 		tmpq = tmpp;
343 		newbufptr = *bufptr + len;
344 		if (newbufptr > bufferend) {
345 			if (!_dowrite(tmpp, len, iop, bufptr)) {
346 				lfree(tmpp, tsize);
347 				return (EOF);
348 			}
349 		} else {
350 			(void) memcpy(*bufptr, tmpp, len);
351 			*bufptr = newbufptr;
352 		}
353 		lfree(tmpp, tsize);
354 		return (0);
355 	}
356 }
357 
358 static int
pad_wide(FILE * iop,unsigned char ** bufptr,unsigned char * bufferend,const char * s,size_t n,int sflag)359 pad_wide(FILE *iop, unsigned char **bufptr,
360 	unsigned char *bufferend, const char *s, size_t n,
361 	int sflag)
362 {
363 	unsigned char	*newbufptr;
364 	ssize_t	nn;
365 	size_t	len;
366 	wchar_t	ps;
367 
368 	if (sflag) {
369 		/* for swprintf */
370 		ps = (wchar_t)s[0];
371 		len = (wchar_t *)bufferend - (wchar_t *)*bufptr;
372 		if (n > len) {
373 			(void) wmemset((wchar_t *)*bufptr, ps, len);
374 			iop->_ptr = bufferend;
375 			return (EOF);
376 		} else {
377 			(void) wmemset((wchar_t *)*bufptr, ps, n);
378 			*bufptr = (unsigned char *)((wchar_t *)*bufptr + n);
379 			return (0);
380 		}
381 	} else {
382 		for (nn = n; nn > PAD_LEN; nn -= PAD_LEN) {
383 			if (!_dowrite(s, PAD_LEN, iop, bufptr))
384 				return (EOF);
385 		}
386 		newbufptr = *bufptr + nn;
387 		if (newbufptr > bufferend) {
388 			if (!_dowrite(s, nn, iop, bufptr))
389 				return (EOF);
390 		} else {
391 			(void) memcpy(*bufptr, s, nn);
392 			*bufptr = newbufptr;
393 		}
394 		return (0);
395 	}
396 }
397 #endif /* _WIDE */
398 
399 #ifdef	_WIDE
400 ssize_t
_wdoprnt(const wchar_t * format,va_list in_args,FILE * iop)401 _wdoprnt(const wchar_t *format, va_list in_args, FILE *iop)
402 {
403 	return (_wndoprnt(format, in_args, iop, 0));
404 }
405 #else	/* _WIDE */
406 ssize_t
_doprnt(const char * format,va_list in_args,FILE * iop)407 _doprnt(const char *format, va_list in_args, FILE *iop)
408 {
409 	return (_ndoprnt(format, in_args, iop, 0));
410 }
411 #endif	/* _WIDE */
412 
413 
414 #ifdef	_WIDE
415 ssize_t
_wndoprnt(const wchar_t * format,va_list in_args,FILE * iop,int prflag)416 _wndoprnt(const wchar_t *format, va_list in_args, FILE *iop, int prflag)
417 #else  /* _WIDE */
418 ssize_t
419 _ndoprnt(const char *format, va_list in_args, FILE *iop, int prflag)
420 #endif /* _WIDE */
421 {
422 
423 #ifdef	_WIDE
424 	int	sflag = 0;
425 	size_t	maxcount;
426 #else
427 	int	snflag = 0;
428 #endif /* _WIDE */
429 	/* bufptr is used inside of doprnt instead of iop->_ptr; */
430 	/* bufferend is a copy of _bufend(iop), if it exists.  For */
431 	/* dummy file descriptors (iop->_flag & _IOREAD), bufferend */
432 	/* may be meaningless. Dummy file descriptors are used so that */
433 	/* sprintf and vsprintf may share the _doprnt routine with the */
434 	/* rest of the printf family. */
435 
436 	unsigned char *bufptr;
437 	unsigned char *bufferend;
438 
439 #ifdef	_WIDE
440 	/* This variable counts output characters. */
441 	size_t	count = 0;
442 #else  /* _WIDE */
443 	/* This variable counts output characters. */
444 	int	count = 0;
445 #endif /* _WIDE */
446 
447 #ifdef	_WIDE
448 	wchar_t	*bp;
449 	size_t bpsize;
450 	wchar_t	*p;
451 	char	*cbp;
452 
453 #else  /* _WIDE */
454 	/* Starting and ending points for value to be printed */
455 	char	*bp;
456 	char *p;
457 #endif /* _WIDE */
458 	/* Field width and precision */
459 	int	prec = 0;
460 	ssize_t width;
461 	ssize_t num;
462 	wchar_t *wp;
463 	ssize_t preco;
464 	ssize_t wcount = 0;
465 	char tmpbuf[10];
466 	char wflag;
467 	char lflag;
468 	int quote;		/* ' */
469 	int	retcode;
470 
471 #ifdef	_WIDE
472 	/* Format code */
473 	wchar_t	fcode;
474 #else  /* _WIDE */
475 	/* Format code */
476 	char	fcode;
477 	ssize_t sec_display;
478 #endif /* _WIDE */
479 
480 	/* Number of padding zeroes required on the left and right */
481 	ssize_t	lzero, rzero, rz, leadzeroes;
482 
483 
484 	/* Flags - bit positions defined by LENGTH, FPLUS, FMINUS, FBLANK, */
485 	/* and FSHARP are set if corresponding character is in format */
486 	/* Bit position defined by PADZERO means extra space in the field */
487 	/* should be padded with leading zeroes rather than with blanks */
488 
489 	ssize_t	flagword;
490 
491 #ifdef	_WIDE
492 	/* Values are developed in this buffer */
493 	wchar_t	buf[max(MAXLLDIGS, 1034)];
494 	wchar_t	cvtbuf[512 + DECIMAL_STRING_LENGTH];
495 
496 	/* Pointer to sign, "0x", "0X", or empty */
497 	wchar_t	*prefix;
498 	wchar_t	prefixbuf[4];
499 
500 	/* Exponent or empty */
501 	wchar_t	*suffix;
502 
503 	/* Buffer to create exponent */
504 	wchar_t	expbuf[MAXESIZ + 1];
505 #else  /* _WIDE */
506 	/* Values are developed in this buffer */
507 	char	buf[max(MAXLLDIGS, 1034)];
508 	char	cvtbuf[512 + DECIMAL_STRING_LENGTH];
509 
510 	/* Pointer to sign, "0x", "0X", or empty */
511 	char	*prefix;
512 	char	prefixbuf[4];
513 
514 	/* Exponent or empty */
515 	char	*suffix;
516 
517 	/* Buffer to create exponent */
518 	char	expbuf[MAXESIZ + 1];
519 #endif /* _WIDE */
520 
521 	/* Length of prefix and of suffix */
522 	ssize_t	prefixlength, suffixlength;
523 
524 	/* Combined length of leading zeroes, trailing zeroes, and suffix */
525 	ssize_t	otherlength;
526 
527 	/* The value being converted, if integer */
528 	ssize_t	val;
529 
530 	/* The value being converted, if long long */
531 	long long ll = 0LL;
532 
533 	/* Output value from aconvert */
534 	int	exp;
535 
536 	/* Output values from fcvt and ecvt */
537 	int	decpt, sign;
538 
539 #ifdef	_WIDE
540 	/* Pointer to a translate table for digits of whatever radix */
541 	const wchar_t *tab;
542 #else  /* _WIDE */
543 	/* Pointer to a translate table for digits of whatever radix */
544 	const char *tab;
545 #endif /* _WIDE */
546 
547 	/* Work variables */
548 	ssize_t	k, lradix, mradix;
549 
550 	int	inf_nan = 0;
551 	int	inf_nan_mixed_case = 0;
552 
553 #ifdef	_WIDE
554 	/* variables for positional parameters */
555 	/* save the beginning of the format */
556 	wchar_t *sformat = (wchar_t *)format;
557 #else  /* _WIDE */
558 	/* variables for positional parameters */
559 	char *sformat = (char *)format; /* save the beginning of the format */
560 #endif
561 
562 	int	fpos = 1;		/* 1 if first positional parameter */
563 	stva_list	args,	/* used to step through the argument list */
564 			sargs;	/* used to save the start of the arg list */
565 	stva_list	bargs;	/* used to restore args if positional width */
566 				/* or precision */
567 	stva_list	arglst[MAXARGS]; /* array giving appropriate values */
568 					/* for va_arg() to retrieve the */
569 					/* corresponding argument: */
570 					/* arglst[0] is the first arg */
571 					/* arglst[1] is the second arg, etc */
572 
573 	int	starflg = 0;	/* set to 1 if * format specifier seen */
574 
575 	/*
576 	 * Initialize args and sargs to the start of the argument list.
577 	 * We don't know any portable way to copy an arbitrary C object
578 	 * so we use a system-specific routine (probably a macro) from
579 	 * stdarg.h.  (Remember that if va_list is an array, in_args will
580 	 * be a pointer and &in_args won't be what we would want for
581 	 * memcpy.)
582 	 */
583 	va_copy(args.ap, in_args);
584 	sargs = args;
585 
586 #ifdef	_WIDE
587 	if (iop->_flag == _IOREAD)
588 		sflag = 1;
589 
590 	if (!sflag) {
591 #endif /* _WIDE */
592 	/* if first I/O to the stream get a buffer */
593 	/* Note that iop->_base should not equal 0 for sprintf and vsprintf */
594 	if (iop->_base == 0)  {
595 	    if (_findbuf(iop) == 0)
596 		return (EOF);
597 	    /* _findbuf leaves _cnt set to 0 which is the wrong thing to do */
598 	    /* for fully buffered files */
599 	    if (!(iop->_flag & (_IOLBF|_IONBF)))
600 		iop->_cnt = _bufend(iop) - iop->_base;
601 	}
602 #ifdef	_WIDE
603 	}
604 #endif /* _WIDE */
605 
606 #ifdef	_WIDE
607 	bufptr = iop->_ptr;
608 	if (sflag) {
609 		maxcount = (size_t)iop->_cnt;
610 		bufferend = (unsigned char *)(((wchar_t *)iop->_ptr) +
611 			maxcount);
612 	} else {
613 		bufferend = _bufend(iop);
614 	}
615 #else  /* _WIDE */
616 	/* initialize buffer pointer and buffer end pointer */
617 	bufptr = iop->_ptr;
618 	if (iop->_flag & _IOREAD) {
619 		/*
620 		 * [v]sprintf or [v]snprintf
621 		 */
622 		if (iop->_cnt == MAXINT) {
623 			/*
624 			 * [v]sprintf (no boundschecking)
625 			 */
626 			bufferend =
627 			    (unsigned char *)((long)bufptr | (-1L & ~HIBITL));
628 		} else {
629 			/*
630 			 * [v]snprintf (with boundschecking) or
631 			 * iop with _IORW has been read.
632 			 */
633 			bufferend = _bufend(iop);
634 			if (bufferend == NULL) {
635 				/*
636 				 * [v]snprintf
637 				 *
638 				 * [v]snprint() needs to be always handled by
639 				 * _dowrite().
640 				 */
641 				snflag = 1;
642 			}
643 		}
644 	} else {
645 		/*
646 		 * [v]printf or [v]fprintf
647 		 */
648 		bufferend = _bufend(iop);
649 	}
650 #endif /* _WIDE */
651 
652 	/*
653 	 *	The main loop -- this loop goes through one iteration
654 	 *	for each string of ordinary characters or format specification.
655 	 */
656 	for (; ; ) {
657 		ssize_t n;
658 
659 		if ((fcode = *format) != '\0' && fcode != '%') {
660 #ifdef	_WIDE
661 			bp = (wchar_t *)format;
662 #else  /* _WIDE */
663 			bp = (char *)format;
664 #endif /* _WIDE */
665 			do {
666 				format++;
667 			} while ((fcode = *format) != '\0' && fcode != '%');
668 
669 			count += (n = format - bp); /* n = no. of non-% chars */
670 			PUT(bp, n);
671 		}
672 		if (fcode == '\0') {  /* end of format; return */
673 			ssize_t nn = bufptr - iop->_ptr;
674 
675 #ifdef	_WIDE
676 			if (sflag) {
677 				iop->_ptr = bufptr;
678 				return ((ssize_t)count);
679 			}
680 #endif /* _WIDE */
681 
682 			iop->_cnt -= nn;
683 			iop->_ptr = bufptr;
684 			/* in case of interrupt during last several lines */
685 			if ((bufptr + iop->_cnt) > bufferend && !(iop->_flag \
686 			    & _IOREAD))
687 				_bufsync(iop, bufferend);
688 			if (iop->_flag & (_IONBF | _IOLBF) && \
689 			    (iop->_flag & _IONBF || \
690 			    memchr((char *)(bufptr+iop->_cnt), \
691 			    '\n', -iop->_cnt) != NULL))
692 				(void) _xflsbuf(iop);
693 #ifdef	_WIDE
694 			return (FERROR(iop) ? EOF : (ssize_t)count);
695 #else  /* _WIDE */
696 			return (FERROR(iop) ? EOF : (int)count);
697 #endif /* _WIDE */
698 		}
699 
700 		/*
701 		 *	% has been found.
702 		 *	The following switch is used to parse the format
703 		 *	specification and to perform the operation specified
704 		 *	by the format letter.  The program repeatedly goes
705 		 *	back to this switch until the format letter is
706 		 *	encountered.
707 		 */
708 		width = prefixlength = otherlength = 0;
709 		flagword = suffixlength = 0;
710 		format++;
711 		wflag = 0;
712 		lflag = 0;
713 		quote = 0;
714 #ifndef	_WIDE
715 		sec_display = 0;
716 #endif
717 
718 	charswitch:
719 
720 		switch (fcode = *format++) {
721 
722 		case '+':
723 			flagword |= FPLUS;
724 			goto charswitch;
725 		case '-':
726 			flagword |= FMINUS;
727 			flagword &= ~PADZERO; /* ignore 0 flag */
728 			goto charswitch;
729 		case ' ':
730 			flagword |= FBLANK;
731 			goto charswitch;
732 		case '\'':	/* XSH4 */
733 			quote++;
734 			goto charswitch;
735 		case '#':
736 			flagword |= FSHARP;
737 			goto charswitch;
738 
739 		/* Scan the field width and precision */
740 		case '.':
741 			flagword |= DOTSEEN;
742 			prec = 0;
743 			goto charswitch;
744 
745 		case '*':
746 			if (_M_ISDIGIT(*format)) {
747 				starflg = 1;
748 				bargs = args;
749 				goto charswitch;
750 			}
751 			if (!(flagword & DOTSEEN)) {
752 				width = va_arg(args.ap, int);
753 				if (width < 0) {
754 					width = -width;
755 					flagword |= FMINUS;
756 				}
757 			} else {
758 				prec = va_arg(args.ap, int);
759 				if (prec < 0) {
760 					prec = 0;
761 					flagword ^= DOTSEEN; /* ANSI sez so */
762 				}
763 			}
764 			goto charswitch;
765 
766 		case '$':
767 			{
768 			ssize_t		position;
769 			stva_list	targs;
770 			if (fpos) {
771 #ifdef	_WIDE
772 				_wmkarglst(sformat, sargs, arglst, prflag);
773 #else  /* _WIDE */
774 				_mkarglst(sformat, sargs, arglst, prflag);
775 #endif /* _WIDE */
776 				fpos = 0;
777 			}
778 			if (flagword & DOTSEEN) {
779 				position = prec;
780 				prec = 0;
781 			} else {
782 				position = width;
783 				width = 0;
784 			}
785 			if (position <= 0) {
786 				/* illegal position */
787 				format--;
788 				continue;
789 			}
790 			if (position <= MAXARGS) {
791 				targs = arglst[position - 1];
792 			} else {
793 				targs = arglst[MAXARGS - 1];
794 #ifdef	_WIDE
795 				_wgetarg(sformat, &targs, position, prflag);
796 #else  /* _WIDE */
797 				_getarg(sformat, &targs, position, prflag);
798 #endif /* _WIDE */
799 			}
800 			if (!starflg)
801 				args = targs;
802 			else {
803 				starflg = 0;
804 				args = bargs;
805 				if (flagword & DOTSEEN) {
806 					prec = va_arg(targs.ap, int);
807 					if (prec < 0) {
808 						prec = 0;
809 						flagword ^= DOTSEEN; /* XSH */
810 					}
811 				} else {
812 					width = va_arg(targs.ap, int);
813 					if (width < 0) {
814 						width = -width;
815 						flagword |= FMINUS;
816 					}
817 				}
818 			}
819 			goto charswitch;
820 			}
821 
822 		case '0':	/* obsolescent spec:  leading zero in width */
823 				/* means pad with leading zeros */
824 			if (!(flagword & (DOTSEEN | FMINUS)))
825 				flagword |= PADZERO;
826 			/* FALLTHROUGH */
827 		case '1':
828 		case '2':
829 		case '3':
830 		case '4':
831 		case '5':
832 		case '6':
833 		case '7':
834 		case '8':
835 		case '9':
836 			{ num = fcode - '0';
837 			while (_M_ISDIGIT(fcode = *format)) {
838 				num = num * 10 + fcode - '0';
839 				format++;
840 			}
841 			if (flagword & DOTSEEN)
842 				prec = num;
843 			else
844 				width = num;
845 			goto charswitch;
846 			}
847 
848 		/* Scan the length modifier */
849 		case 'l':
850 			if (!(flagword & XLONG)) {
851 				if (lflag) {
852 					/* long long */
853 					flagword &= ~LENGTH;
854 					flagword |= XLONG;
855 				} else	{
856 					/* long */
857 					flagword |= LENGTH;
858 				}
859 			}
860 			lflag++;
861 			goto charswitch;
862 
863 		case 'L':			/* long double */
864 			flagword |= QUAD;
865 			goto charswitch;
866 
867 		case 'h':
868 			if (!(flagword & CHAR)) {
869 				if (flagword & SHORT) {
870 					/* char - hh */
871 					flagword &= ~SHORT;
872 					flagword |= CHAR;
873 				} else {
874 					/* short */
875 					flagword |= SHORT;
876 				}
877 			}
878 			goto charswitch;
879 		case 'j':
880 #ifndef _LP64
881 			/*
882 			 * *printf_c89() in 32-bit libc uses
883 			 * 32-bit intmax_t; otherwise intmax_t
884 			 * is 64-bits.
885 			 */
886 			if (!(prflag & _F_INTMAX32)) {
887 #endif
888 				flagword |= XLONG;	/* [u]intmax_t (64) */
889 #ifndef _LP64
890 			}
891 #endif
892 			goto charswitch;
893 
894 		case 't':
895 			/*
896 			 * LENGTH is shared by l, t, z specifiers; protect
897 			 * against (destructive) undefined behavior (eg:
898 			 * avoid %llt setting XLONG and LENGTH) with invalid
899 			 * combinations of specifiers
900 			 */
901 			if (!(flagword & XLONG)) {
902 				flagword |= LENGTH;	/* ptrdiff_t */
903 			}
904 			goto charswitch;
905 
906 		case 'z':
907 			if (!(flagword & XLONG)) {
908 				flagword |= LENGTH;	/* [s]size_t */
909 			}
910 			goto charswitch;
911 
912 		/*
913 		 *	The character addressed by format must be
914 		 *	the format letter -- there is nothing
915 		 *	left for it to be.
916 		 *
917 		 *	The status of the +, -, #, and blank
918 		 *	flags are reflected in the variable
919 		 *	"flagword".  "width" and "prec" contain
920 		 *	numbers corresponding to the digit
921 		 *	strings before and after the decimal
922 		 *	point, respectively. If there was no
923 		 *	decimal point, then flagword & DOTSEEN
924 		 *	is false and the value of prec is meaningless.
925 		 *
926 		 *	The following switch cases set things up
927 		 *	for printing.  What ultimately gets
928 		 *	printed will be padding blanks, a
929 		 *	prefix, left padding zeroes, a value,
930 		 *	right padding zeroes, a suffix, and
931 		 *	more padding blanks.  Padding blanks
932 		 *	will not appear simultaneously on both
933 		 *	the left and the right.  Each case in
934 		 *	this switch will compute the value, and
935 		 *	leave in several variables the informa-
936 		 *	tion necessary to construct what is to
937 		 *	be printed.
938 		 *
939 		 *	The prefix is a sign, a blank, "0x",
940 		 *	"0X", a sign or a blank followed by "0x"
941 		 *	or "0X", or nothing, and is addressed by
942 		 *	"prefix".
943 		 *
944 		 *	The suffix is either null or an
945 		 *	exponent, and is addressed by "suffix".
946 		 *	If there is a suffix, the flagword bit
947 		 *	SUFFIX will be set.
948 		 *
949 		 *	The value to be printed starts at "bp"
950 		 *	and continues up to and not including
951 		 *	"p".
952 		 *
953 		 *	"lzero" and "rzero" will contain the
954 		 *	number of padding zeroes required on
955 		 *	the left and right, respectively.
956 		 *	The flagword bits LZERO and RZERO tell
957 		 *	whether padding zeros are required.
958 		 *
959 		 *	The number of padding blanks, and
960 		 *	whether they go on the left or the
961 		 *	right, will be computed on exit from
962 		 *	the switch.
963 		 */
964 
965 
966 
967 		/*
968 		 *	decimal fixed point representations
969 		 *
970 		 *	HIBITL is 100...000
971 		 *	binary, and is equal to	the maximum
972 		 *	negative number.
973 		 *	We assume a 2's complement machine
974 		 */
975 		case 'i':
976 		case 'd':
977 			if ((flagword & PADZERO) && (flagword & DOTSEEN))
978 				flagword &= ~PADZERO; /* ignore 0 flag */
979 			/* Set buffer pointer to last digit */
980 			p = bp = buf + MAXLLDIGS;
981 
982 			/* Fetch the argument to be printed */
983 			if (flagword & XLONG) {		/* long long */
984 				ll = va_arg(args.ap, long long);
985 
986 				/* If signed conversion, make sign */
987 				if (ll < 0) {
988 					prefix = _P_HYPHEN;
989 					prefixlength = 1;
990 					/*
991 					 * Negate, checking in advance for
992 					 * possible overflow.
993 					 */
994 					if (ll != HIBITLL)
995 						ll = -ll;
996 					else
997 					/* number is -HIBITLL; convert last */
998 					/* digit now and get positive number */
999 						*--bp = _lowlldigit(&ll);
1000 				} else if (flagword & FPLUS) {
1001 					prefix = _P_PLUS;
1002 					prefixlength = 1;
1003 				} else if (flagword & FBLANK) {
1004 					prefix = _P_BLANK;
1005 					prefixlength = 1;
1006 				}
1007 			} else {		/* not long long */
1008 				if (flagword & LENGTH)
1009 					val = va_arg(args.ap, long);
1010 				else
1011 					val = va_arg(args.ap, int);
1012 
1013 				if (flagword & SHORT)
1014 					val = (short)val;
1015 				else if (flagword & CHAR)
1016 					val = (char)val;
1017 
1018 				/* If signed conversion, make sign */
1019 				if (val < 0) {
1020 					prefix = _P_HYPHEN;
1021 					prefixlength = 1;
1022 					/*
1023 					 * Negate, checking in advance
1024 					 * for possible overflow.
1025 					 */
1026 					if (val != HIBITL)
1027 						val = -val;
1028 					/*
1029 					 * number is -HIBITL; convert
1030 					 * last digit now and get
1031 					 * positive number
1032 					 */
1033 					else
1034 						*--bp = _lowdigit(&val);
1035 				} else if (flagword & FPLUS) {
1036 					prefix = _P_PLUS;
1037 					prefixlength = 1;
1038 				} else if (flagword & FBLANK) {
1039 					prefix = _P_BLANK;
1040 					prefixlength = 1;
1041 				}
1042 			}
1043 
1044 		decimal:
1045 			{
1046 			long qval = val;
1047 			long long lll = ll;
1048 			long long tll;
1049 			if (flagword & XLONG) {
1050 				if (lll < 10LL) {
1051 #ifdef	_WIDE
1052 					if (lll != 0LL || !(flagword & DOTSEEN))
1053 						*--bp = (wchar_t)lll + L'0';
1054 #else  /* _WIDE */
1055 					if (lll != 0LL || !(flagword & DOTSEEN))
1056 						*--bp = (char)lll + '0';
1057 #endif /* _WIDE */
1058 				} else {
1059 					do {
1060 						tll = lll;
1061 						lll /= 10;
1062 #ifdef	_WIDE
1063 						*--bp = (wchar_t)
1064 							(tll - lll * 10 + '0');
1065 #else  /* _WIDE */
1066 						*--bp = (char) \
1067 						    (tll - lll * 10 + '0');
1068 #endif /* _WIDE */
1069 					} while (lll >= 10);
1070 #ifdef	_WIDE
1071 					*--bp = (wchar_t)lll + '0';
1072 #else  /* _WIDE */
1073 					*--bp = (char)lll + '0';
1074 #endif /* _WIDE */
1075 				}
1076 			} else {
1077 				if (qval <= 9) {
1078 #ifdef	_WIDE
1079 					if (qval != 0 || !(flagword & DOTSEEN))
1080 						*--bp = (wchar_t)qval + '0';
1081 #else  /* _WIDE */
1082 					if (qval != 0 || !(flagword & DOTSEEN))
1083 						*--bp = (char)qval + '0';
1084 #endif /* _WIDE */
1085 				} else {
1086 					do {
1087 						n = qval;
1088 						qval /= 10;
1089 #ifdef	_WIDE
1090 						*--bp = (wchar_t) \
1091 						    (n - qval * 10 + '0');
1092 #else  /* _WIDE */
1093 						*--bp = (char) \
1094 						    (n - qval * 10 + '0');
1095 #endif /* _WIDE */
1096 					} while (qval > 9);
1097 #ifdef	_WIDE
1098 					*--bp = (wchar_t)qval + '0';
1099 #else  /* _WIDE */
1100 					*--bp = (char)qval + '0';
1101 #endif /* _WIDE */
1102 				}
1103 			}
1104 			}
1105 			/* Handle the ' flag */
1106 			if (quote) {
1107 				p = insert_thousands_sep(bp, p);
1108 			}
1109 
1110 			/* Calculate minimum padding zero requirement */
1111 			if (flagword & DOTSEEN) {
1112 				leadzeroes = prec - (p - bp);
1113 				if (leadzeroes > 0) {
1114 					otherlength = lzero = leadzeroes;
1115 					flagword |= LZERO;
1116 				}
1117 			}
1118 			break;
1119 
1120 		case 'u':
1121 			if ((flagword & PADZERO) && (flagword & DOTSEEN))
1122 				flagword &= ~PADZERO; /* ignore 0 flag */
1123 			p = bp = buf + MAXLLDIGS;
1124 
1125 			/* Fetch the argument to be printed */
1126 			if (flagword & XLONG) {
1127 				ll = va_arg(args.ap, long long);
1128 
1129 				if (ll & HIBITLL)
1130 					*--bp = _lowlldigit(&ll);
1131 			} else {
1132 				if (flagword & LENGTH)
1133 					val = va_arg(args.ap, long);
1134 				else
1135 					val = va_arg(args.ap, unsigned);
1136 
1137 				if (flagword & SHORT)
1138 					val = (unsigned short)val;
1139 				else if (flagword & CHAR)
1140 					val = (unsigned char)val;
1141 
1142 				if (val & HIBITL)
1143 					*--bp = _lowdigit(&val);
1144 			}
1145 
1146 			goto decimal;
1147 
1148 		/*
1149 		 *	non-decimal fixed point representations
1150 		 *	for radix equal to a power of two
1151 		 *
1152 		 *	"mradix" is one less than the radix for the conversion.
1153 		 *	"lradix" is one less than the base 2 log
1154 		 *	of the radix for the conversion. Conversion is unsigned.
1155 		 *	HIBITL is 100...000
1156 		 *	binary, and is equal to	the maximum
1157 		 *	negative number.
1158 		 *	We assume a 2's complement machine
1159 		 */
1160 
1161 		case 'o':
1162 			mradix = 7;
1163 			lradix = 2;
1164 			/*
1165 			 * DR151 and clarification in C90
1166 			 * presence of '#' increases precision to first
1167 			 * digit of the result to be zero
1168 			 */
1169 			if ((flagword & DOTSEEN) && (flagword & FSHARP) &&
1170 			    prec == 0)
1171 				prec = 1;
1172 
1173 			goto fixed;
1174 
1175 		case 'p':
1176 			flagword &= ~(XLONG | SHORT);
1177 			flagword |= LENGTH;
1178 
1179 			/* FALLTHRU */
1180 		case 'X':
1181 		case 'x':
1182 			mradix = 15;
1183 			lradix = 3;
1184 
1185 		fixed:
1186 			if ((flagword & PADZERO) && (flagword & DOTSEEN))
1187 				flagword &= ~PADZERO; /* ignore 0 flag */
1188 
1189 #ifdef	_WIDE
1190 			/* Set translate table for digits */
1191 			tab = (wchar_t *)((fcode == 'X') ? uc_digs : lc_digs);
1192 #else  /* _WIDE */
1193 			/* Set translate table for digits */
1194 			tab = (fcode == 'X') ? uc_digs : lc_digs;
1195 #endif /* _WIDE */
1196 
1197 			/* Fetch the argument to be printed */
1198 			if (flagword & XLONG) {
1199 				ll = va_arg(args.ap, long long);
1200 			} else {
1201 				if (flagword & LENGTH)
1202 					val = va_arg(args.ap, long);
1203 				else
1204 					val = va_arg(args.ap, unsigned);
1205 
1206 				if (flagword & SHORT)
1207 					val = (unsigned short) val;
1208 				else if (flagword & CHAR)
1209 					val = (unsigned char) val;
1210 			}
1211 			p = bp = buf + MAXLLDIGS;
1212 
1213 			/* Develop the digits of the value */
1214 			if (flagword & XLONG) {
1215 				long long lll = ll;
1216 
1217 				if (lll == 0LL) {
1218 					if (!(flagword & DOTSEEN)) {
1219 						otherlength = lzero = 1;
1220 						flagword |= LZERO;
1221 					}
1222 				} else do {
1223 					*--bp = tab[(ssize_t)(lll & mradix)];
1224 					lll = ((lll >> 1) & ~HIBITLL) \
1225 					    >> lradix;
1226 				} while (lll != 0LL);
1227 			} else {
1228 				long qval = val;
1229 
1230 				if (qval == 0) {
1231 					if (!(flagword & DOTSEEN)) {
1232 						otherlength = lzero = 1;
1233 						flagword |= LZERO;
1234 					}
1235 				} else do {
1236 					*--bp = tab[qval & mradix];
1237 					qval = ((qval >> 1) & ~HIBITL) \
1238 					    >> lradix;
1239 				} while (qval != 0);
1240 			}
1241 
1242 			/* Calculate minimum padding zero requirement */
1243 			if (flagword & DOTSEEN) {
1244 				leadzeroes = prec - (p - bp);
1245 				if (leadzeroes > 0) {
1246 					otherlength = lzero = leadzeroes;
1247 					flagword |= LZERO;
1248 				}
1249 			}
1250 
1251 			/* Handle the # flag, (val != 0) for int and long */
1252 			/* (ll!= 0) handles long long case */
1253 			if ((flagword & FSHARP) &&
1254 			    (((flagword & XLONG) == 0 && val != 0) ||
1255 			    ((flagword & XLONG) == XLONG && ll != 0)))
1256 				switch (fcode) {
1257 				case 'o':
1258 					if (!(flagword & LZERO)) {
1259 						otherlength = lzero = 1;
1260 						flagword |= LZERO;
1261 					}
1262 					break;
1263 				case 'x':
1264 					prefix = _P_ZEROx;
1265 					prefixlength = 2;
1266 					break;
1267 				case 'X':
1268 					prefix = _P_ZEROX;
1269 					prefixlength = 2;
1270 					break;
1271 				}
1272 
1273 			break;
1274 
1275 		case 'A':
1276 		case 'a':
1277 			/* A format */
1278 			if (flagword & QUAD) {
1279 				long double	qval = GETQVAL(args.ap);
1280 
1281 				/* establish default precision */
1282 				if (!(flagword & DOTSEEN))
1283 #if defined(__sparc)
1284 					prec = HEXFP_QUAD_DIG - 1;
1285 #elif defined(__i386) || defined(__amd64)
1286 					prec = HEXFP_EXTENDED_DIG - 1;
1287 #else
1288 #error Unknown architecture
1289 #endif
1290 
1291 				FPCONV(__qaconvert, &qval,
1292 				    min(prec + 1, MAXECVT), &exp, &sign,
1293 				    cvtbuf);
1294 			} else {
1295 				double	dval = va_arg(args.ap, double);
1296 
1297 				/* establish default precision */
1298 				if (!(flagword & DOTSEEN))
1299 					prec = HEXFP_DOUBLE_DIG - 1;
1300 
1301 				FPCONV(__aconvert, dval,
1302 				    min(prec + 1, MAXECVT), &exp, &sign,
1303 				    cvtbuf);
1304 			}
1305 			bp = cvtbuf;
1306 
1307 			/*
1308 			 * The following is wide-character safe because
1309 			 * __aconvert and __qaconvert only produce ASCII
1310 			 * characters.
1311 			 */
1312 			if (!isxdigit((unsigned char)*bp)) {
1313 				inf_nan = 1;
1314 				break;
1315 			}
1316 
1317 			/*
1318 			 * Create the prefix.  We ought to use the strings
1319 			 * defined above (_P_HYPHEN, etc.), but that would
1320 			 * be awkward: we'd either have to define six more
1321 			 * of them or we'd have to use strcpy/strcat to
1322 			 * assemble the ones already defined.  So instead,
1323 			 * we just build the prefix character by character.
1324 			 */
1325 			p = prefix = prefixbuf;
1326 			if (sign) {
1327 				*p++ = '-';
1328 				prefixlength = 1;
1329 			} else if (flagword & FPLUS) {
1330 				*p++ = '+';
1331 				prefixlength = 1;
1332 			} else if (flagword & FBLANK) {
1333 				*p++ = ' ';
1334 				prefixlength = 1;
1335 			}
1336 			*p++ = '0';
1337 			*p++ = (fcode == 'A') ? 'X' : 'x';
1338 			*p = '\0';
1339 			prefixlength += 2;
1340 
1341 			/* put the first digit in the buffer */
1342 			p = &buf[0];
1343 			*p++ = (*bp != '\0') ? *bp++ : '0';
1344 
1345 			/* Put in a decimal point if needed */
1346 			if (prec != 0 || (flagword & FSHARP))
1347 				p = insert_decimal_point(p);
1348 
1349 			/* Create the rest of the mantissa */
1350 			rz = prec;
1351 			if (fcode == 'A') {
1352 				for (; rz > 0 && *bp != '\0'; --rz) {
1353 					*p++ = ('a' <= *bp && *bp <= 'f')?
1354 					    *bp - 32 : *bp;
1355 					bp++;
1356 				}
1357 			} else {
1358 				for (; rz > 0 && *bp != '\0'; --rz)
1359 					*p++ = *bp++;
1360 			}
1361 			if (rz > 0) {
1362 				otherlength = rzero = rz;
1363 				flagword |= RZERO;
1364 			}
1365 
1366 			bp = &buf[0];
1367 
1368 			/*
1369 			 * Create the exponent in right-to-left order.
1370 			 * buf[0] == '0' if and only if the value being
1371 			 * converted is exactly zero, in which case the
1372 			 * exponent should be +0 regardless of exp.
1373 			 */
1374 			suffix = &expbuf[MAXESIZ];
1375 			*suffix = '\0';
1376 			if (buf[0] != '0') {
1377 				int	nn;
1378 
1379 				nn = exp;
1380 				if (nn < 0)
1381 				    nn = -nn;
1382 				for (; nn > 9; nn /= 10)
1383 					*--suffix = todigit(nn % 10);
1384 				*--suffix = todigit(nn);
1385 				*--suffix = (exp >= 0) ? '+' : '-';
1386 			} else {
1387 				*--suffix = '0';
1388 				*--suffix = '+';
1389 			}
1390 
1391 			/* put in the p */
1392 			*--suffix = (fcode == 'A') ? 'P' : 'p';
1393 
1394 			/* compute size of suffix */
1395 			suffixlength = &expbuf[MAXESIZ] - suffix;
1396 			otherlength += suffixlength;
1397 			flagword |= SUFFIX;
1398 			break;
1399 
1400 		case 'E':
1401 		case 'e':
1402 			/*
1403 			 * E-format.  The general strategy
1404 			 * here is fairly easy: we take what
1405 			 * econvert gives us and re-format it.
1406 			 * (qeconvert for long double)
1407 			 */
1408 
1409 			/* Establish default precision */
1410 			if (!(flagword & DOTSEEN))
1411 				prec = 6;
1412 
1413 			if (flagword & QUAD) {	/* long double */
1414 				long double	qval = GETQVAL(args.ap);
1415 
1416 				FPCONV(qeconvert, &qval,
1417 				    min(prec + 1, MAXECVT), &decpt, &sign,
1418 				    cvtbuf);
1419 			} else {	/* double */
1420 				double	dval = va_arg(args.ap, double);
1421 
1422 				FPCONV(econvert, dval,
1423 				    min(prec + 1, MAXECVT), &decpt, &sign,
1424 				    cvtbuf);
1425 			}
1426 			bp = cvtbuf;
1427 			if (*bp > '9') {
1428 				inf_nan = 1;
1429 				inf_nan_mixed_case = (__xpg6 &
1430 				    _C99SUSv3_mixed_case_Inf_and_NaN);
1431 				break;
1432 			}
1433 
1434 			/* Determine the prefix */
1435 		e_merge:
1436 			if (sign) {
1437 				prefix = _P_HYPHEN;
1438 				prefixlength = 1;
1439 			} else if (flagword & FPLUS) {
1440 				prefix = _P_PLUS;
1441 				prefixlength = 1;
1442 			} else if (flagword & FBLANK) {
1443 				prefix = _P_BLANK;
1444 				prefixlength = 1;
1445 			}
1446 
1447 			/* Place the first digit in the buffer */
1448 			p = &buf[0];
1449 			*p++ = (*bp != '\0') ? *bp++ : '0';
1450 
1451 			/* Put in a decimal point if needed */
1452 			if (prec != 0 || (flagword & FSHARP))
1453 				p = insert_decimal_point(p);
1454 
1455 			/* Create the rest of the mantissa */
1456 			rz = prec;
1457 			for (; rz > 0 && *bp != '\0'; --rz)
1458 				*p++ = *bp++;
1459 			if (rz > 0) {
1460 				otherlength = rzero = rz;
1461 				flagword |= RZERO;
1462 			}
1463 
1464 			bp = &buf[0];
1465 
1466 			/*
1467 			 * Create the exponent.  buf[0] == '0' if and
1468 			 * only if the value being converted is exactly
1469 			 * zero, in which case the exponent should be
1470 			 * +0 regardless of decpt.
1471 			 */
1472 			*(suffix = &expbuf[MAXESIZ]) = '\0';
1473 			if (buf[0] != '0') {
1474 				int nn = decpt - 1;
1475 				if (nn < 0)
1476 				    nn = -nn;
1477 				for (; nn > 9; nn /= 10)
1478 					*--suffix = todigit(nn % 10);
1479 				*--suffix = todigit(nn);
1480 			}
1481 
1482 			/* Prepend leading zeroes to the exponent */
1483 			while (suffix > &expbuf[MAXESIZ - 2])
1484 				*--suffix = '0';
1485 
1486 			/* Put in the exponent sign */
1487 			*--suffix = (decpt > 0 || buf[0] == '0') ? '+' : '-';
1488 
1489 			/* Put in the e */
1490 			*--suffix = _M_ISUPPER(fcode) ? 'E'  : 'e';
1491 
1492 			/* compute size of suffix */
1493 			otherlength += (suffixlength = &expbuf[MAXESIZ] \
1494 			    - suffix);
1495 			flagword |= SUFFIX;
1496 			break;
1497 
1498 		case 'F':
1499 		case 'f':
1500 			/*
1501 			 * F-format floating point.  This is a
1502 			 * good deal less simple than E-format.
1503 			 * The overall strategy will be to call
1504 			 * fconvert, reformat its result into buf,
1505 			 * and calculate how many trailing
1506 			 * zeroes will be required.  There will
1507 			 * never be any leading zeroes needed.
1508 			 * (qfconvert for long double)
1509 			 */
1510 
1511 			/* Establish default precision */
1512 			if (!(flagword & DOTSEEN))
1513 				prec = 6;
1514 
1515 			if (flagword & QUAD) {	/* long double */
1516 				long double	qval = GETQVAL(args.ap);
1517 
1518 				FPCONV(qfconvert, &qval, min(prec, MAXFCVT),
1519 				    &decpt, &sign, cvtbuf);
1520 				bp = cvtbuf;
1521 				if (*bp == 0) {
1522 					/*
1523 					 * qfconvert would have required
1524 					 * too many characters; use qeconvert
1525 					 * instead
1526 					 */
1527 					FPCONV(qeconvert, &qval,
1528 					    min(prec + 1, MAXECVT), &decpt,
1529 					    &sign, cvtbuf);
1530 					goto e_merge;
1531 				}
1532 			} else {	/* double */
1533 				double	dval = va_arg(args.ap, double);
1534 
1535 				FPCONV(fconvert, dval, min(prec, MAXFCVT),
1536 				    &decpt, &sign, cvtbuf);
1537 			}
1538 			bp = cvtbuf;
1539 			if (*bp > '9') {
1540 				inf_nan = 1;
1541 				if (fcode == 'f')
1542 					inf_nan_mixed_case = (__xpg6 &
1543 					    _C99SUSv3_mixed_case_Inf_and_NaN);
1544 				break;
1545 			}
1546 
1547 			/* Determine the prefix */
1548 		f_merge:
1549 			if (sign) {
1550 				prefix = _P_HYPHEN;
1551 				prefixlength = 1;
1552 			} else if (flagword & FPLUS) {
1553 				prefix = _P_PLUS;
1554 				prefixlength = 1;
1555 			} else if (flagword & FBLANK) {
1556 				prefix = _P_BLANK;
1557 				prefixlength = 1;
1558 			}
1559 
1560 			/* Initialize buffer pointer */
1561 			p = &buf[0];
1562 
1563 			{
1564 				ssize_t nn = decpt;
1565 
1566 				/* Emit the digits before the decimal point */
1567 				k = 0;
1568 				do {
1569 					*p++ = (nn <= 0 || *bp == '\0' || \
1570 					    k >= MAXFSIG) ? '0' : (k++, *bp++);
1571 				} while (--nn > 0);
1572 
1573 				if (quote)
1574 					p = insert_thousands_sep(buf, p);
1575 
1576 				/* Put in a decimal point if needed */
1577 				if (prec > 0 || (flagword & FSHARP))
1578 					p = insert_decimal_point(p);
1579 
1580 				/* Digits (if any) after the decimal point */
1581 				nn = min(prec, MAXFCVT);
1582 				if (prec > nn) {
1583 					flagword |= RZERO;
1584 					otherlength = rzero = prec - nn;
1585 				}
1586 				while (--nn >= 0)
1587 					*p++ = (++decpt <= 0 || *bp == '\0' || \
1588 					    k >= MAXFSIG) ? '0' : (k++, *bp++);
1589 			}
1590 
1591 			bp = &buf[0];
1592 
1593 			break;
1594 
1595 		case 'G':
1596 		case 'g':
1597 			/*
1598 			 * g-format.  We play around a bit
1599 			 * and then jump into e or f, as needed.
1600 			 */
1601 
1602 			/* Establish default precision */
1603 			if (!(flagword & DOTSEEN))
1604 				prec = 6;
1605 			else if (prec == 0)
1606 				prec = 1;
1607 
1608 			if (flagword & QUAD) {	/* long double */
1609 				long double	qval = GETQVAL(args.ap);
1610 
1611 				FPCONV(qeconvert, &qval, min(prec, MAXECVT),
1612 				    &decpt, &sign, cvtbuf);
1613 			} else {	/* double */
1614 				double	dval = va_arg(args.ap, double);
1615 
1616 				FPCONV(econvert, dval, min(prec, MAXECVT),
1617 				    &decpt, &sign, cvtbuf);
1618 			}
1619 			bp = cvtbuf;
1620 			if (*bp > '9') {
1621 				inf_nan = 1;
1622 				inf_nan_mixed_case = (__xpg6 &
1623 				    _C99SUSv3_mixed_case_Inf_and_NaN);
1624 				break;
1625 			}
1626 			if (*bp == '0')	/* the value converted is zero */
1627 				decpt = 1;
1628 
1629 			{
1630 				int kk = prec;
1631 				if (!(flagword & FSHARP)) {
1632 #ifdef	_WIDE
1633 					n = wcslen(bp);
1634 #else  /* _WIDE */
1635 					n = strlen(bp);
1636 #endif /* _WIDE */
1637 					if (n < kk)
1638 						kk = (int)n;
1639 					while (kk >= 1 && bp[kk-1] == '0')
1640 						--kk;
1641 				}
1642 				if (decpt < -3 || decpt > prec) {
1643 					prec = kk - 1;
1644 					goto e_merge;
1645 				}
1646 				prec = kk - decpt;
1647 				goto f_merge;
1648 			}
1649 
1650 		case '%':
1651 			buf[0] = fcode;
1652 			goto c_merge;
1653 
1654 #ifndef	_WIDE
1655 		case 'w':
1656 			wflag = 1;
1657 			goto charswitch;
1658 #endif /* _WIDE */
1659 
1660 
1661 		case 'C': /* XPG XSH4 extention */
1662 wide_C:
1663 			{
1664 				wchar_t	temp;
1665 
1666 				temp = va_arg(args.ap, wchar_t);
1667 #ifdef	_WIDE
1668 				if (temp) {
1669 					buf[0] = temp;
1670 					p = (bp = buf) + 1;
1671 				} else {
1672 					buf[0] = 0;
1673 					p = (bp = buf) + 1;
1674 				}
1675 				wcount = 1;
1676 				wflag = 1;
1677 #else  /* _WIDE */
1678 				if (temp) {
1679 					if ((retcode = wctomb(buf, temp))
1680 						== -1) {
1681 						errno = EILSEQ;
1682 						return (EOF);
1683 					} else {
1684 						p = (bp = buf) + retcode;
1685 					}
1686 				} else { /* NULL character */
1687 					buf[0] = 0;
1688 					p = (bp = buf) + 1;
1689 				}
1690 				wcount = p - bp;
1691 #endif /* _WIDE */
1692 			}
1693 			break;
1694 		case 'c':
1695 			if (lflag) {
1696 				goto wide_C;
1697 			}
1698 #ifndef	_WIDE
1699 			if (wflag) {
1700 				wchar_t	temp;
1701 
1702 				temp = va_arg(args.ap, wchar_t);
1703 				if (temp) {
1704 					if ((retcode = wctomb(buf, temp))
1705 						== -1) {
1706 						p = (bp = buf) + 1;
1707 					} else {
1708 						p = (bp = buf) + retcode;
1709 					}
1710 				} else { /* NULL character */
1711 					buf[0] = 0;
1712 					p = (bp = buf) + 1;
1713 				}
1714 				wcount = p - bp;
1715 			} else {
1716 #endif /* _WIDE */
1717 				if (flagword & XLONG) {
1718 					long long temp;
1719 					temp = va_arg(args.ap, long long);
1720 #ifdef	_WIDE
1721 					buf[0] = (wchar_t)temp;
1722 #else  /* _WIDE */
1723 					buf[0] = (char)temp;
1724 #endif /* _WIDE */
1725 				} else
1726 					buf[0] = va_arg(args.ap, int);
1727 			c_merge:
1728 				p = (bp = &buf[0]) + 1;
1729 #ifdef	_WIDE
1730 				wcount = 1;
1731 				wflag = 1;
1732 #endif /* _WIDE */
1733 #ifndef	_WIDE
1734 			}
1735 #endif /* _WIDE */
1736 			break;
1737 
1738 		case 'S': /* XPG XSH4 extention */
1739 wide_S:
1740 #ifdef	_WIDE
1741 			if (!lflag) {
1742 				lflag++;
1743 			}
1744 			bp = va_arg(args.ap, wchar_t *);
1745 			if (bp == NULL)
1746 				bp = (wchar_t *)widenullstr;
1747 			if (!(flagword & DOTSEEN)) {
1748 				/* wide character handling */
1749 				prec = MAXINT;
1750 			}
1751 
1752 			wp = bp;
1753 			wcount = 0;
1754 			while (*wp) {
1755 				if ((prec - wcount - 1) >= 0) {
1756 					wcount++;
1757 					wp++;
1758 				} else {
1759 					break;
1760 				}
1761 			}
1762 			p = wp;
1763 			wflag = 1;
1764 			break;
1765 #else  /* _WIDE */
1766 			if (!wflag)
1767 				wflag++;
1768 			bp = va_arg(args.ap, char *);
1769 			if (bp == NULL)
1770 				bp = (char *)widenullstr;
1771 			if (!(flagword & DOTSEEN)) {
1772 				/* wide character handling */
1773 				prec = MAXINT;
1774 			}
1775 
1776 			wp = (wchar_t *)(uintptr_t)bp;
1777 			wcount = 0;
1778 			while (*wp) {
1779 				int nbytes;
1780 
1781 				nbytes = wctomb(tmpbuf, *wp);
1782 				if (nbytes < 0) {
1783 					errno = EILSEQ;
1784 					return (EOF);
1785 				}
1786 				if ((prec - (wcount + nbytes)) >= 0) {
1787 					wcount += nbytes;
1788 					wp++;
1789 				} else {
1790 					break;
1791 				}
1792 			}
1793 			sec_display = wcount;
1794 			p = (char *)wp;
1795 			break;
1796 #endif /* _WIDE */
1797 		case 's':
1798 			if (lflag) {
1799 				goto wide_S;
1800 			}
1801 #ifdef	_WIDE
1802 			cbp = va_arg(args.ap, char *);
1803 			if (cbp == NULL)
1804 				cbp = (char *)nullstr;
1805 			if (!(flagword & DOTSEEN)) {
1806 				size_t	nwc;
1807 				wchar_t	*wstr;
1808 
1809 				nwc = mbstowcs(NULL, cbp, 0);
1810 				if (nwc == (size_t)-1) {
1811 					errno = EILSEQ;
1812 					return (EOF);
1813 				}
1814 				bpsize = sizeof (wchar_t) * (nwc + 1);
1815 				wstr = (wchar_t *)lmalloc(bpsize);
1816 				if (wstr == NULL) {
1817 					errno = EILSEQ;
1818 					return (EOF);
1819 				}
1820 				nwc = mbstowcs(wstr, cbp, MAXINT);
1821 				wcount = nwc;
1822 				bp = wstr;
1823 				p = wstr + nwc;
1824 			} else {
1825 				size_t	nwc;
1826 				wchar_t	*wstr;
1827 
1828 				nwc = mbstowcs(NULL, cbp, 0);
1829 				if (nwc == (size_t)-1) {
1830 					errno = EILSEQ;
1831 					return (EOF);
1832 				}
1833 				if (prec > nwc) {
1834 					bpsize = sizeof (wchar_t) * nwc;
1835 					wstr = (wchar_t *)lmalloc(bpsize);
1836 					if (wstr == NULL) {
1837 						errno = ENOMEM;
1838 						return (EOF);
1839 					}
1840 					nwc = mbstowcs(wstr, cbp, nwc);
1841 					wcount = nwc;
1842 					bp = wstr;
1843 					p = wstr + nwc;
1844 				} else {
1845 					size_t	nnwc;
1846 					int	len;
1847 					char	*s;
1848 					wchar_t	*wstr;
1849 
1850 					bpsize = sizeof (wchar_t) * prec;
1851 					wstr = (wchar_t *)lmalloc(bpsize);
1852 					if (wstr == NULL) {
1853 						errno = ENOMEM;
1854 						return (EOF);
1855 					}
1856 					nwc = mbstowcs(wstr, cbp, prec);
1857 					wcount = prec;
1858 					bp = wstr;
1859 					p = wstr + nwc;
1860 				}
1861 			}
1862 			wflag = 1;
1863 #else  /* _WIDE */
1864 			bp = va_arg(args.ap, char *);
1865 			if (bp == NULL)
1866 				bp = (char *)nullstr;
1867 			if (!(flagword & DOTSEEN)) {
1868 				if (wflag) {
1869 					/* wide character handling */
1870 					prec = MAXINT;
1871 					goto wide_hand;
1872 				}
1873 
1874 
1875 				p = bp + strlen(bp);
1876 
1877 				/*
1878 				 * sec_display only needed if width
1879 				 * is specified (ie, "%<width>s")
1880 				 * Solaris behavior counts <width> in
1881 				 * screen column width.  (If XPG4 behavior,
1882 				 * <width> is counted in bytes.)
1883 				 */
1884 				if (width > 0 && __xpg4 == 0 &&
1885 				    MB_CUR_MAX > 1) {
1886 #define	NW	256
1887 					wchar_t wbuff[NW];
1888 					wchar_t *wp, *wptr;
1889 					size_t wpsize;
1890 					size_t nwc;
1891 
1892 					wp = NULL;
1893 					if ((nwc = mbstowcs(wbuff, bp,
1894 					    NW)) == (size_t)-1) {
1895 						/* Estimate width */
1896 						sec_display = strlen(bp);
1897 						goto mbs_err;
1898 					}
1899 					if (nwc < NW) {
1900 						wptr = wbuff;
1901 					} else {
1902 						/*
1903 						 * If widechar does not fit into
1904 						 * wbuff, allocate larger buffer
1905 						 */
1906 						if ((nwc =
1907 						    mbstowcs(NULL, bp, 0)) ==
1908 						    (size_t)-1) {
1909 							sec_display =
1910 							    strlen(bp);
1911 							goto mbs_err;
1912 						}
1913 						wpsize = (nwc + 1) *
1914 						    sizeof (wchar_t);
1915 						if ((wp = lmalloc(wpsize))
1916 						    == NULL) {
1917 							errno = ENOMEM;
1918 							return (EOF);
1919 						}
1920 						if ((nwc = mbstowcs(wp,
1921 						    bp, nwc)) == (size_t)-1) {
1922 							sec_display = \
1923 							    strlen(bp);
1924 							goto mbs_err;
1925 						}
1926 						wptr = wp;
1927 					}
1928 					if ((sec_display = wcswidth(wptr, nwc))
1929 					    == -1) {
1930 						sec_display =
1931 							_rec_scrswidth
1932 								(wptr, nwc);
1933 					}
1934 				mbs_err:
1935 					if (wp)
1936 						lfree(wp, wpsize);
1937 				}
1938 			} else { /* a strnlen function would be useful here! */
1939 				/*
1940 				 * If we've seen a dot, and count has been set
1941 				 * to 0, then we don't output in any cases
1942 				 * below. prec should be always >= 0. So we only
1943 				 * check to see if it's zero.
1944 				 */
1945 				if (prec == 0) {
1946 					p = bp;
1947 					break;
1948 				}
1949 
1950 				if (wflag) {
1951 					/* wide character handling */
1952 
1953 				wide_hand:
1954 					wp = (wchar_t *)(uintptr_t)bp;
1955 					preco = prec;
1956 					wcount = 0;
1957 					while (*wp &&
1958 					    (prec -= _scrwidth(*wp)) >= 0) {
1959 						if ((retcode =
1960 						    wctomb(tmpbuf, *wp)) < 0)
1961 							wcount++;
1962 						else
1963 							wcount += retcode;
1964 						wp++;
1965 					}
1966 					if (*wp)
1967 						prec += _scrwidth(*wp);
1968 					p = (char *)wp;
1969 					sec_display = preco - prec;
1970 				} else if (__xpg4 == 0 && MB_CUR_MAX > 1) {
1971 					/*
1972 					 * Solaris behavior - count
1973 					 * precision as screen column width
1974 					 */
1975 					char *qp = bp;
1976 					int ncol, nbytes;
1977 					wchar_t wc;
1978 
1979 					ncol = 0;
1980 					preco = prec;
1981 					while (*qp) {
1982 						if (isascii(*qp)) {
1983 							qp++;
1984 							if (--prec == 0)
1985 								break;
1986 							continue;
1987 						}
1988 						if ((nbytes = mbtowc(&wc, qp,
1989 							MB_LEN_MAX)) == -1) {
1990 							/* print illegal char */
1991 							nbytes = 1;
1992 							ncol = 1;
1993 						} else {
1994 							if ((ncol =
1995 							_scrwidth(wc))
1996 								== 0) {
1997 								ncol = 1;
1998 							}
1999 						}
2000 
2001 						if ((prec -= ncol) >= 0) {
2002 							qp += nbytes;
2003 							if (prec == 0)
2004 								break;
2005 						} else {
2006 							break;
2007 						}
2008 					}
2009 					if (prec < 0)
2010 						prec += ncol;
2011 					p = qp;
2012 					sec_display = preco - prec;
2013 				} else {
2014 					/*
2015 					 * XPG4 behavior - count
2016 					 * precision as bytes.
2017 					 * We don't use strlen() because
2018 					 * the given char string may not
2019 					 * be null-terminated.
2020 					 */
2021 					char *qp;
2022 
2023 					qp = memchr(bp, '\0', prec);
2024 					if (qp == NULL) {
2025 						p = bp + prec;
2026 					} else {
2027 						p = qp;
2028 					}
2029 				}
2030 			}
2031 #endif /* _WIDE */
2032 			break;
2033 
2034 		case 'n':
2035 			{
2036 			if (flagword & XLONG) {
2037 				long long *svcount;
2038 				svcount = va_arg(args.ap, long long *);
2039 				*svcount = (long long)count;
2040 			} else if (flagword & LENGTH) {
2041 				long *svcount;
2042 				svcount = va_arg(args.ap, long *);
2043 				*svcount = (long)count;
2044 			} else if (flagword & SHORT) {
2045 				short *svcount;
2046 				svcount = va_arg(args.ap, short *);
2047 				*svcount = (short)count;
2048 			} else if (flagword & CHAR) {
2049 				char *svcount;
2050 				svcount = va_arg(args.ap, char *);
2051 				*svcount = (char)count;
2052 			} else {
2053 				int *svcount;
2054 				svcount = va_arg(args.ap, int *);
2055 				*svcount = count;
2056 			}
2057 			continue;
2058 		}
2059 		default: /* this is technically an error; what we do is to */
2060 			/* back up the format pointer to the offending char */
2061 			/* and continue with the format scan */
2062 			format--;
2063 			continue;
2064 		}
2065 
2066 		if (inf_nan) {
2067 			if (inf_nan_mixed_case) {
2068 				/* advance p */
2069 				for (p = bp + 1; *p != '\0'; p++)
2070 					;
2071 			} else {
2072 				int upper;
2073 
2074 				/* advance p and make output all one case */
2075 				upper = _M_ISUPPER(fcode);
2076 				for (p = bp; *p != '\0'; p++)
2077 					*p = upper? toupper(*p) : tolower(*p);
2078 			}
2079 			if (sign) {
2080 				prefix = _P_HYPHEN;
2081 				prefixlength = 1;
2082 			} else if (flagword & FPLUS) {
2083 				prefix = _P_PLUS;
2084 				prefixlength = 1;
2085 			} else if (flagword & FBLANK) {
2086 				prefix = _P_BLANK;
2087 				prefixlength = 1;
2088 			}
2089 			inf_nan = 0;
2090 			inf_nan_mixed_case = 0;
2091 			flagword &= ~PADZERO; /* ignore 0 flag */
2092 		}
2093 
2094 		/* Calculate number of padding blanks */
2095 		n = p - bp; /* n == size of the converted value (in bytes) */
2096 
2097 #ifdef	_WIDE
2098 		k = n;
2099 #else  /* _WIDE */
2100 		if (sec_display) /* when format is %s or %ws or %S */
2101 			k = sec_display;
2102 		else
2103 			k = n;
2104 #endif /* _WIDE */
2105 		/*
2106 		 * k is the (screen) width or # of bytes of the converted value
2107 		 */
2108 		k += prefixlength + otherlength;
2109 
2110 #ifdef	_WIDE
2111 		if (wflag) {
2112 			count += wcount;
2113 		} else {
2114 			count += n;
2115 		}
2116 #else  /* _WIDE */
2117 		/*
2118 		 * update count which is the overall size of the output data
2119 		 * and passed to memchr()
2120 		 */
2121 		if (wflag)
2122 			/*
2123 			 * when wflag != 0 (i.e. %ws or %wc), the size of the
2124 			 * converted value is wcount bytes
2125 			 */
2126 			count += wcount;
2127 		else
2128 			/*
2129 			 * when wflag == 0, the size of the converted
2130 			 * value is n (= p-bp) bytes
2131 			 */
2132 			count += n;
2133 #endif /* _WIDE */
2134 		count += prefixlength + otherlength;
2135 
2136 		if (width > k) {
2137 			count += (width - k);
2138 			/*
2139 			 * Set up for padding zeroes if requested
2140 			 * Otherwise emit padding blanks unless output is
2141 			 * to be left-justified.
2142 			 */
2143 
2144 			if (flagword & PADZERO) {
2145 				if (!(flagword & LZERO)) {
2146 					flagword |= LZERO;
2147 					lzero = width - k;
2148 				} else
2149 					lzero += width - k;
2150 				k = width; /* cancel padding blanks */
2151 			} else
2152 				/* Blanks on left if required */
2153 				if (!(flagword & FMINUS))
2154 					PAD(_blanks, width - k);
2155 		}
2156 
2157 		/* Prefix, if any */
2158 		if (prefixlength != 0)
2159 			PUT(prefix, prefixlength);
2160 
2161 		/* Zeroes on the left */
2162 		if ((flagword & LZERO)) /* && */
2163 			/* (!(flagword & SHORT) || !(flagword & FMINUS)) */
2164 			PAD(_zeroes, lzero);
2165 
2166 #ifdef	_WIDE
2167 		if (n > 0)
2168 			PUT(bp, n);
2169 		if ((fcode == 's') && !lflag) {
2170 			if (bp)
2171 				lfree(bp, bpsize);
2172 		}
2173 #else  /* _WIDE */
2174 		/* The value itself */
2175 		if ((fcode == 's' || fcode == 'S') && wflag) {
2176 			/* wide character handling */
2177 			wchar_t *wp = (wchar_t *)(uintptr_t)bp;
2178 			int cnt;
2179 			char *bufp;
2180 			long printn;
2181 			printn = (wchar_t *)(uintptr_t)p -
2182 				(wchar_t *)(uintptr_t)bp;
2183 			bufp = buf;
2184 			while (printn > 0) {
2185 				if ((cnt = wctomb(buf, *wp)) < 0)
2186 					cnt = 1;
2187 			PUT(bufp, cnt);
2188 				wp++;
2189 				printn--;
2190 			}
2191 		} else {	/* non wide character value */
2192 			if (n > 0)
2193 				PUT(bp, n);
2194 		}
2195 #endif /* _WIDE */
2196 
2197 		if (flagword & (RZERO | SUFFIX | FMINUS)) {
2198 			/* Zeroes on the right */
2199 			if (flagword & RZERO)
2200 				PAD(_zeroes, rzero);
2201 
2202 			/* The suffix */
2203 			if (flagword & SUFFIX)
2204 				PUT(suffix, suffixlength);
2205 
2206 			/* Blanks on the right if required */
2207 			if (flagword & FMINUS && width > k)
2208 				PAD(_blanks, width - k);
2209 		}
2210 	}
2211 }
2212 
2213 #ifdef	_WIDE
2214 static int
_watoi(wchar_t * fmt)2215 _watoi(wchar_t *fmt)
2216 {
2217 	int	n = 0;
2218 	wchar_t	ch;
2219 
2220 	ch = *fmt;
2221 	if (_M_ISDIGIT(ch)) {
2222 		n = ch - '0';
2223 		ch = *++fmt;
2224 		while (_M_ISDIGIT(ch)) {
2225 			n *= 10;
2226 			n += ch - '0';
2227 			ch = *++fmt;
2228 		}
2229 	}
2230 	return (n);
2231 }
2232 #endif /* _WIDE */
2233 
2234 /*
2235  * This function initializes arglst, to contain the appropriate va_list values
2236  * for the first MAXARGS arguments.
2237  */
2238 
2239 /*
2240  * Type modifier flags:
2241  *  0x01	for long
2242  *  0x02	for int
2243  *  0x04	for long long
2244  *  0x08	for long double
2245  */
2246 
2247 #define	FLAG_LONG	0x01
2248 #define	FLAG_INT	0x02
2249 #define	FLAG_LONG_LONG	0x04
2250 #define	FLAG_LONG_DBL	0x08
2251 
2252 /* ARGSUSED3 */
2253 #ifdef	_WIDE
2254 static void
_wmkarglst(wchar_t * fmt,stva_list args,stva_list arglst[],int prflag)2255 _wmkarglst(wchar_t *fmt, stva_list args, stva_list arglst[], int prflag)
2256 #else  /* _WIDE */
2257 static void
2258 _mkarglst(char *fmt, stva_list args, stva_list arglst[], int prflag)
2259 #endif /* _WIDE */
2260 {
2261 #ifdef	_WIDE
2262 	static const wchar_t	digits[] = L"01234567890";
2263 	static const wchar_t	skips[] = L"# +-.'0123456789h$";
2264 #else  /* _WIDE */
2265 	static const char digits[] = "01234567890";
2266 	static const char skips[] = "# +-.'0123456789h$";
2267 #endif /* _WIDE */
2268 	enum types {INT = 1, LONG, CHAR_PTR, DOUBLE, LONG_DOUBLE, VOID_PTR,
2269 		LONG_PTR, INT_PTR, LONG_LONG, LONG_LONG_PTR};
2270 	enum types typelst[MAXARGS], curtype;
2271 	ssize_t n;
2272 	int  maxnum, curargno, flags;
2273 
2274 	/*
2275 	 * Algorithm	1. set all argument types to zero.
2276 	 *		2. walk through fmt putting arg types in typelst[].
2277 	 *		3. walk through args using va_arg(args.ap, typelst[n])
2278 	 *		   and set arglst[] to the appropriate values.
2279 	 * Assumptions:	Cannot use %*$... to specify variable position.
2280 	 */
2281 
2282 	(void) memset((void *) typelst, 0, sizeof (typelst));
2283 	maxnum = -1;
2284 	curargno = 0;
2285 	while ((fmt = STRCHR(fmt, '%')) != 0) {
2286 		fmt++;	/* skip % */
2287 		if (fmt[n = STRSPN(fmt, digits)] == '$') {
2288 			/* convert to zero base */
2289 			curargno = ATOI(fmt) - 1;
2290 			if (curargno < 0)
2291 				continue;
2292 			fmt += n + 1;
2293 		}
2294 		flags = 0;
2295 	again:;
2296 		fmt += STRSPN(fmt, skips);
2297 		switch (*fmt++) {
2298 		case '%':	/* there is no argument! */
2299 			continue;
2300 		case 'l':
2301 			if (flags & (FLAG_LONG | FLAG_LONG_LONG)) {
2302 				flags |= FLAG_LONG_LONG;
2303 				flags &= ~FLAG_LONG;
2304 			} else {
2305 				flags |= FLAG_LONG;
2306 			}
2307 			goto again;
2308 		case 'j':
2309 #ifndef _LP64
2310 			/*
2311 			 * *printf_c89() in 32-bit libc uses
2312 			 * 32-bit intmax_t; otherwise intmax_t
2313 			 * is 64-bits.
2314 			 */
2315 			if (!(prflag & _F_INTMAX32)) {
2316 #endif
2317 				flags |= FLAG_LONG_LONG;	/* 64-bit */
2318 #ifndef _LP64
2319 			}
2320 #endif
2321 			goto again;
2322 		case 't':
2323 			flags |= FLAG_LONG;
2324 			goto again;
2325 		case 'z':
2326 			flags |= FLAG_LONG;
2327 			goto again;
2328 		case 'L':
2329 			flags |= FLAG_LONG_DBL;
2330 			goto again;
2331 		case '*':	/* int argument used for value */
2332 			/* check if there is a positional parameter */
2333 #ifdef	_WIDE
2334 			if ((*fmt >= 0) && (*fmt < 256) &&
2335 				isdigit(*fmt))
2336 #else  /* _WIDE */
2337 			if (isdigit(*fmt))
2338 #endif /* _WIDE */
2339 			{
2340 				int	targno;
2341 				targno = ATOI(fmt) - 1;
2342 				fmt += STRSPN(fmt, digits);
2343 				if (*fmt == '$')
2344 					fmt++; /* skip '$' */
2345 				if (targno >= 0 && targno < MAXARGS) {
2346 					typelst[targno] = INT;
2347 					if (maxnum < targno)
2348 						maxnum = targno;
2349 				}
2350 				goto again;
2351 			}
2352 			flags |= FLAG_INT;
2353 			curtype = INT;
2354 			break;
2355 		case 'a':
2356 		case 'A':
2357 		case 'e':
2358 		case 'E':
2359 		case 'f':
2360 		case 'F':
2361 		case 'g':
2362 		case 'G':
2363 			if (flags & FLAG_LONG_DBL)
2364 				curtype = LONG_DOUBLE;
2365 			else
2366 				curtype = DOUBLE;
2367 			break;
2368 		case 's':
2369 			curtype = CHAR_PTR;
2370 			break;
2371 		case 'p':
2372 			curtype = VOID_PTR;
2373 			break;
2374 		case 'n':
2375 			if (flags & FLAG_LONG_LONG)
2376 				curtype = LONG_LONG_PTR;
2377 			else if (flags & FLAG_LONG)
2378 				curtype = LONG_PTR;
2379 			else
2380 				curtype = INT_PTR;
2381 			break;
2382 		default:
2383 			if (flags & FLAG_LONG_LONG)
2384 				curtype = LONG_LONG;
2385 			else if (flags & FLAG_LONG)
2386 				curtype = LONG;
2387 			else
2388 				curtype = INT;
2389 			break;
2390 		}
2391 		if (curargno >= 0 && curargno < MAXARGS) {
2392 			typelst[curargno] = curtype;
2393 			if (maxnum < curargno)
2394 				maxnum = curargno;
2395 		}
2396 		curargno++;	/* default to next in list */
2397 		if (flags & FLAG_INT)	/* took care of *, keep going */
2398 		{
2399 			flags ^= FLAG_INT;
2400 			goto again;
2401 		}
2402 	}
2403 	for (n = 0; n <= maxnum; n++) {
2404 		arglst[n] = args;
2405 		if (typelst[n] == 0)
2406 			typelst[n] = INT;
2407 
2408 		switch (typelst[n]) {
2409 		case INT:
2410 			(void) va_arg(args.ap, int);
2411 			break;
2412 		case LONG:
2413 			(void) va_arg(args.ap, long);
2414 			break;
2415 		case CHAR_PTR:
2416 			(void) va_arg(args.ap, char *);
2417 			break;
2418 		case DOUBLE:
2419 			(void) va_arg(args.ap, double);
2420 			break;
2421 		case LONG_DOUBLE:
2422 			(void) GETQVAL(args.ap);
2423 			break;
2424 		case VOID_PTR:
2425 			(void) va_arg(args.ap, void *);
2426 			break;
2427 		case LONG_PTR:
2428 			(void) va_arg(args.ap, long *);
2429 			break;
2430 		case INT_PTR:
2431 			(void) va_arg(args.ap, int *);
2432 			break;
2433 		case LONG_LONG:
2434 			(void) va_arg(args.ap, long long);
2435 			break;
2436 		case LONG_LONG_PTR:
2437 			(void) va_arg(args.ap, long long *);
2438 			break;
2439 		}
2440 	}
2441 }
2442 
2443 /*
2444  * This function is used to find the va_list value for arguments whose
2445  * position is greater than MAXARGS.  This function is slow, so hopefully
2446  * MAXARGS will be big enough so that this function need only be called in
2447  * unusual circumstances.
2448  * pargs is assumed to contain the value of arglst[MAXARGS - 1].
2449  */
2450 /* ARGSUSED3 */
2451 #ifdef	_WIDE
2452 static void
_wgetarg(wchar_t * fmt,stva_list * pargs,long argno,int prflag)2453 _wgetarg(wchar_t *fmt, stva_list *pargs, long argno, int prflag)
2454 #else  /* _WIDE */
2455 void
2456 _getarg(char *fmt, stva_list *pargs, long argno, int prflag)
2457 #endif /* _WIDE */
2458 {
2459 
2460 #ifdef	_WIDE
2461 	static const wchar_t	digits[] = L"01234567890";
2462 	static const wchar_t	skips[] = L"# +-.'0123456789h$";
2463 	wchar_t	*sfmt = fmt;
2464 #else  /* _WIDE */
2465 	static const char digits[] = "01234567890";
2466 	static const char skips[] = "# +-.'0123456789h$";
2467 	char	*sfmt = fmt;
2468 #endif /* _WIDE */
2469 	ssize_t n;
2470 	int i, curargno, flags;
2471 	int	found = 1;
2472 
2473 	i = MAXARGS;
2474 	curargno = 1;
2475 	while (found) {
2476 		fmt = sfmt;
2477 		found = 0;
2478 		while ((i != argno) && (fmt = STRCHR(fmt, '%')) != 0) {
2479 			fmt++;	/* skip % */
2480 			if (fmt[n = STRSPN(fmt, digits)] == '$') {
2481 				curargno = ATOI(fmt);
2482 				if (curargno <= 0)
2483 					continue;
2484 				fmt += n + 1;
2485 			}
2486 
2487 			/* find conversion specifier for next argument */
2488 			if (i != curargno) {
2489 				curargno++;
2490 				continue;
2491 			} else
2492 				found = 1;
2493 			flags = 0;
2494 		again:;
2495 			fmt += STRSPN(fmt, skips);
2496 			switch (*fmt++) {
2497 			case '%':	/* there is no argument! */
2498 				continue;
2499 			case 'l':
2500 				if (flags & (FLAG_LONG | FLAG_LONG_LONG)) {
2501 					flags |= FLAG_LONG_LONG;
2502 					flags &= ~FLAG_LONG;
2503 				} else {
2504 					flags |= FLAG_LONG;
2505 				}
2506 				goto again;
2507 			case 'j':
2508 #ifndef _LP64
2509 				/*
2510 				 * *printf_c89() in 32-bit libc uses
2511 				 * 32-bit intmax_t; otherwise intmax_t
2512 				 * is 64-bits.
2513 				 */
2514 				if (!(prflag & _F_INTMAX32)) {
2515 #endif
2516 					flags |= FLAG_LONG_LONG;  /* 64-bit */
2517 #ifndef _LP64
2518 				}
2519 #endif
2520 				goto again;
2521 			case 't':
2522 				flags |= FLAG_LONG;
2523 				goto again;
2524 			case 'z':
2525 				flags |= FLAG_LONG;
2526 				goto again;
2527 			case 'L':
2528 				flags |= FLAG_LONG_DBL;
2529 				goto again;
2530 			case '*':	/* int argument used for value */
2531 				/*
2532 				 * check if there is a positional parameter;
2533 				 * if so, just skip it; its size will be
2534 				 * correctly determined by default
2535 				 */
2536 				if (_M_ISDIGIT(*fmt)) {
2537 					fmt += STRSPN(fmt, digits);
2538 					if (*fmt == '$')
2539 						fmt++; /* skip '$' */
2540 					goto again;
2541 				}
2542 				flags |= FLAG_INT;
2543 				(void) va_arg((*pargs).ap, int);
2544 				break;
2545 			case 'a':
2546 			case 'A':
2547 			case 'e':
2548 			case 'E':
2549 			case 'f':
2550 			case 'F':
2551 			case 'g':
2552 			case 'G':
2553 				if (flags & FLAG_LONG_DBL)
2554 					(void) GETQVAL((*pargs).ap);
2555 				else
2556 					(void) va_arg((*pargs).ap, double);
2557 				break;
2558 			case 's':
2559 				(void) va_arg((*pargs).ap, char *);
2560 				break;
2561 			case 'p':
2562 				(void) va_arg((*pargs).ap, void *);
2563 				break;
2564 			case 'n':
2565 				if (flags & FLAG_LONG_LONG)
2566 					(void) va_arg((*pargs).ap, long long *);
2567 				else if (flags & FLAG_LONG)
2568 					(void) va_arg((*pargs).ap, long *);
2569 				else
2570 					(void) va_arg((*pargs).ap, int *);
2571 				break;
2572 			default:
2573 				if (flags & FLAG_LONG_LONG)
2574 					(void) va_arg((*pargs).ap, long long);
2575 				else if (flags & FLAG_LONG)
2576 					(void) va_arg((*pargs).ap, long int);
2577 				else
2578 					(void) va_arg((*pargs).ap, int);
2579 				break;
2580 			}
2581 			i++;
2582 			curargno++;	/* default to next in list */
2583 			if (flags & FLAG_INT)	/* took care of *, keep going */
2584 			{
2585 				flags ^= FLAG_INT;
2586 				goto again;
2587 			}
2588 		}
2589 
2590 		/* missing specifier for parameter, assume param is an int */
2591 		if (!found && i != argno) {
2592 			(void) va_arg((*pargs).ap, int);
2593 			i++;
2594 			curargno = i;
2595 			found = 1;
2596 		}
2597 	}
2598 }
2599 
2600 #ifdef	_WIDE
2601 static wchar_t *
insert_thousands_sep(wchar_t * bp,wchar_t * ep)2602 insert_thousands_sep(wchar_t *bp, wchar_t *ep)
2603 #else  /* _WIDE */
2604 static char *
2605 insert_thousands_sep(char *bp, char *ep)
2606 #endif /* _WIDE */
2607 {
2608 	char thousep;
2609 	struct lconv *locptr;
2610 	ssize_t buf_index;
2611 	int i;
2612 #ifdef	_WIDE
2613 	wchar_t *obp = bp;
2614 	wchar_t buf[371];
2615 	wchar_t *bufptr = buf;
2616 #else  /* _WIDE */
2617 	char *obp = bp;
2618 	char buf[371];
2619 	char *bufptr = buf;
2620 #endif /* _WIDE */
2621 	char *grp_ptr;
2622 
2623 	/* get the thousands sep. from the current locale */
2624 	locptr = localeconv();
2625 	thousep	= *locptr->thousands_sep;
2626 	grp_ptr = locptr->grouping;
2627 
2628 	/* thousands sep. not use in this locale or no grouping required */
2629 	if (!thousep || (*grp_ptr == '\0'))
2630 		return (ep);
2631 
2632 	buf_index = ep - bp;
2633 	for (;;) {
2634 		if (*grp_ptr == CHAR_MAX) {
2635 			for (i = 0; i < buf_index--; i++)
2636 				*bufptr++ = *(bp + buf_index);
2637 			break;
2638 		}
2639 		for (i = 0; i < *grp_ptr && buf_index-- > 0; i++)
2640 			*bufptr++ = *(bp + buf_index);
2641 
2642 		if (buf_index > 0) {
2643 #ifdef	_WIDE
2644 			*bufptr++ = (wchar_t)thousep;
2645 #else  /* _WIDE */
2646 			*bufptr++ = thousep;
2647 #endif /* _WIDE */
2648 			ep++;
2649 		}
2650 		else
2651 			break;
2652 		if (*(grp_ptr + 1) != '\0')
2653 			++grp_ptr;
2654 	}
2655 
2656 	/* put the string in the caller's buffer in reverse order */
2657 	--bufptr;
2658 	while (buf <= bufptr)
2659 		*obp++ = *bufptr--;
2660 	return (ep);
2661 }
2662 
2663 #ifdef _WIDE
2664 static wchar_t *
insert_decimal_point(wchar_t * ep)2665 insert_decimal_point(wchar_t *ep)
2666 #else
2667 static char *
2668 insert_decimal_point(char *ep)
2669 #endif
2670 {
2671 	struct lconv *locptr = localeconv();
2672 	char	*dp = locptr->decimal_point;
2673 #ifdef _WIDE
2674 	wchar_t wdp;
2675 
2676 	(void) mbtowc(&wdp, dp, MB_CUR_MAX);
2677 	*ep = wdp;
2678 	return (ep + 1);
2679 #else
2680 	(void) memcpy(ep, dp, strlen(dp));
2681 	return (ep + strlen(dp));
2682 #endif
2683 }
2684 
2685 
2686 /*
2687  *  Recovery scrswidth function -
2688  *  this variant of wcswidth() accepts non-printable or illegal
2689  *  widechar characters.
2690  */
2691 static int
_rec_scrswidth(wchar_t * wp,ssize_t n)2692 _rec_scrswidth(wchar_t *wp, ssize_t n)
2693 {
2694 	int col;
2695 	int i;
2696 
2697 	col = 0;
2698 	while (*wp && (n-- > 0)) {
2699 		if ((i = _scrwidth(*wp++)) == 0)
2700 			i = 1;
2701 		col += i;
2702 	}
2703 	return (col);
2704 }
2705