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