![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to snprintf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / compat|
Return to snprintf.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / compat |
1.1 misho 1: /*
2: * Copyright (c) 1999-2005, 2008, 2010-2011
3: * Todd C. Miller <Todd.Miller@courtesan.com>
4: * Copyright (c) 1990, 1993
5: * The Regents of the University of California. All rights reserved.
6: *
7: * This code is derived from software contributed to Berkeley by
8: * Chris Torek.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: * 3. Neither the name of the University nor the names of its contributors
19: * may be used to endorse or promote products derived from this software
20: * without specific prior written permission.
21: *
22: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32: * SUCH DAMAGE.
33: *
34: * From: @(#)vfprintf.c 8.1 (Berkeley) 6/4/93
35: */
36:
37: /*
38: * v?snprintf/v?asprintf based on 4.4BSD stdio.
39: * NOTE: does not support floating point.
40: */
41:
42: #include <config.h>
43:
44: #include <sys/types.h>
45: #include <sys/param.h>
46:
47: #include <stdio.h>
48: #ifdef STDC_HEADERS
49: # include <stdlib.h>
50: # include <stddef.h>
51: #else
52: # ifdef HAVE_STDLIB_H
53: # include <stdlib.h>
54: # endif
55: #endif /* STDC_HEADERS */
56: #ifdef HAVE_STDINT_H
57: # include <stdint.h>
58: #endif
59: #ifdef HAVE_STRING_H
60: # if defined(HAVE_MEMORY_H) && !defined(STDC_HEADERS)
61: # include <memory.h>
62: # endif
63: # include <string.h>
64: #endif /* HAVE_STRING_H */
65: #ifdef HAVE_STRINGS_H
66: # include <strings.h>
67: #endif /* HAVE_STRINGS_H */
68: #if defined(HAVE_MALLOC_H) && !defined(STDC_HEADERS)
69: # include <malloc.h>
70: #endif /* HAVE_MALLOC_H && !STDC_HEADERS */
71: #include <limits.h>
72: #include <stdarg.h>
73:
74: #include "missing.h"
75:
76: static int xxxprintf(char **, size_t, int, const char *, va_list);
77:
78: /*
79: * Some systems may not have these defined in <limits.h>
80: */
81: #ifndef ULONG_MAX
82: # define ULONG_MAX ((unsigned long)-1)
83: #endif
84: #ifndef LONG_MAX
85: # define LONG_MAX (ULONG_MAX / 2)
86: #endif
87: #ifdef HAVE_LONG_LONG_INT
88: # ifndef ULLONG_MAX
89: # ifdef UQUAD_MAX
90: # define ULLONG_MAX UQUAD_MAX
91: # else
92: # define ULLONG_MAX ((unsigned long long)-1)
93: # endif
94: # endif
95: # ifndef LLONG_MAX
96: # ifdef QUAD_MAX
97: # define LLONG_MAX QUAD_MAX
98: # else
99: # define LLONG_MAX (ULLONG_MAX / 2)
100: # endif
101: # endif
102: #endif /* HAVE_LONG_LONG_INT */
103:
104: /*
105: * Macros for converting digits to letters and vice versa
106: */
107: #define to_digit(c) ((c) - '0')
108: #define is_digit(c) ((unsigned int)to_digit(c) <= 9)
109: #define to_char(n) ((n) + '0')
110:
111: /*
112: * Flags used during conversion.
113: */
114: #define ALT 0x001 /* alternate form */
115: #define HEXPREFIX 0x002 /* add 0x or 0X prefix */
116: #define LADJUST 0x004 /* left adjustment */
117: #define LONGDBL 0x008 /* long double; unimplemented */
118: #define LONGINT 0x010 /* long integer */
119: #define QUADINT 0x020 /* quad integer */
120: #define SHORTINT 0x040 /* short integer */
121: #define ZEROPAD 0x080 /* zero (as opposed to blank) pad */
122:
123: #define BUF 68
124:
125: /*
126: * Convert an unsigned long to ASCII for printf purposes, returning
127: * a pointer to the first character of the string representation.
128: * Octal numbers can be forced to have a leading zero; hex numbers
129: * use the given digits.
130: */
131: static char *
132: __ultoa(unsigned long val, char *endp, int base, int octzero, char *xdigs)
133: {
134: char *cp = endp;
135: long sval;
136:
137: /*
138: * Handle the three cases separately, in the hope of getting
139: * better/faster code.
140: */
141: switch (base) {
142: case 10:
143: if (val < 10) { /* many numbers are 1 digit */
144: *--cp = to_char(val);
145: return cp;
146: }
147: /*
148: * On many machines, unsigned arithmetic is harder than
149: * signed arithmetic, so we do at most one unsigned mod and
150: * divide; this is sufficient to reduce the range of
151: * the incoming value to where signed arithmetic works.
152: */
153: if (val > LONG_MAX) {
154: *--cp = to_char(val % 10);
155: sval = val / 10;
156: } else
157: sval = val;
158: do {
159: *--cp = to_char(sval % 10);
160: sval /= 10;
161: } while (sval != 0);
162: break;
163:
164: case 8:
165: do {
166: *--cp = to_char(val & 7);
167: val >>= 3;
168: } while (val);
169: if (octzero && *cp != '0')
170: *--cp = '0';
171: break;
172:
173: case 16:
174: do {
175: *--cp = xdigs[val & 15];
176: val >>= 4;
177: } while (val);
178: break;
179:
180: default: /* oops */
181: abort();
182: }
183: return cp;
184: }
185:
186: /* Identical to __ultoa, but for quads. */
187: #ifdef HAVE_LONG_LONG_INT
188: # if SIZEOF_LONG_INT == 8
189: # define __uqtoa(v, e, b, o, x) __ultoa((unsigned long)(v), (e), (b), (o), (x))
190: # else
191: static char *
192: __uqtoa(unsigned long long val, char *endp, int base, int octzero, char *xdigs)
193: {
194: char *cp = endp;
195: long long sval;
196:
197: /* quick test for small values; __ultoa is typically much faster */
198: /* (perhaps instead we should run until small, then call __ultoa?) */
199: if (val <= (unsigned long long)ULONG_MAX)
200: return __ultoa((unsigned long)val, endp, base, octzero, xdigs);
201: switch (base) {
202: case 10:
203: if (val < 10) {
204: *--cp = to_char(val % 10);
205: return cp;
206: }
207: if (val > LLONG_MAX) {
208: *--cp = to_char(val % 10);
209: sval = val / 10;
210: } else
211: sval = val;
212: do {
213: *--cp = to_char(sval % 10);
214: sval /= 10;
215: } while (sval != 0);
216: break;
217:
218: case 8:
219: do {
220: *--cp = to_char(val & 7);
221: val >>= 3;
222: } while (val);
223: if (octzero && *cp != '0')
224: *--cp = '0';
225: break;
226:
227: case 16:
228: do {
229: *--cp = xdigs[val & 15];
230: val >>= 4;
231: } while (val);
232: break;
233:
234: default: /* oops */
235: abort();
236: }
237: return cp;
238: }
239: # endif /* !SIZEOF_LONG_INT */
240: #endif /* HAVE_LONG_LONG_INT */
241:
242: /*
243: * Actual printf innards.
244: */
245: static int
246: xxxprintf(char **strp, size_t strsize, int alloc, const char *fmt0, va_list ap)
247: {
248: char *fmt; /* format string */
249: int ch; /* character from fmt */
250: int n; /* handy integer (short term usage) */
251: char *cp; /* handy char pointer (short term usage) */
252: int flags; /* flags as above */
253: int ret; /* return value accumulator */
254: int width; /* width from format (%8d), or 0 */
255: int prec; /* precision from format (%.3d), or -1 */
256: char sign; /* sign prefix (' ', '+', '-', or \0) */
257: unsigned long ulval = 0; /* integer arguments %[diouxX] */
258: #ifdef HAVE_LONG_LONG_INT
259: unsigned long long uqval = 0; /* %q (quad) integers */
260: #endif
261: int base; /* base for [diouxX] conversion */
262: int dprec; /* a copy of prec if [diouxX], 0 otherwise */
263: int fieldsz; /* field size expanded by sign, etc */
264: int realsz; /* field size expanded by dprec */
265: int size; /* size of converted field or string */
266: char *xdigs = ""; /* digits for [xX] conversion */
267: char buf[BUF]; /* space for %c, %[diouxX], %[eEfgG] */
268: char ox[2]; /* space for 0x hex-prefix */
269: char *str; /* pointer to string to fill */
270: char *estr; /* pointer to last char in str */
271:
272: /*
273: * Choose PADSIZE to trade efficiency vs. size. If larger printf
274: * fields occur frequently, increase PADSIZE and make the initialisers
275: * below longer.
276: */
277: #define PADSIZE 16 /* pad chunk size */
278: static char blanks[PADSIZE] =
279: {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '};
280: static char zeroes[PADSIZE] =
281: {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};
282:
283: /* Print chars to "str", (allocate as needed if alloc is set). */
284: #define PRINT(ptr, len) do { \
285: const char *p = ptr; \
286: const char *endp = ptr + len; \
287: while (p < endp && (str < estr || alloc)) { \
288: if (alloc && str >= estr) { \
289: char *t; \
290: strsize = (strsize << 1) + 1; \
291: if (!(t = (char *)realloc(*strp, strsize))) { \
292: free(str); \
293: *strp = NULL; \
294: ret = -1; \
295: goto done; \
296: } \
297: str = t + (str - *strp); \
298: estr = t + strsize - 1; \
299: *strp = t; \
300: } \
301: *str++ = *p++; \
302: } \
303: } while (0)
304:
305: /* BEWARE, PAD uses `n'. */
306: #define PAD(plen, pstr) do { \
307: if ((n = (plen)) > 0) { \
308: while (n > PADSIZE) { \
309: PRINT(pstr, PADSIZE); \
310: n -= PADSIZE; \
311: } \
312: PRINT(pstr, n); \
313: } \
314: } while (0)
315:
316: /*
317: * To extend shorts properly, we need both signed and unsigned
318: * argument extraction methods.
319: */
320: #define SARG() \
321: (flags&LONGINT ? va_arg(ap, long) : \
322: flags&SHORTINT ? (long)(short)va_arg(ap, int) : \
323: (long)va_arg(ap, int))
324: #define UARG() \
325: (flags&LONGINT ? va_arg(ap, unsigned long) : \
326: flags&SHORTINT ? (unsigned long)(unsigned short)va_arg(ap, int) : \
327: (unsigned long)va_arg(ap, unsigned int))
328:
329: fmt = (char *)fmt0;
330: ret = 0;
331:
332: if (alloc) {
333: strsize = 128;
334: *strp = str = (char *)malloc(strsize);
335: if (str == NULL) {
336: ret = -1;
337: goto done;
338: }
339: estr = str + 127;
340: } else {
341: str = *strp;
342: if (strsize)
343: estr = str + strsize - 1;
344: else
345: estr = NULL;
346: }
347:
348: /*
349: * Scan the format for conversions (`%' character).
350: */
351: for (;;) {
352: for (cp = fmt; (ch = *fmt) != '\0' && ch != '%'; fmt++)
353: /* void */;
354: if ((n = fmt - cp) != 0) {
355: PRINT(cp, n);
356: ret += n;
357: }
358: if (ch == '\0')
359: goto done;
360: fmt++; /* skip over '%' */
361:
362: flags = 0;
363: dprec = 0;
364: width = 0;
365: prec = -1;
366: sign = '\0';
367:
368: rflag: ch = *fmt++;
369: reswitch: switch (ch) {
370: case ' ':
371: /*
372: * ``If the space and + flags both appear, the space
373: * flag will be ignored.''
374: * -- ANSI X3J11
375: */
376: if (!sign)
377: sign = ' ';
378: goto rflag;
379: case '#':
380: flags |= ALT;
381: goto rflag;
382: case '*':
383: /*
384: * ``A negative field width argument is taken as a
385: * - flag followed by a positive field width.''
386: * -- ANSI X3J11
387: * They don't exclude field widths read from args.
388: */
389: if ((width = va_arg(ap, int)) >= 0)
390: goto rflag;
391: width = -width;
392: /* FALLTHROUGH */
393: case '-':
394: flags |= LADJUST;
395: goto rflag;
396: case '+':
397: sign = '+';
398: goto rflag;
399: case '.':
400: if ((ch = *fmt++) == '*') {
401: n = va_arg(ap, int);
402: prec = n < 0 ? -1 : n;
403: goto rflag;
404: }
405: n = 0;
406: while (is_digit(ch)) {
407: n = 10 * n + to_digit(ch);
408: ch = *fmt++;
409: }
410: prec = n < 0 ? -1 : n;
411: goto reswitch;
412: case '0':
413: /*
414: * ``Note that 0 is taken as a flag, not as the
415: * beginning of a field width.''
416: * -- ANSI X3J11
417: */
418: flags |= ZEROPAD;
419: goto rflag;
420: case '1': case '2': case '3': case '4':
421: case '5': case '6': case '7': case '8': case '9':
422: n = 0;
423: do {
424: n = 10 * n + to_digit(ch);
425: ch = *fmt++;
426: } while (is_digit(ch));
427: width = n;
428: goto reswitch;
429: case 'h':
430: flags |= SHORTINT;
431: goto rflag;
432: case 'l':
433: flags |= LONGINT;
434: goto rflag;
435: #ifdef HAVE_LONG_LONG_INT
436: case 'q':
437: flags |= QUADINT;
438: goto rflag;
439: #endif /* HAVE_LONG_LONG_INT */
440: case 'c':
441: *(cp = buf) = va_arg(ap, int);
442: size = 1;
443: sign = '\0';
444: break;
445: case 'D':
446: flags |= LONGINT;
447: /*FALLTHROUGH*/
448: case 'd':
449: case 'i':
450: #ifdef HAVE_LONG_LONG_INT
451: if (flags & QUADINT) {
452: uqval = va_arg(ap, long long);
453: if ((long long)uqval < 0) {
454: uqval = -uqval;
455: sign = '-';
456: }
457: }
458: else
459: #endif /* HAVE_LONG_LONG_INT */
460: {
461: ulval = SARG();
462: if ((long)ulval < 0) {
463: ulval = -ulval;
464: sign = '-';
465: }
466: }
467: base = 10;
468: goto number;
469: case 'n':
470: #ifdef HAVE_LONG_LONG_INT
471: if (flags & QUADINT)
472: *va_arg(ap, long long *) = ret;
473: else
474: #endif /* HAVE_LONG_LONG_INT */
475: if (flags & LONGINT)
476: *va_arg(ap, long *) = ret;
477: else if (flags & SHORTINT)
478: *va_arg(ap, short *) = ret;
479: else
480: *va_arg(ap, int *) = ret;
481: continue; /* no output */
482: case 'O':
483: flags |= LONGINT;
484: /*FALLTHROUGH*/
485: case 'o':
486: #ifdef HAVE_LONG_LONG_INT
487: if (flags & QUADINT)
488: uqval = va_arg(ap, unsigned long long);
489: else
490: #endif /* HAVE_LONG_LONG_INT */
491: ulval = UARG();
492: base = 8;
493: goto nosign;
494: case 'p':
495: /*
496: * ``The argument shall be a pointer to void. The
497: * value of the pointer is converted to a sequence
498: * of printable characters, in an implementation-
499: * defined manner.''
500: * -- ANSI X3J11
501: */
502: ulval = (unsigned long)va_arg(ap, void *);
503: base = 16;
504: xdigs = "0123456789abcdef";
505: flags = (flags & ~QUADINT) | HEXPREFIX;
506: ch = 'x';
507: goto nosign;
508: case 's':
509: if ((cp = va_arg(ap, char *)) == NULL)
510: cp = "(null)";
511: if (prec >= 0) {
512: /*
513: * can't use strlen; can only look for the
514: * NUL in the first `prec' characters, and
515: * strlen() will go further.
516: */
517: char *p = memchr(cp, 0, prec);
518:
519: if (p != NULL) {
520: size = p - cp;
521: if (size > prec)
522: size = prec;
523: } else
524: size = prec;
525: } else
526: size = strlen(cp);
527: sign = '\0';
528: break;
529: case 'U':
530: flags |= LONGINT;
531: /*FALLTHROUGH*/
532: case 'u':
533: #ifdef HAVE_LONG_LONG_INT
534: if (flags & QUADINT)
535: uqval = va_arg(ap, unsigned long long);
536: else
537: #endif /* HAVE_LONG_LONG_INT */
538: ulval = UARG();
539: base = 10;
540: goto nosign;
541: case 'X':
542: xdigs = "0123456789ABCDEF";
543: goto hex;
544: case 'x':
545: xdigs = "0123456789abcdef";
546: hex:
547: #ifdef HAVE_LONG_LONG_INT
548: if (flags & QUADINT)
549: uqval = va_arg(ap, unsigned long long);
550: else
551: #endif /* HAVE_LONG_LONG_INT */
552: ulval = UARG();
553: base = 16;
554: /* leading 0x/X only if non-zero */
555: if (flags & ALT &&
556: #ifdef HAVE_LONG_LONG_INT
557: (flags & QUADINT ? uqval != 0 : ulval != 0))
558: #else
559: ulval != 0)
560: #endif /* HAVE_LONG_LONG_INT */
561: flags |= HEXPREFIX;
562:
563: /* unsigned conversions */
564: nosign: sign = '\0';
565: /*
566: * ``... diouXx conversions ... if a precision is
567: * specified, the 0 flag will be ignored.''
568: * -- ANSI X3J11
569: */
570: number: if ((dprec = prec) >= 0)
571: flags &= ~ZEROPAD;
572:
573: /*
574: * ``The result of converting a zero value with an
575: * explicit precision of zero is no characters.''
576: * -- ANSI X3J11
577: */
578: cp = buf + BUF;
579: #ifdef HAVE_LONG_LONG_INT
580: if (flags & QUADINT) {
581: if (uqval != 0 || prec != 0)
582: cp = __uqtoa(uqval, cp, base,
583: flags & ALT, xdigs);
584: }
585: else
586: #endif /* HAVE_LONG_LONG_INT */
587: {
588: if (ulval != 0 || prec != 0)
589: cp = __ultoa(ulval, cp, base,
590: flags & ALT, xdigs);
591: }
592: size = buf + BUF - cp;
593: break;
594: default: /* "%?" prints ?, unless ? is NUL */
595: if (ch == '\0')
596: goto done;
597: /* pretend it was %c with argument ch */
598: cp = buf;
599: *cp = ch;
600: size = 1;
601: sign = '\0';
602: break;
603: }
604:
605: /*
606: * All reasonable formats wind up here. At this point, `cp'
607: * points to a string which (if not flags&LADJUST) should be
608: * padded out to `width' places. If flags&ZEROPAD, it should
609: * first be prefixed by any sign or other prefix; otherwise,
610: * it should be blank padded before the prefix is emitted.
611: * After any left-hand padding and prefixing, emit zeroes
612: * required by a decimal [diouxX] precision, then print the
613: * string proper, then emit zeroes required by any leftover
614: * floating precision; finally, if LADJUST, pad with blanks.
615: *
616: * Compute actual size, so we know how much to pad.
617: * fieldsz excludes decimal prec; realsz includes it.
618: */
619: fieldsz = size;
620: if (sign)
621: fieldsz++;
622: else if (flags & HEXPREFIX)
623: fieldsz += 2;
624: realsz = dprec > fieldsz ? dprec : fieldsz;
625:
626: /* right-adjusting blank padding */
627: if ((flags & (LADJUST|ZEROPAD)) == 0)
628: PAD(width - realsz, blanks);
629:
630: /* prefix */
631: if (sign) {
632: PRINT(&sign, 1);
633: } else if (flags & HEXPREFIX) {
634: ox[0] = '0';
635: ox[1] = ch;
636: PRINT(ox, 2);
637: }
638:
639: /* right-adjusting zero padding */
640: if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
641: PAD(width - realsz, zeroes);
642:
643: /* leading zeroes from decimal precision */
644: PAD(dprec - fieldsz, zeroes);
645:
646: /* the string or number proper */
647: PRINT(cp, size);
648:
649: /* left-adjusting padding (always blank) */
650: if (flags & LADJUST)
651: PAD(width - realsz, blanks);
652:
653: /* finally, adjust ret */
654: ret += width > realsz ? width : realsz;
655: }
656: done:
657: if (strsize)
658: *str = '\0';
659: return ret;
660: /* NOTREACHED */
661: }
662:
663: #ifndef HAVE_VSNPRINTF
664: int
665: vsnprintf(char *str, size_t n, const char *fmt, va_list ap)
666: {
667:
668: return xxxprintf(&str, n, 0, fmt, ap);
669: }
670: #endif /* HAVE_VSNPRINTF */
671:
672: #ifndef HAVE_SNPRINTF
673: int
674: snprintf(char *str, size_t n, char const *fmt, ...)
675: {
676: int ret;
677: va_list ap;
678:
679: va_start(ap, fmt);
680: ret = xxxprintf(&str, n, 0, fmt, ap);
681: va_end(ap);
682: return ret;
683: }
684: #endif /* HAVE_SNPRINTF */
685:
686: #ifndef HAVE_VASPRINTF
687: int
688: vasprintf(char **str, const char *fmt, va_list ap)
689: {
690:
691: return xxxprintf(str, 0, 1, fmt, ap);
692: }
693: #endif /* HAVE_VASPRINTF */
694:
695: #ifndef HAVE_ASPRINTF
696: int
697: asprintf(char **str, char const *fmt, ...)
698: {
699: int ret;
700: va_list ap;
701:
702: va_start(ap, fmt);
703: ret = xxxprintf(str, 0, 1, fmt, ap);
704: va_end(ap);
705: return ret;
706: }
707: #endif /* HAVE_ASPRINTF */