/* * Copyright (c) 1999-2005 Todd C. Miller * Copyright (c) 1990, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Chris Torek. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * From: @(#)vfprintf.c 8.1 (Berkeley) 6/4/93 */ /* * v?snprintf/v?asprintf based on 4.4BSD stdio. * NOTE: does not support floating point. */ #include #include #include #include #ifdef STDC_HEADERS # include # include #else # ifdef HAVE_STDLIB_H # include # endif #endif /* STDC_HEADERS */ #ifdef HAVE_STRING_H # if defined(HAVE_MEMORY_H) && !defined(STDC_HEADERS) # include # endif # include #else # ifdef HAVE_STRINGS_H # include # endif #endif /* HAVE_STRING_H */ #if defined(HAVE_MALLOC_H) && !defined(STDC_HEADERS) # include #endif /* HAVE_MALLOC_H && !STDC_HEADERS */ #include #ifdef __STDC__ # include #else # include #endif #include #ifndef lint __unused static const char rcsid[] = "$Sudo: snprintf.c,v 1.14.4.2 2007/06/12 01:28:42 millert Exp $"; #endif /* lint */ static int xxxprintf __P((char **, size_t, int, const char *, va_list)); /* * Some systems may not have these defined in */ #ifndef ULONG_MAX # define ULONG_MAX ((unsigned long)-1) #endif #ifndef LONG_MAX # define LONG_MAX (ULONG_MAX / 2) #endif #ifdef HAVE_LONG_LONG # ifndef UQUAD_MAX # ifdef ULONG_LONG_MAX # define UQUAD_MAX ULONG_LONG_MAX # else # define UQUAD_MAX ((unsigned long long)-1) # endif # endif # ifndef QUAD_MAX # ifdef LONG_LONG_MAX # define QUAD_MAX LONG_LONG_MAX # else # define QUAD_MAX (UQUAD_MAX / 2) # endif # endif #endif /* HAVE_LONG_LONG */ /* * Macros for converting digits to letters and vice versa */ #define to_digit(c) ((c) - '0') #define is_digit(c) ((unsigned int)to_digit(c) <= 9) #define to_char(n) ((n) + '0') /* * Flags used during conversion. */ #define ALT 0x001 /* alternate form */ #define HEXPREFIX 0x002 /* add 0x or 0X prefix */ #define LADJUST 0x004 /* left adjustment */ #define LONGDBL 0x008 /* long double; unimplemented */ #define LONGINT 0x010 /* long integer */ #define QUADINT 0x020 /* quad integer */ #define SHORTINT 0x040 /* short integer */ #define ZEROPAD 0x080 /* zero (as opposed to blank) pad */ #define BUF 68 #ifndef HAVE_MEMCHR VOID * memchr(s, c, n) const VOID *s; unsigned char c; size_t n; { if (n != 0) { const unsigned char *p = s; do { if (*p++ == c) return ((VOID *)(p - 1)); } while (--n != 0); } return (NULL); } #endif /* !HAVE_MEMCHR */ /* * Convert an unsigned long to ASCII for printf purposes, returning * a pointer to the first character of the string representation. * Octal numbers can be forced to have a leading zero; hex numbers * use the given digits. */ static char * __ultoa(val, endp, base, octzero, xdigs) unsigned long val; char *endp; int base, octzero; char *xdigs; { char *cp = endp; long sval; /* * Handle the three cases separately, in the hope of getting * better/faster code. */ switch (base) { case 10: if (val < 10) { /* many numbers are 1 digit */ *--cp = to_char(val); return (cp); } /* * On many machines, unsigned arithmetic is harder than * signed arithmetic, so we do at most one unsigned mod and * divide; this is sufficient to reduce the range of * the incoming value to where signed arithmetic works. */ if (val > LONG_MAX) { *--cp = to_char(val % 10); sval = val / 10; } else sval = val; do { *--cp = to_char(sval % 10); sval /= 10; } while (sval != 0); break; case 8: do { *--cp = to_char(val & 7); val >>= 3; } while (val); if (octzero && *cp != '0') *--cp = '0'; break; case 16: do { *--cp = xdigs[val & 15]; val >>= 4; } while (val); break; default: /* oops */ abort(); } return (cp); } /* Identical to __ultoa, but for quads. */ #ifdef HAVE_LONG_LONG # ifdef LONG_IS_QUAD # define __uqtoa(v, e, b, o, x) __ultoa((unsigned long)(v), (e), (b), (o), (x)) # else static char * __uqtoa(val, endp, base, octzero, xdigs) unsigned long long val; char *endp; int base, octzero; char *xdigs; { char *cp = endp; long long sval; /* quick test for small values; __ultoa is typically much faster */ /* (perhaps instead we should run until small, then call __ultoa?) */ if (val <= (unsigned long long)ULONG_MAX) return (__ultoa((unsigned long)val, endp, base, octzero, xdigs)); switch (base) { case 10: if (val < 10) { *--cp = to_char(val % 10); return (cp); } if (val > QUAD_MAX) { *--cp = to_char(val % 10); sval = val / 10; } else sval = val; do { *--cp = to_char(sval % 10); sval /= 10; } while (sval != 0); break; case 8: do { *--cp = to_char(val & 7); val >>= 3; } while (val); if (octzero && *cp != '0') *--cp = '0'; break; case 16: do { *--cp = xdigs[val & 15]; val >>= 4; } while (val); break; default: /* oops */ abort(); } return (cp); } # endif /* !LONG_IS_QUAD */ #endif /* HAVE_LONG_LONG */ /* * Actual printf innards. */ static int xxxprintf(strp, strsize, alloc, fmt0, ap) char **strp; size_t strsize; int alloc; const char *fmt0; va_list ap; { char *fmt; /* format string */ int ch; /* character from fmt */ int n; /* handy integer (short term usage) */ char *cp; /* handy char pointer (short term usage) */ int flags; /* flags as above */ int ret; /* return value accumulator */ int width; /* width from format (%8d), or 0 */ int prec; /* precision from format (%.3d), or -1 */ char sign; /* sign prefix (' ', '+', '-', or \0) */ unsigned long ulval; /* integer arguments %[diouxX] */ #ifdef HAVE_LONG_LONG unsigned long long uqval; /* %q (quad) integers */ #endif int base; /* base for [diouxX] conversion */ int dprec; /* a copy of prec if [diouxX], 0 otherwise */ int fieldsz; /* field size expanded by sign, etc */ int realsz; /* field size expanded by dprec */ int size; /* size of converted field or string */ char *xdigs; /* digits for [xX] conversion */ char buf[BUF]; /* space for %c, %[diouxX], %[eEfgG] */ char ox[2]; /* space for 0x hex-prefix */ char *str; /* pointer to string to fill */ char *estr; /* pointer to last char in str */ /* * Choose PADSIZE to trade efficiency vs. size. If larger printf * fields occur frequently, increase PADSIZE and make the initialisers * below longer. */ #define PADSIZE 16 /* pad chunk size */ static char blanks[PADSIZE] = {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '}; static char zeroes[PADSIZE] = {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'}; /* Print chars to "str", (allocate as needed if alloc is set). */ #define PRINT(ptr, len) do { \ const char *p = ptr; \ const char *endp = ptr + len; \ while (p < endp && (str < estr || alloc)) { \ if (alloc && str >= estr) { \ char *t; \ strsize = (strsize << 1) + 1; \ if (!(t = (char *)realloc(*strp, strsize))) { \ free(str); \ *strp = NULL; \ ret = -1; \ goto done; \ } \ str = t + (str - *strp); \ estr = t + strsize - 1; \ *strp = t; \ } \ *str++ = *p++; \ } \ } while (0) /* BEWARE, PAD uses `n'. */ #define PAD(howmany, with) do { \ if ((n = (howmany)) > 0) { \ while (n > PADSIZE) { \ PRINT(with, PADSIZE); \ n -= PADSIZE; \ } \ PRINT(with, n); \ } \ } while (0) /* * To extend shorts properly, we need both signed and unsigned * argument extraction methods. */ #define SARG() \ (flags&LONGINT ? va_arg(ap, long) : \ flags&SHORTINT ? (long)(short)va_arg(ap, int) : \ (long)va_arg(ap, int)) #define UARG() \ (flags&LONGINT ? va_arg(ap, unsigned long) : \ flags&SHORTINT ? (unsigned long)(unsigned short)va_arg(ap, int) : \ (unsigned long)va_arg(ap, unsigned int)) fmt = (char *)fmt0; ret = 0; if (alloc) { strsize = 128; *strp = str = (char *)malloc(strsize); if (str == NULL) { ret = -1; goto done; } estr = str + 127; } else { str = *strp; if (strsize) estr = str + strsize - 1; else estr = NULL; } /* * Scan the format for conversions (`%' character). */ for (;;) { for (cp = fmt; (ch = *fmt) != '\0' && ch != '%'; fmt++) /* void */; if ((n = fmt - cp) != 0) { PRINT(cp, n); ret += n; } if (ch == '\0') goto done; fmt++; /* skip over '%' */ flags = 0; dprec = 0; width = 0; prec = -1; sign = '\0'; rflag: ch = *fmt++; reswitch: switch (ch) { case ' ': /* * ``If the space and + flags both appear, the space * flag will be ignored.'' * -- ANSI X3J11 */ if (!sign) sign = ' '; goto rflag; case '#': flags |= ALT; goto rflag; case '*': /* * ``A negative field width argument is taken as a * - flag followed by a positive field width.'' * -- ANSI X3J11 * They don't exclude field widths read from args. */ if ((width = va_arg(ap, int)) >= 0) goto rflag; width = -width; /* FALLTHROUGH */ case '-': flags |= LADJUST; goto rflag; case '+': sign = '+'; goto rflag; case '.': if ((ch = *fmt++) == '*') { n = va_arg(ap, int); prec = n < 0 ? -1 : n; goto rflag; } n = 0; while (is_digit(ch)) { n = 10 * n + to_digit(ch); ch = *fmt++; } prec = n < 0 ? -1 : n; goto reswitch; case '0': /* * ``Note that 0 is taken as a flag, not as the * beginning of a field width.'' * -- ANSI X3J11 */ flags |= ZEROPAD; goto rflag; case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': n = 0; do { n = 10 * n + to_digit(ch); ch = *fmt++; } while (is_digit(ch)); width = n; goto reswitch; case 'h': flags |= SHORTINT; goto rflag; case 'l': flags |= LONGINT; goto rflag; #ifdef HAVE_LONG_LONG case 'q': flags |= QUADINT; goto rflag; #endif /* HAVE_LONG_LONG */ case 'c': *(cp = buf) = va_arg(ap, int); size = 1; sign = '\0'; break; case 'D': flags |= LONGINT; /*FALLTHROUGH*/ case 'd': case 'i': #ifdef HAVE_LONG_LONG if (flags & QUADINT) { uqval = va_arg(ap, long long); if ((long long)uqval < 0) { uqval = -uqval; sign = '-'; } } else #endif /* HAVE_LONG_LONG */ { ulval = SARG(); if ((long)ulval < 0) { ulval = -ulval; sign = '-'; } } base = 10; goto number; case 'n': #ifdef HAVE_LONG_LONG if (flags & QUADINT) *va_arg(ap, long long *) = ret; else #endif /* HAVE_LONG_LONG */ if (flags & LONGINT) *va_arg(ap, long *) = ret; else if (flags & SHORTINT) *va_arg(ap, short *) = ret; else *va_arg(ap, int *) = ret; continue; /* no output */ case 'O': flags |= LONGINT; /*FALLTHROUGH*/ case 'o': #ifdef HAVE_LONG_LONG if (flags & QUADINT) uqval = va_arg(ap, unsigned long long); else #endif /* HAVE_LONG_LONG */ ulval = UARG(); base = 8; goto nosign; case 'p': /* * ``The argument shall be a pointer to void. The * value of the pointer is converted to a sequence * of printable characters, in an implementation- * defined manner.'' * -- ANSI X3J11 */ ulval = (unsigned long)va_arg(ap, VOID *); base = 16; xdigs = "0123456789abcdef"; flags = (flags & ~QUADINT) | HEXPREFIX; ch = 'x'; goto nosign; case 's': if ((cp = va_arg(ap, char *)) == NULL) cp = "(null)"; if (prec >= 0) { /* * can't use strlen; can only look for the * NUL in the first `prec' characters, and * strlen() will go further. */ char *p = memchr(cp, 0, prec); if (p != NULL) { size = p - cp; if (size > prec) size = prec; } else size = prec; } else size = strlen(cp); sign = '\0'; break; case 'U': flags |= LONGINT; /*FALLTHROUGH*/ case 'u': #ifdef HAVE_LONG_LONG if (flags & QUADINT) uqval = va_arg(ap, unsigned long long); else #endif /* HAVE_LONG_LONG */ ulval = UARG(); base = 10; goto nosign; case 'X': xdigs = "0123456789ABCDEF"; goto hex; case 'x': xdigs = "0123456789abcdef"; hex: #ifdef HAVE_LONG_LONG if (flags & QUADINT) uqval = va_arg(ap, unsigned long long); else #endif /* HAVE_LONG_LONG */ ulval = UARG(); base = 16; /* leading 0x/X only if non-zero */ if (flags & ALT && #ifdef HAVE_LONG_LONG (flags & QUADINT ? uqval != 0 : ulval != 0)) #else ulval != 0) #endif /* HAVE_LONG_LONG */ flags |= HEXPREFIX; /* unsigned conversions */ nosign: sign = '\0'; /* * ``... diouXx conversions ... if a precision is * specified, the 0 flag will be ignored.'' * -- ANSI X3J11 */ number: if ((dprec = prec) >= 0) flags &= ~ZEROPAD; /* * ``The result of converting a zero value with an * explicit precision of zero is no characters.'' * -- ANSI X3J11 */ cp = buf + BUF; #ifdef HAVE_LONG_LONG if (flags & QUADINT) { if (uqval != 0 || prec != 0) cp = __uqtoa(uqval, cp, base, flags & ALT, xdigs); } else #endif /* HAVE_LONG_LONG */ { if (ulval != 0 || prec != 0) cp = __ultoa(ulval, cp, base, flags & ALT, xdigs); } size = buf + BUF - cp; break; default: /* "%?" prints ?, unless ? is NUL */ if (ch == '\0') goto done; /* pretend it was %c with argument ch */ cp = buf; *cp = ch; size = 1; sign = '\0'; break; } /* * All reasonable formats wind up here. At this point, `cp' * points to a string which (if not flags&LADJUST) should be * padded out to `width' places. If flags&ZEROPAD, it should * first be prefixed by any sign or other prefix; otherwise, * it should be blank padded before the prefix is emitted. * After any left-hand padding and prefixing, emit zeroes * required by a decimal [diouxX] precision, then print the * string proper, then emit zeroes required by any leftover * floating precision; finally, if LADJUST, pad with blanks. * * Compute actual size, so we know how much to pad. * fieldsz excludes decimal prec; realsz includes it. */ fieldsz = size; if (sign) fieldsz++; else if (flags & HEXPREFIX) fieldsz += 2; realsz = dprec > fieldsz ? dprec : fieldsz; /* right-adjusting blank padding */ if ((flags & (LADJUST|ZEROPAD)) == 0) PAD(width - realsz, blanks); /* prefix */ if (sign) { PRINT(&sign, 1); } else if (flags & HEXPREFIX) { ox[0] = '0'; ox[1] = ch; PRINT(ox, 2); } /* right-adjusting zero padding */ if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD) PAD(width - realsz, zeroes); /* leading zeroes from decimal precision */ PAD(dprec - fieldsz, zeroes); /* the string or number proper */ PRINT(cp, size); /* left-adjusting padding (always blank) */ if (flags & LADJUST) PAD(width - realsz, blanks); /* finally, adjust ret */ ret += width > realsz ? width : realsz; } done: if (strsize) *str = '\0'; return (ret); /* NOTREACHED */ } #ifndef HAVE_VSNPRINTF int vsnprintf(str, n, fmt, ap) char *str; size_t n; const char *fmt; va_list ap; { return (xxxprintf(&str, n, 0, fmt, ap)); } #endif /* HAVE_VSNPRINTF */ #ifndef HAVE_SNPRINTF int #ifdef __STDC__ snprintf(char *str, size_t n, char const *fmt, ...) #else snprintf(str, n, fmt, va_alist) char *str; size_t n; char const *fmt; va_dcl #endif { int ret; va_list ap; #ifdef __STDC__ va_start(ap, fmt); #else va_start(ap); #endif ret = xxxprintf(&str, n, 0, fmt, ap); va_end(ap); return (ret); } #endif /* HAVE_SNPRINTF */ #ifndef HAVE_VASPRINTF int vasprintf(str, fmt, ap) char **str; const char *fmt; va_list ap; { return (xxxprintf(str, 0, 1, fmt, ap)); } #endif /* HAVE_VASPRINTF */ #ifndef HAVE_ASPRINTF int #ifdef __STDC__ asprintf(char **str, char const *fmt, ...) #else asprintf(str, fmt, va_alist) char **str; char const *fmt; va_dcl #endif { int ret; va_list ap; #ifdef __STDC__ va_start(ap, fmt); #else va_start(ap); #endif ret = xxxprintf(str, 0, 1, fmt, ap); va_end(ap); return (ret); } #endif /* HAVE_ASPRINTF */