StdLib/LibC/Stdio/vsnprintf_ss.c

   1 /*  $NetBSD: vsnprintf_ss.c,v 1.2.2.1 2007/05/07 19:49:09 pavel Exp $ */
   2
   3 /*-
   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 #include  <LibConfig.h>
  35 #include <sys/EfiCdefs.h>
  36 #if defined(LIBC_SCCS) && !defined(lint)
  37 #if 0
  38 static char sccsid[] = "@(#)vsnprintf.c 8.1 (Berkeley) 6/4/93";
  39 #else
  40 __RCSID("$NetBSD: vsnprintf_ss.c,v 1.2.2.1 2007/05/07 19:49:09 pavel Exp $");
  41 #endif
  42 #endif /* LIBC_SCCS and not lint */
  43
  44 #include "namespace.h"
  45
  46 #include <sys/types.h>
  47 #include <inttypes.h>
  48 #include <assert.h>
  49 #include <stdio.h>
  50 #include <errno.h>
  51 #include <stdarg.h>
  52 #include <string.h>
  53 #include "reentrant.h"
  54 #include "extern.h"
  55 #include "local.h"
  56
  57 #ifdef __weak_alias
  58 __weak_alias(vsnprintf_ss,_vsnprintf_ss)
  59 #endif
  60
  61 /*
  62  * vsnprintf_ss: scaled down version of printf(3).
  63  *
  64  * this version based on vfprintf() from libc which was derived from
  65  * software contributed to Berkeley by Chris Torek.
  66  *
  67  */
  68
  69 /*
  70  * macros for converting digits to letters and vice versa
  71  */
  72 #define to_digit(c) ((c) - '0')
  73 #define is_digit(c) ((unsigned)to_digit(c) <= 9)
  74 #define to_char(n)  (char)((n) + '0')
  75
  76 /*
  77  * flags used during conversion.
  78  */
  79 #define ALT   0x001   /* alternate form */
  80 #define HEXPREFIX 0x002   /* add 0x or 0X prefix */
  81 #define LADJUST   0x004   /* left adjustment */
  82 #define LONGDBL   0x008   /* long double; unimplemented */
  83 #define LONGINT   0x010   /* long integer */
  84 #define QUADINT   0x020   /* quad integer */
  85 #define SHORTINT  0x040   /* short integer */
  86 #define MAXINT    0x080   /* intmax_t */
  87 #define PTRINT    0x100   /* intptr_t */
  88 #define SIZEINT   0x200   /* size_t */
  89 #define ZEROPAD   0x400   /* zero (as opposed to blank) pad */
  90 #define FPT   0x800   /* Floating point number */
  91
  92   /*
  93    * To extend shorts properly, we need both signed and unsigned
  94    * argument extraction methods.
  95    */
  96 #define SARG() \
  97   ((INT64)(flags&MAXINT ? va_arg(ap, intmax_t) : \
  98       flags&PTRINT ? va_arg(ap, intptr_t) : \
  99       flags&SIZEINT ? va_arg(ap, ssize_t) : /* XXX */ \
 100       flags&QUADINT ? va_arg(ap, quad_t) : \
 101       flags&LONGINT ? va_arg(ap, long) : \
 102       flags&SHORTINT ? (short)va_arg(ap, int) : \
 103       va_arg(ap, int)))
 104
 105 #define UARG() \
 106   ((UINT64)(flags&MAXINT ? va_arg(ap, uintmax_t) : \
 107       flags&PTRINT ? va_arg(ap, uintptr_t) : \
 108       flags&SIZEINT ? va_arg(ap, size_t) : \
 109       flags&QUADINT ? va_arg(ap, u_quad_t) : \
 110       flags&LONGINT ? va_arg(ap, unsigned long) : \
 111       flags&SHORTINT ? (u_short)va_arg(ap, int) : \
 112       va_arg(ap, u_int)))
 113
 114 #define PUTCHAR(C) do {         \
 115   if (sbuf < tailp)       \
 116     *sbuf++ = (C);        \
 117 } while (/*CONSTCOND*/0)
 118
 119 int
 120 vsnprintf_ss(char *sbuf, size_t slen, const char *fmt0, va_list ap)
 121 {
 122   const char *fmt;  /* format string */
 123   int ch;     /* character from fmt */
 124   int n;      /* handy integer (short term usage) */
 125   char *cp;   /* handy char pointer (short term usage) */
 126   int flags;    /* flags as above */
 127   int ret;    /* return value accumulator */
 128   int width;    /* width from format (%8d), or 0 */
 129   int prec;   /* precision from format (%.3d), or -1 */
 130   char sign;    /* sign prefix (' ', '+', '-', or \0) */
 131
 132   u_quad_t _uquad;  /* integer arguments %[diouxX] */
 133   enum { OCT, DEC, HEX } base;/* base for [diouxX] conversion */
 134   int dprec;    /* a copy of prec if [diouxX], 0 otherwise */
 135   int realsz;   /* field size expanded by dprec */
 136   int size;   /* size of converted field or string */
 137   const char *xdigs;  /* digits for [xX] conversion */
 138   char bf[128];     /* space for %c, %[diouxX] */
 139   char *tailp;    /* tail pointer for snprintf */
 140
 141   static const char xdigs_lower[16] = "0123456789abcdef";
 142   static const char xdigs_upper[16] = "0123456789ABCDEF";
 143
 144
 145   _DIAGASSERT(n == 0 || sbuf != NULL);
 146   _DIAGASSERT(fmt != NULL);
 147
 148   tailp = sbuf + slen;
 149
 150   cp = NULL;  /* XXX: shutup gcc */
 151   size = 0; /* XXX: shutup gcc */
 152
 153   fmt = fmt0;
 154   ret = 0;
 155
 156   xdigs = NULL;   /* XXX: shut up gcc warning */
 157
 158   /*
 159    * Scan the format for conversions (`%' character).
 160    */
 161   for (;;) {
 162     while (*fmt != '%' && *fmt) {
 163       ret++;
 164       PUTCHAR(*fmt++);
 165     }
 166     if (*fmt == 0)
 167       goto done;
 168
 169     fmt++;    /* skip over '%' */
 170
 171     flags = 0;
 172     dprec = 0;
 173     width = 0;
 174     prec = -1;
 175     sign = '\0';
 176
 177 rflag:    ch = *fmt++;
 178 reswitch: switch (ch) {
 179     case ' ':
 180       /*
 181        * ``If the space and + flags both appear, the space
 182        * flag will be ignored.''
 183        *  -- ANSI X3J11
 184        */
 185       if (!sign)
 186         sign = ' ';
 187       goto rflag;
 188     case '#':
 189       flags |= ALT;
 190       goto rflag;
 191     case '*':
 192       /*
 193        * ``A negative field width argument is taken as a
 194        * - flag followed by a positive field width.''
 195        *  -- ANSI X3J11
 196        * They don't exclude field widths read from args.
 197        */
 198       if ((width = va_arg(ap, int)) >= 0)
 199         goto rflag;
 200       width = -width;
 201       /* FALLTHROUGH */
 202     case '-':
 203       flags |= LADJUST;
 204       goto rflag;
 205     case '+':
 206       sign = '+';
 207       goto rflag;
 208     case '.':
 209       if ((ch = *fmt++) == '*') {
 210         n = va_arg(ap, int);
 211         prec = n < 0 ? -1 : n;
 212         goto rflag;
 213       }
 214       n = 0;
 215       while (is_digit(ch)) {
 216         n = 10 * n + to_digit(ch);
 217         ch = *fmt++;
 218       }
 219       prec = n < 0 ? -1 : n;
 220       goto reswitch;
 221     case '0':
 222       /*
 223        * ``Note that 0 is taken as a flag, not as the
 224        * beginning of a field width.''
 225        *  -- ANSI X3J11
 226        */
 227       flags |= ZEROPAD;
 228       goto rflag;
 229     case '1': case '2': case '3': case '4':
 230     case '5': case '6': case '7': case '8': case '9':
 231       n = 0;
 232       do {
 233         n = 10 * n + to_digit(ch);
 234         ch = *fmt++;
 235       } while (is_digit(ch));
 236       width = n;
 237       goto reswitch;
 238     case 'h':
 239       flags |= SHORTINT;
 240       goto rflag;
 241     case 'j':
 242       flags |= MAXINT;
 243       goto rflag;
 244     case 'l':
 245       if (*fmt == 'l') {
 246         fmt++;
 247         flags |= QUADINT;
 248       } else {
 249         flags |= LONGINT;
 250       }
 251       goto rflag;
 252     case 'q':
 253       flags |= QUADINT;
 254       goto rflag;
 255     case 't':
 256       flags |= PTRINT;
 257       goto rflag;
 258     case 'z':
 259       flags |= SIZEINT;
 260       goto rflag;
 261     case 'c':
 262       *(cp = bf) = va_arg(ap, int);
 263       size = 1;
 264       sign = '\0';
 265       break;
 266     case 'D':
 267       flags |= LONGINT;
 268       /*FALLTHROUGH*/
 269     case 'd':
 270     case 'i':
 271       _uquad = SARG();
 272       if ((quad_t)_uquad < 0) {
 273         _uquad = -_uquad;
 274         sign = '-';
 275       }
 276       base = DEC;
 277       goto number;
 278     case 'n':
 279       if (flags & MAXINT)
 280         *va_arg(ap, intmax_t *) = ret;
 281       else if (flags & PTRINT)
 282         *va_arg(ap, intptr_t *) = ret;
 283       else if (flags & SIZEINT)
 284         *va_arg(ap, ssize_t *) = ret;
 285       else if (flags & QUADINT)
 286         *va_arg(ap, quad_t *) = ret;
 287       else if (flags & LONGINT)
 288         *va_arg(ap, long *) = (long)ret;
 289       else if (flags & SHORTINT)
 290         *va_arg(ap, short *) = (short)ret;
 291       else
 292         *va_arg(ap, int *) = ret;
 293       continue; /* no output */
 294     case 'O':
 295       flags |= LONGINT;
 296       /*FALLTHROUGH*/
 297     case 'o':
 298       _uquad = UARG();
 299       base = OCT;
 300       goto nosign;
 301     case 'p':
 302       /*
 303        * ``The argument shall be a pointer to void.  The
 304        * value of the pointer is converted to a sequence
 305        * of printable characters, in an implementation-
 306        * defined manner.''
 307        *  -- ANSI X3J11
 308        */
 309       /* NOSTRICT */
 310       _uquad = (u_long)va_arg(ap, void *);
 311       base = HEX;
 312       xdigs = xdigs_lower;
 313       flags |= HEXPREFIX;
 314       ch = 'x';
 315       goto nosign;
 316     case 's':
 317       if ((cp = va_arg(ap, char *)) == NULL)
 318         /*XXXUNCONST*/
 319         cp = __UNCONST("(null)");
 320       if (prec >= 0) {
 321         /*
 322          * can't use strlen; can only look for the
 323          * NUL in the first `prec' characters, and
 324          * strlen() will go further.
 325          */
 326         char *p = memchr(cp, 0, (size_t)prec);
 327
 328         if (p != NULL) {
 329           size = p - cp;
 330           if (size > prec)
 331             size = prec;
 332         } else
 333           size = prec;
 334       } else
 335         size = strlen(cp);
 336       sign = '\0';
 337       break;
 338     case 'U':
 339       flags |= LONGINT;
 340       /*FALLTHROUGH*/
 341     case 'u':
 342       _uquad = UARG();
 343       base = DEC;
 344       goto nosign;
 345     case 'X':
 346       xdigs = xdigs_upper;
 347       goto hex;
 348     case 'x':
 349       xdigs = xdigs_lower;
 350 hex:      _uquad = UARG();
 351       base = HEX;
 352       /* leading 0x/X only if non-zero */
 353       if (flags & ALT && _uquad != 0)
 354         flags |= HEXPREFIX;
 355
 356       /* unsigned conversions */
 357 nosign:     sign = '\0';
 358       /*
 359        * ``... diouXx conversions ... if a precision is
 360        * specified, the 0 flag will be ignored.''
 361        *  -- ANSI X3J11
 362        */
 363 number:     if ((dprec = prec) >= 0)
 364         flags &= ~ZEROPAD;
 365
 366       /*
 367        * ``The result of converting a zero value with an
 368        * explicit precision of zero is no characters.''
 369        *  -- ANSI X3J11
 370        */
 371       cp = bf + sizeof(bf);
 372       if (_uquad != 0 || prec != 0) {
 373         /*
 374          * Unsigned mod is hard, and unsigned mod
 375          * by a constant is easier than that by
 376          * a variable; hence this switch.
 377          */
 378         switch (base) {
 379         case OCT:
 380           do {
 381             *--cp = to_char(_uquad & 7);
 382             _uquad >>= 3;
 383           } while (_uquad);
 384           /* handle octal leading 0 */
 385           if (flags & ALT && *cp != '0')
 386             *--cp = '0';
 387           break;
 388
 389         case DEC:
 390           /* many numbers are 1 digit */
 391           while (_uquad >= 10) {
 392             *--cp = to_char(_uquad % 10);
 393             _uquad /= 10;
 394           }
 395           *--cp = to_char(_uquad);
 396           break;
 397
 398         case HEX:
 399           do {
 400             *--cp = xdigs[(size_t)_uquad & 15];
 401             _uquad >>= 4;
 402           } while (_uquad);
 403           break;
 404
 405         default:
 406           /*XXXUNCONST*/
 407           cp = __UNCONST("bug bad base");
 408           size = strlen(cp);
 409           goto skipsize;
 410         }
 411       }
 412       size = bf + sizeof(bf) - cp;
 413     skipsize:
 414       break;
 415     default:  /* "%?" prints ?, unless ? is NUL */
 416       if (ch == '\0')
 417         goto done;
 418       /* pretend it was %c with argument ch */
 419       cp = bf;
 420       *cp = ch;
 421       size = 1;
 422       sign = '\0';
 423       break;
 424     }
 425
 426     /*
 427      * All reasonable formats wind up here.  At this point, `cp'
 428      * points to a string which (if not flags&LADJUST) should be
 429      * padded out to `width' places.  If flags&ZEROPAD, it should
 430      * first be prefixed by any sign or other prefix; otherwise,
 431      * it should be blank padded before the prefix is emitted.
 432      * After any left-hand padding and prefixing, emit zeroes
 433      * required by a decimal [diouxX] precision, then print the
 434      * string proper, then emit zeroes required by any leftover
 435      * floating precision; finally, if LADJUST, pad with blanks.
 436      *
 437      * Compute actual size, so we know how much to pad.
 438      * size excludes decimal prec; realsz includes it.
 439      */
 440     realsz = dprec > size ? dprec : size;
 441     if (sign)
 442       realsz++;
 443     else if (flags & HEXPREFIX)
 444       realsz+= 2;
 445
 446     /* adjust ret */
 447     ret += width > realsz ? width : realsz;
 448
 449     /* right-adjusting blank padding */
 450     if ((flags & (LADJUST|ZEROPAD)) == 0) {
 451       n = width - realsz;
 452       while (n-- > 0)
 453         PUTCHAR(' ');
 454     }
 455
 456     /* prefix */
 457     if (sign) {
 458       PUTCHAR(sign);
 459     } else if (flags & HEXPREFIX) {
 460       PUTCHAR('0');
 461       PUTCHAR(ch);
 462     }
 463
 464     /* right-adjusting zero padding */
 465     if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD) {
 466       n = width - realsz;
 467       while (n-- > 0)
 468         PUTCHAR('0');
 469     }
 470
 471     /* leading zeroes from decimal precision */
 472     n = dprec - size;
 473     while (n-- > 0)
 474       PUTCHAR('0');
 475
 476     /* the string or number proper */
 477     while (size--)
 478       PUTCHAR(*cp++);
 479     /* left-adjusting padding (always blank) */
 480     if (flags & LADJUST) {
 481       n = width - realsz;
 482       while (n-- > 0)
 483         PUTCHAR(' ');
 484     }
 485   }
 486
 487 done:
 488   if (sbuf == tailp)
 489     sbuf[-1] = '\0';
 490   else
 491     *sbuf = '\0';
 492   return (ret);
 493   /* NOTREACHED */
 494 }