?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
9511 printf family isn't aware of multibyte decimal point characters (fix regression)
[unleashed.git] / usr / src / lib / libc / port / print / doprnt.c
blobe8cfaad6debfc5394f88bc02d46c460e154a3d5c
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
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
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
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
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
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
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
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
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, NULL)) ==
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
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
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
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 *
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 *
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
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 }
Unleashed OS