--- /dev/null
+/* $NetBSD: vsnprintf_ss.c,v 1.2.2.1 2007/05/07 19:49:09 pavel Exp $ */\r
+\r
+/*-\r
+ * Copyright (c) 1990, 1993\r
+ * The Regents of the University of California. All rights reserved.\r
+ *\r
+ * This code is derived from software contributed to Berkeley by\r
+ * Chris Torek.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in the\r
+ * documentation and/or other materials provided with the distribution.\r
+ * 3. Neither the name of the University nor the names of its contributors\r
+ * may be used to endorse or promote products derived from this software\r
+ * without specific prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND\r
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE\r
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
+ * SUCH DAMAGE.\r
+ */\r
+#include <LibConfig.h>\r
+#include <sys/EfiCdefs.h>\r
+#if defined(LIBC_SCCS) && !defined(lint)\r
+#if 0\r
+static char sccsid[] = "@(#)vsnprintf.c 8.1 (Berkeley) 6/4/93";\r
+#else\r
+__RCSID("$NetBSD: vsnprintf_ss.c,v 1.2.2.1 2007/05/07 19:49:09 pavel Exp $");\r
+#endif\r
+#endif /* LIBC_SCCS and not lint */\r
+\r
+#include "namespace.h"\r
+\r
+#include <sys/types.h>\r
+#include <inttypes.h>\r
+#include <assert.h>\r
+#include <stdio.h>\r
+#include <errno.h>\r
+#include <stdarg.h>\r
+#include <string.h>\r
+#include "reentrant.h"\r
+#include "extern.h"\r
+#include "local.h"\r
+\r
+#ifdef __weak_alias\r
+__weak_alias(vsnprintf_ss,_vsnprintf_ss)\r
+#endif\r
+\r
+/*\r
+ * vsnprintf_ss: scaled down version of printf(3).\r
+ *\r
+ * this version based on vfprintf() from libc which was derived from\r
+ * software contributed to Berkeley by Chris Torek.\r
+ *\r
+ */\r
+\r
+/*\r
+ * macros for converting digits to letters and vice versa\r
+ */\r
+#define to_digit(c) ((c) - '0')\r
+#define is_digit(c) ((unsigned)to_digit(c) <= 9)\r
+#define to_char(n) (char)((n) + '0')\r
+\r
+/*\r
+ * flags used during conversion.\r
+ */\r
+#define ALT 0x001 /* alternate form */\r
+#define HEXPREFIX 0x002 /* add 0x or 0X prefix */\r
+#define LADJUST 0x004 /* left adjustment */\r
+#define LONGDBL 0x008 /* long double; unimplemented */\r
+#define LONGINT 0x010 /* long integer */\r
+#define QUADINT 0x020 /* quad integer */\r
+#define SHORTINT 0x040 /* short integer */\r
+#define MAXINT 0x080 /* intmax_t */\r
+#define PTRINT 0x100 /* intptr_t */\r
+#define SIZEINT 0x200 /* size_t */\r
+#define ZEROPAD 0x400 /* zero (as opposed to blank) pad */\r
+#define FPT 0x800 /* Floating point number */\r
+\r
+ /*\r
+ * To extend shorts properly, we need both signed and unsigned\r
+ * argument extraction methods.\r
+ */\r
+#define SARG() \\r
+ ((INT64)(flags&MAXINT ? va_arg(ap, intmax_t) : \\r
+ flags&PTRINT ? va_arg(ap, intptr_t) : \\r
+ flags&SIZEINT ? va_arg(ap, ssize_t) : /* XXX */ \\r
+ flags&QUADINT ? va_arg(ap, quad_t) : \\r
+ flags&LONGINT ? va_arg(ap, long) : \\r
+ flags&SHORTINT ? (short)va_arg(ap, int) : \\r
+ va_arg(ap, int)))\r
+\r
+#define UARG() \\r
+ ((UINT64)(flags&MAXINT ? va_arg(ap, uintmax_t) : \\r
+ flags&PTRINT ? va_arg(ap, uintptr_t) : \\r
+ flags&SIZEINT ? va_arg(ap, size_t) : \\r
+ flags&QUADINT ? va_arg(ap, u_quad_t) : \\r
+ flags&LONGINT ? va_arg(ap, unsigned long) : \\r
+ flags&SHORTINT ? (u_short)va_arg(ap, int) : \\r
+ va_arg(ap, u_int)))\r
+\r
+#define PUTCHAR(C) do { \\r
+ if (sbuf < tailp) \\r
+ *sbuf++ = (C); \\r
+} while (/*CONSTCOND*/0)\r
+\r
+int\r
+vsnprintf_ss(char *sbuf, size_t slen, const char *fmt0, _BSD_VA_LIST_ ap)\r
+{\r
+ const char *fmt; /* format string */\r
+ int ch; /* character from fmt */\r
+ int n; /* handy integer (short term usage) */\r
+ char *cp; /* handy char pointer (short term usage) */\r
+ int flags; /* flags as above */\r
+ int ret; /* return value accumulator */\r
+ int width; /* width from format (%8d), or 0 */\r
+ int prec; /* precision from format (%.3d), or -1 */\r
+ char sign; /* sign prefix (' ', '+', '-', or \0) */\r
+\r
+ u_quad_t _uquad; /* integer arguments %[diouxX] */\r
+ enum { OCT, DEC, HEX } base;/* base for [diouxX] conversion */\r
+ int dprec; /* a copy of prec if [diouxX], 0 otherwise */\r
+ int realsz; /* field size expanded by dprec */\r
+ int size; /* size of converted field or string */\r
+ const char *xdigs; /* digits for [xX] conversion */\r
+ char bf[128]; /* space for %c, %[diouxX] */\r
+ char *tailp; /* tail pointer for snprintf */\r
+\r
+ static const char xdigs_lower[16] = "0123456789abcdef";\r
+ static const char xdigs_upper[16] = "0123456789ABCDEF";\r
+\r
+\r
+ _DIAGASSERT(n == 0 || sbuf != NULL);\r
+ _DIAGASSERT(fmt != NULL);\r
+\r
+ tailp = sbuf + slen;\r
+\r
+ cp = NULL; /* XXX: shutup gcc */\r
+ size = 0; /* XXX: shutup gcc */\r
+\r
+ fmt = fmt0;\r
+ ret = 0;\r
+\r
+ xdigs = NULL; /* XXX: shut up gcc warning */\r
+\r
+ /*\r
+ * Scan the format for conversions (`%' character).\r
+ */\r
+ for (;;) {\r
+ while (*fmt != '%' && *fmt) {\r
+ ret++;\r
+ PUTCHAR(*fmt++);\r
+ }\r
+ if (*fmt == 0)\r
+ goto done;\r
+\r
+ fmt++; /* skip over '%' */\r
+\r
+ flags = 0;\r
+ dprec = 0;\r
+ width = 0;\r
+ prec = -1;\r
+ sign = '\0';\r
+\r
+rflag: ch = *fmt++;\r
+reswitch: switch (ch) {\r
+ case ' ':\r
+ /*\r
+ * ``If the space and + flags both appear, the space\r
+ * flag will be ignored.''\r
+ * -- ANSI X3J11\r
+ */\r
+ if (!sign)\r
+ sign = ' ';\r
+ goto rflag;\r
+ case '#':\r
+ flags |= ALT;\r
+ goto rflag;\r
+ case '*':\r
+ /*\r
+ * ``A negative field width argument is taken as a\r
+ * - flag followed by a positive field width.''\r
+ * -- ANSI X3J11\r
+ * They don't exclude field widths read from args.\r
+ */\r
+ if ((width = va_arg(ap, int)) >= 0)\r
+ goto rflag;\r
+ width = -width;\r
+ /* FALLTHROUGH */\r
+ case '-':\r
+ flags |= LADJUST;\r
+ goto rflag;\r
+ case '+':\r
+ sign = '+';\r
+ goto rflag;\r
+ case '.':\r
+ if ((ch = *fmt++) == '*') {\r
+ n = va_arg(ap, int);\r
+ prec = n < 0 ? -1 : n;\r
+ goto rflag;\r
+ }\r
+ n = 0;\r
+ while (is_digit(ch)) {\r
+ n = 10 * n + to_digit(ch);\r
+ ch = *fmt++;\r
+ }\r
+ prec = n < 0 ? -1 : n;\r
+ goto reswitch;\r
+ case '0':\r
+ /*\r
+ * ``Note that 0 is taken as a flag, not as the\r
+ * beginning of a field width.''\r
+ * -- ANSI X3J11\r
+ */\r
+ flags |= ZEROPAD;\r
+ goto rflag;\r
+ case '1': case '2': case '3': case '4':\r
+ case '5': case '6': case '7': case '8': case '9':\r
+ n = 0;\r
+ do {\r
+ n = 10 * n + to_digit(ch);\r
+ ch = *fmt++;\r
+ } while (is_digit(ch));\r
+ width = n;\r
+ goto reswitch;\r
+ case 'h':\r
+ flags |= SHORTINT;\r
+ goto rflag;\r
+ case 'j':\r
+ flags |= MAXINT;\r
+ goto rflag;\r
+ case 'l':\r
+ if (*fmt == 'l') {\r
+ fmt++;\r
+ flags |= QUADINT;\r
+ } else {\r
+ flags |= LONGINT;\r
+ }\r
+ goto rflag;\r
+ case 'q':\r
+ flags |= QUADINT;\r
+ goto rflag;\r
+ case 't':\r
+ flags |= PTRINT;\r
+ goto rflag;\r
+ case 'z':\r
+ flags |= SIZEINT;\r
+ goto rflag;\r
+ case 'c':\r
+ *(cp = bf) = va_arg(ap, int);\r
+ size = 1;\r
+ sign = '\0';\r
+ break;\r
+ case 'D':\r
+ flags |= LONGINT;\r
+ /*FALLTHROUGH*/\r
+ case 'd':\r
+ case 'i':\r
+ _uquad = SARG();\r
+ if ((quad_t)_uquad < 0) {\r
+ _uquad = -_uquad;\r
+ sign = '-';\r
+ }\r
+ base = DEC;\r
+ goto number;\r
+ case 'n':\r
+ if (flags & MAXINT)\r
+ *va_arg(ap, intmax_t *) = ret;\r
+ else if (flags & PTRINT)\r
+ *va_arg(ap, intptr_t *) = ret;\r
+ else if (flags & SIZEINT)\r
+ *va_arg(ap, ssize_t *) = ret;\r
+ else if (flags & QUADINT)\r
+ *va_arg(ap, quad_t *) = ret;\r
+ else if (flags & LONGINT)\r
+ *va_arg(ap, long *) = (long)ret;\r
+ else if (flags & SHORTINT)\r
+ *va_arg(ap, short *) = (short)ret;\r
+ else\r
+ *va_arg(ap, int *) = ret;\r
+ continue; /* no output */\r
+ case 'O':\r
+ flags |= LONGINT;\r
+ /*FALLTHROUGH*/\r
+ case 'o':\r
+ _uquad = UARG();\r
+ base = OCT;\r
+ goto nosign;\r
+ case 'p':\r
+ /*\r
+ * ``The argument shall be a pointer to void. The\r
+ * value of the pointer is converted to a sequence\r
+ * of printable characters, in an implementation-\r
+ * defined manner.''\r
+ * -- ANSI X3J11\r
+ */\r
+ /* NOSTRICT */\r
+ _uquad = (u_long)va_arg(ap, void *);\r
+ base = HEX;\r
+ xdigs = xdigs_lower;\r
+ flags |= HEXPREFIX;\r
+ ch = 'x';\r
+ goto nosign;\r
+ case 's':\r
+ if ((cp = va_arg(ap, char *)) == NULL)\r
+ /*XXXUNCONST*/\r
+ cp = __UNCONST("(null)");\r
+ if (prec >= 0) {\r
+ /*\r
+ * can't use strlen; can only look for the\r
+ * NUL in the first `prec' characters, and\r
+ * strlen() will go further.\r
+ */\r
+ char *p = memchr(cp, 0, (size_t)prec);\r
+\r
+ if (p != NULL) {\r
+ size = p - cp;\r
+ if (size > prec)\r
+ size = prec;\r
+ } else\r
+ size = prec;\r
+ } else\r
+ size = strlen(cp);\r
+ sign = '\0';\r
+ break;\r
+ case 'U':\r
+ flags |= LONGINT;\r
+ /*FALLTHROUGH*/\r
+ case 'u':\r
+ _uquad = UARG();\r
+ base = DEC;\r
+ goto nosign;\r
+ case 'X':\r
+ xdigs = xdigs_upper;\r
+ goto hex;\r
+ case 'x':\r
+ xdigs = xdigs_lower;\r
+hex: _uquad = UARG();\r
+ base = HEX;\r
+ /* leading 0x/X only if non-zero */\r
+ if (flags & ALT && _uquad != 0)\r
+ flags |= HEXPREFIX;\r
+\r
+ /* unsigned conversions */\r
+nosign: sign = '\0';\r
+ /*\r
+ * ``... diouXx conversions ... if a precision is\r
+ * specified, the 0 flag will be ignored.''\r
+ * -- ANSI X3J11\r
+ */\r
+number: if ((dprec = prec) >= 0)\r
+ flags &= ~ZEROPAD;\r
+\r
+ /*\r
+ * ``The result of converting a zero value with an\r
+ * explicit precision of zero is no characters.''\r
+ * -- ANSI X3J11\r
+ */\r
+ cp = bf + sizeof(bf);\r
+ if (_uquad != 0 || prec != 0) {\r
+ /*\r
+ * Unsigned mod is hard, and unsigned mod\r
+ * by a constant is easier than that by\r
+ * a variable; hence this switch.\r
+ */\r
+ switch (base) {\r
+ case OCT:\r
+ do {\r
+ *--cp = to_char(_uquad & 7);\r
+ _uquad >>= 3;\r
+ } while (_uquad);\r
+ /* handle octal leading 0 */\r
+ if (flags & ALT && *cp != '0')\r
+ *--cp = '0';\r
+ break;\r
+\r
+ case DEC:\r
+ /* many numbers are 1 digit */\r
+ while (_uquad >= 10) {\r
+ *--cp = to_char(_uquad % 10);\r
+ _uquad /= 10;\r
+ }\r
+ *--cp = to_char(_uquad);\r
+ break;\r
+\r
+ case HEX:\r
+ do {\r
+ *--cp = xdigs[(size_t)_uquad & 15];\r
+ _uquad >>= 4;\r
+ } while (_uquad);\r
+ break;\r
+\r
+ default:\r
+ /*XXXUNCONST*/\r
+ cp = __UNCONST("bug bad base");\r
+ size = strlen(cp);\r
+ goto skipsize;\r
+ }\r
+ }\r
+ size = bf + sizeof(bf) - cp;\r
+ skipsize:\r
+ break;\r
+ default: /* "%?" prints ?, unless ? is NUL */\r
+ if (ch == '\0')\r
+ goto done;\r
+ /* pretend it was %c with argument ch */\r
+ cp = bf;\r
+ *cp = ch;\r
+ size = 1;\r
+ sign = '\0';\r
+ break;\r
+ }\r
+\r
+ /*\r
+ * All reasonable formats wind up here. At this point, `cp'\r
+ * points to a string which (if not flags&LADJUST) should be\r
+ * padded out to `width' places. If flags&ZEROPAD, it should\r
+ * first be prefixed by any sign or other prefix; otherwise,\r
+ * it should be blank padded before the prefix is emitted.\r
+ * After any left-hand padding and prefixing, emit zeroes\r
+ * required by a decimal [diouxX] precision, then print the\r
+ * string proper, then emit zeroes required by any leftover\r
+ * floating precision; finally, if LADJUST, pad with blanks.\r
+ *\r
+ * Compute actual size, so we know how much to pad.\r
+ * size excludes decimal prec; realsz includes it.\r
+ */\r
+ realsz = dprec > size ? dprec : size;\r
+ if (sign)\r
+ realsz++;\r
+ else if (flags & HEXPREFIX)\r
+ realsz+= 2;\r
+\r
+ /* adjust ret */\r
+ ret += width > realsz ? width : realsz;\r
+\r
+ /* right-adjusting blank padding */\r
+ if ((flags & (LADJUST|ZEROPAD)) == 0) {\r
+ n = width - realsz;\r
+ while (n-- > 0)\r
+ PUTCHAR(' ');\r
+ }\r
+\r
+ /* prefix */\r
+ if (sign) {\r
+ PUTCHAR(sign);\r
+ } else if (flags & HEXPREFIX) {\r
+ PUTCHAR('0');\r
+ PUTCHAR(ch);\r
+ }\r
+\r
+ /* right-adjusting zero padding */\r
+ if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD) {\r
+ n = width - realsz;\r
+ while (n-- > 0)\r
+ PUTCHAR('0');\r
+ }\r
+\r
+ /* leading zeroes from decimal precision */\r
+ n = dprec - size;\r
+ while (n-- > 0)\r
+ PUTCHAR('0');\r
+\r
+ /* the string or number proper */\r
+ while (size--)\r
+ PUTCHAR(*cp++);\r
+ /* left-adjusting padding (always blank) */\r
+ if (flags & LADJUST) {\r
+ n = width - realsz;\r
+ while (n-- > 0)\r
+ PUTCHAR(' ');\r
+ }\r
+ }\r
+\r
+done:\r
+ if (sbuf == tailp)\r
+ sbuf[-1] = '\0';\r
+ else\r
+ *sbuf = '\0';\r
+ return (ret);\r
+ /* NOTREACHED */\r
+}\r
projects / mirror_edk2.git / blobdiff