StdLib/LibC/Stdio: fix "missing braces around initializer"

[mirror_edk2.git] / StdLib / LibC / Stdio / vsnprintf_ss.c

/*  $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, 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