1 /*- 2 * Copyright (c) 2005 Poul-Henning Kamp 3 * Copyright (c) 1990, 1993 4 * The Regents of the University of California. All rights reserved. 5 * 6 * This code is derived from software contributed to Berkeley by 7 * Chris Torek. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * $FreeBSD$ 34 */ 35 36 #include "namespace.h" 37 #include <err.h> 38 #include <sys/types.h> 39 #include <stdio.h> 40 #include <stddef.h> 41 #include <stdlib.h> 42 #include <locale.h> 43 #include <stdint.h> 44 #include <assert.h> 45 #include <stdarg.h> 46 #include <namespace.h> 47 #include <string.h> 48 #include <wchar.h> 49 #include "un-namespace.h" 50 51 #include "local.h" 52 #include "printf.h" 53 #include "fvwrite.h" 54 55 int __use_xprintf = -1; 56 57 /* private stuff -----------------------------------------------------*/ 58 59 union arg { 60 int intarg; 61 long longarg; 62 intmax_t intmaxarg; 63 #ifndef NO_FLOATING_POINT 64 double doublearg; 65 long double longdoublearg; 66 #endif 67 wint_t wintarg; 68 char *pchararg; 69 wchar_t *pwchararg; 70 void *pvoidarg; 71 }; 72 73 /* 74 * Macros for converting digits to letters and vice versa 75 */ 76 #define to_digit(c) ((c) - '0') 77 #define is_digit(c) (((unsigned)to_digit(c)) <= 9) 78 79 /* various globals ---------------------------------------------------*/ 80 81 const char __lowercase_hex[17] = "0123456789abcdef?"; /*lint !e784 */ 82 const char __uppercase_hex[17] = "0123456789ABCDEF?"; /*lint !e784 */ 83 84 #define PADSIZE 16 85 static char blanks[PADSIZE] = 86 {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '}; 87 static char zeroes[PADSIZE] = 88 {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'}; 89 90 /* printing and padding functions ------------------------------------*/ 91 92 #define NIOV 8 93 94 struct __printf_io { 95 FILE *fp; 96 struct __suio uio; 97 struct __siov iov[NIOV]; 98 struct __siov *iovp; 99 }; 100 101 static void 102 __printf_init(struct __printf_io *io) 103 { 104 105 io->uio.uio_iov = io->iovp = &io->iov[0]; 106 io->uio.uio_resid = 0; 107 io->uio.uio_iovcnt = 0; 108 } 109 110 void 111 __printf_flush(struct __printf_io *io) 112 { 113 114 __sfvwrite(io->fp, &io->uio); 115 __printf_init(io); 116 } 117 118 int 119 __printf_puts(struct __printf_io *io, const void *ptr, int len) 120 { 121 122 123 if (io->fp->_flags & __SERR) 124 return (0); 125 if (len == 0) 126 return (0); 127 io->iovp->iov_base = __DECONST(void *, ptr); 128 io->iovp->iov_len = len; 129 io->uio.uio_resid += len; 130 io->iovp++; 131 io->uio.uio_iovcnt++; 132 if (io->uio.uio_iovcnt >= NIOV) 133 __printf_flush(io); 134 return (len); 135 } 136 137 int 138 __printf_pad(struct __printf_io *io, int howmany, int zero) 139 { 140 int n; 141 const char *with; 142 int ret = 0; 143 144 if (zero) 145 with = zeroes; 146 else 147 with = blanks; 148 149 if ((n = (howmany)) > 0) { 150 while (n > PADSIZE) { 151 ret += __printf_puts(io, with, PADSIZE); 152 n -= PADSIZE; 153 } 154 ret += __printf_puts(io, with, n); 155 } 156 return (ret); 157 } 158 159 int 160 __printf_out(struct __printf_io *io, const struct printf_info *pi, const void *ptr, int len) 161 { 162 int ret = 0; 163 164 if ((!pi->left) && pi->width > len) 165 ret += __printf_pad(io, pi->width - len, pi->pad == '0'); 166 ret += __printf_puts(io, ptr, len); 167 if (pi->left && pi->width > len) 168 ret += __printf_pad(io, pi->width - len, pi->pad == '0'); 169 return (ret); 170 } 171 172 173 /* percent handling -------------------------------------------------*/ 174 175 static int 176 __printf_arginfo_pct(const struct printf_info *pi __unused, size_t n __unused, int *argt __unused) 177 { 178 179 return (0); 180 } 181 182 static int 183 __printf_render_pct(struct __printf_io *io, const struct printf_info *pi __unused, const void *const *arg __unused) 184 { 185 186 return (__printf_puts(io, "%", 1)); 187 } 188 189 /* 'n' ---------------------------------------------------------------*/ 190 191 static int 192 __printf_arginfo_n(const struct printf_info *pi, size_t n, int *argt) 193 { 194 195 assert(n >= 1); 196 argt[0] = PA_POINTER; 197 return (1); 198 } 199 200 /* 201 * This is a printf_render so that all output has been flushed before it 202 * gets called. 203 */ 204 205 static int 206 __printf_render_n(FILE *io __unused, const struct printf_info *pi, const void *const *arg) 207 { 208 209 if (pi->is_char) 210 **((signed char **)arg[0]) = (signed char)pi->sofar; 211 else if (pi->is_short) 212 **((short **)arg[0]) = (short)pi->sofar; 213 else if (pi->is_long) 214 **((long **)arg[0]) = pi->sofar; 215 else if (pi->is_long_double) 216 **((long long **)arg[0]) = pi->sofar; 217 else if (pi->is_intmax) 218 **((intmax_t **)arg[0]) = pi->sofar; 219 else if (pi->is_ptrdiff) 220 **((ptrdiff_t **)arg[0]) = pi->sofar; 221 else if (pi->is_quad) 222 **((quad_t **)arg[0]) = pi->sofar; 223 else if (pi->is_size) 224 **((size_t **)arg[0]) = pi->sofar; 225 else 226 **((int **)arg[0]) = pi->sofar; 227 228 return (0); 229 } 230 231 /* table -------------------------------------------------------------*/ 232 233 /*lint -esym(785, printf_tbl) */ 234 static struct { 235 printf_arginfo_function *arginfo; 236 printf_function *gnurender; 237 printf_render *render; 238 } printf_tbl[256] = { 239 ['%'] = { __printf_arginfo_pct, NULL, __printf_render_pct }, 240 ['A'] = { __printf_arginfo_float, NULL, __printf_render_float }, 241 ['C'] = { __printf_arginfo_chr, NULL, __printf_render_chr }, 242 ['E'] = { __printf_arginfo_float, NULL, __printf_render_float }, 243 ['F'] = { __printf_arginfo_float, NULL, __printf_render_float }, 244 ['G'] = { __printf_arginfo_float, NULL, __printf_render_float }, 245 ['S'] = { __printf_arginfo_str, NULL, __printf_render_str }, 246 ['X'] = { __printf_arginfo_int, NULL, __printf_render_int }, 247 ['a'] = { __printf_arginfo_float, NULL, __printf_render_float }, 248 ['c'] = { __printf_arginfo_chr, NULL, __printf_render_chr }, 249 ['d'] = { __printf_arginfo_int, NULL, __printf_render_int }, 250 ['e'] = { __printf_arginfo_float, NULL, __printf_render_float }, 251 ['f'] = { __printf_arginfo_float, NULL, __printf_render_float }, 252 ['g'] = { __printf_arginfo_float, NULL, __printf_render_float }, 253 ['i'] = { __printf_arginfo_int, NULL, __printf_render_int }, 254 ['n'] = { __printf_arginfo_n, __printf_render_n, NULL }, 255 ['o'] = { __printf_arginfo_int, NULL, __printf_render_int }, 256 ['p'] = { __printf_arginfo_ptr, NULL, __printf_render_ptr }, 257 ['q'] = { __printf_arginfo_int, NULL, __printf_render_int }, 258 ['s'] = { __printf_arginfo_str, NULL, __printf_render_str }, 259 ['u'] = { __printf_arginfo_int, NULL, __printf_render_int }, 260 ['x'] = { __printf_arginfo_int, NULL, __printf_render_int }, 261 }; 262 263 264 static int 265 __v2printf(FILE *fp, const char *fmt0, unsigned pct, va_list ap) 266 { 267 struct printf_info *pi, *pil; 268 const char *fmt; 269 int ch; 270 struct printf_info pia[pct + 10]; 271 int argt[pct + 10]; 272 union arg args[pct + 10]; 273 int nextarg; 274 int maxarg; 275 int ret = 0; 276 int n; 277 struct __printf_io io; 278 279 __printf_init(&io); 280 io.fp = fp; 281 282 fmt = fmt0; 283 maxarg = 0; 284 nextarg = 1; 285 memset(argt, 0, sizeof argt); 286 for (pi = pia; ; pi++) { 287 memset(pi, 0, sizeof *pi); 288 pil = pi; 289 if (*fmt == '\0') 290 break; 291 pil = pi + 1; 292 pi->prec = -1; 293 pi->pad = ' '; 294 pi->begin = pi->end = fmt; 295 while (*fmt != '\0' && *fmt != '%') 296 pi->end = ++fmt; 297 if (*fmt == '\0') 298 break; 299 fmt++; 300 for (;;) { 301 pi->spec = *fmt; 302 switch (pi->spec) { 303 case ' ': 304 /*- 305 * ``If the space and + flags both appear, the space 306 * flag will be ignored.'' 307 * -- ANSI X3J11 308 */ 309 if (pi->showsign == 0) 310 pi->showsign = ' '; 311 fmt++; 312 continue; 313 case '#': 314 pi->alt = 1; 315 fmt++; 316 continue; 317 case '.': 318 pi->prec = 0; 319 fmt++; 320 if (*fmt == '*') { 321 fmt++; 322 pi->get_prec = nextarg; 323 argt[nextarg++] = PA_INT; 324 continue; 325 } 326 while (*fmt != '\0' && is_digit(*fmt)) { 327 pi->prec *= 10; 328 pi->prec += to_digit(*fmt); 329 fmt++; 330 } 331 continue; 332 case '-': 333 pi->left = 1; 334 fmt++; 335 continue; 336 case '+': 337 pi->showsign = '+'; 338 fmt++; 339 continue; 340 case '*': 341 fmt++; 342 pi->get_width = nextarg; 343 argt[nextarg++] = PA_INT; 344 continue; 345 case '%': 346 fmt++; 347 break; 348 case '\'': 349 pi->group = 1; 350 fmt++; 351 continue; 352 case '0': 353 /*- 354 * ``Note that 0 is taken as a flag, not as the 355 * beginning of a field width.'' 356 * -- ANSI X3J11 357 */ 358 pi->pad = '0'; 359 fmt++; 360 continue; 361 case '1': case '2': case '3': 362 case '4': case '5': case '6': 363 case '7': case '8': case '9': 364 n = 0; 365 while (*fmt != '\0' && is_digit(*fmt)) { 366 n *= 10; 367 n += to_digit(*fmt); 368 fmt++; 369 } 370 if (*fmt == '$') { 371 if (nextarg > maxarg) 372 maxarg = nextarg; 373 nextarg = n; 374 fmt++; 375 } else 376 pi->width = n; 377 continue; 378 case 'D': 379 case 'O': 380 case 'U': 381 pi->spec += ('a' - 'A'); 382 pi->is_intmax = 0; 383 if (pi->is_long_double || pi->is_quad) { 384 pi->is_long = 0; 385 pi->is_long_double = 1; 386 } else { 387 pi->is_long = 1; 388 pi->is_long_double = 0; 389 } 390 fmt++; 391 break; 392 case 'j': 393 pi->is_intmax = 1; 394 fmt++; 395 continue; 396 case 'q': 397 pi->is_long = 0; 398 pi->is_quad = 1; 399 fmt++; 400 continue; 401 case 'L': 402 pi->is_long_double = 1; 403 fmt++; 404 continue; 405 case 'h': 406 fmt++; 407 if (*fmt == 'h') { 408 fmt++; 409 pi->is_char = 1; 410 } else { 411 pi->is_short = 1; 412 } 413 continue; 414 case 'l': 415 fmt++; 416 if (*fmt == 'l') { 417 fmt++; 418 pi->is_long_double = 1; 419 pi->is_quad = 0; 420 } else { 421 pi->is_quad = 0; 422 pi->is_long = 1; 423 } 424 continue; 425 case 't': 426 pi->is_ptrdiff = 1; 427 fmt++; 428 continue; 429 case 'z': 430 pi->is_size = 1; 431 fmt++; 432 continue; 433 default: 434 fmt++; 435 break; 436 } 437 if (printf_tbl[pi->spec].arginfo == NULL) 438 errx(1, "arginfo[%c] = NULL", pi->spec); 439 ch = printf_tbl[pi->spec].arginfo( 440 pi, __PRINTFMAXARG, &argt[nextarg]); 441 if (ch > 0) 442 pi->arg[0] = &args[nextarg]; 443 if (ch > 1) 444 pi->arg[1] = &args[nextarg + 1]; 445 nextarg += ch; 446 break; 447 } 448 } 449 if (nextarg > maxarg) 450 maxarg = nextarg; 451 #if 0 452 fprintf(stderr, "fmt0 <%s>\n", fmt0); 453 fprintf(stderr, "pil %p\n", pil); 454 #endif 455 for (ch = 1; ch < maxarg; ch++) { 456 #if 0 457 fprintf(stderr, "arg %d %x\n", ch, argt[ch]); 458 #endif 459 switch(argt[ch]) { 460 case PA_CHAR: 461 args[ch].intarg = (char)va_arg (ap, int); 462 break; 463 case PA_INT: 464 args[ch].intarg = va_arg (ap, int); 465 break; 466 case PA_INT | PA_FLAG_SHORT: 467 args[ch].intarg = (short)va_arg (ap, int); 468 break; 469 case PA_INT | PA_FLAG_LONG: 470 args[ch].longarg = va_arg (ap, long); 471 break; 472 case PA_INT | PA_FLAG_INTMAX: 473 args[ch].intmaxarg = va_arg (ap, intmax_t); 474 break; 475 case PA_INT | PA_FLAG_QUAD: 476 args[ch].intmaxarg = va_arg (ap, quad_t); 477 break; 478 case PA_INT | PA_FLAG_LONG_LONG: 479 args[ch].intmaxarg = va_arg (ap, long long); 480 break; 481 case PA_INT | PA_FLAG_SIZE: 482 args[ch].intmaxarg = va_arg (ap, size_t); 483 break; 484 case PA_INT | PA_FLAG_PTRDIFF: 485 args[ch].intmaxarg = va_arg (ap, ptrdiff_t); 486 break; 487 case PA_WCHAR: 488 args[ch].wintarg = va_arg (ap, wint_t); 489 break; 490 case PA_POINTER: 491 args[ch].pvoidarg = va_arg (ap, void *); 492 break; 493 case PA_STRING: 494 args[ch].pchararg = va_arg (ap, char *); 495 break; 496 case PA_WSTRING: 497 args[ch].pwchararg = va_arg (ap, wchar_t *); 498 break; 499 case PA_DOUBLE: 500 #ifndef NO_FLOATING_POINT 501 args[ch].doublearg = va_arg (ap, double); 502 #endif 503 break; 504 case PA_DOUBLE | PA_FLAG_LONG_DOUBLE: 505 #ifndef NO_FLOATING_POINT 506 args[ch].longdoublearg = va_arg (ap, long double); 507 #endif 508 break; 509 default: 510 errx(1, "argtype = %x (fmt = \"%s\")\n", 511 argt[ch], fmt0); 512 } 513 } 514 for (pi = pia; pi < pil; pi++) { 515 #if 0 516 fprintf(stderr, "pi %p", pi); 517 fprintf(stderr, " spec '%c'", pi->spec); 518 fprintf(stderr, " args %d", 519 ((uintptr_t)pi->arg[0] - (uintptr_t)args) / sizeof args[0]); 520 if (pi->width) fprintf(stderr, " width %d", pi->width); 521 if (pi->pad) fprintf(stderr, " pad 0x%x", pi->pad); 522 if (pi->left) fprintf(stderr, " left"); 523 if (pi->showsign) fprintf(stderr, " showsign"); 524 if (pi->prec != -1) fprintf(stderr, " prec %d", pi->prec); 525 if (pi->is_char) fprintf(stderr, " char"); 526 if (pi->is_short) fprintf(stderr, " short"); 527 if (pi->is_long) fprintf(stderr, " long"); 528 if (pi->is_long_double) fprintf(stderr, " long_double"); 529 fprintf(stderr, "\n"); 530 fprintf(stderr, "\t\"%.*s\"\n", pi->end - pi->begin, pi->begin); 531 #endif 532 if (pi->get_width) { 533 pi->width = args[pi->get_width].intarg; 534 /*- 535 * ``A negative field width argument is taken as a 536 * - flag followed by a positive field width.'' 537 * -- ANSI X3J11 538 * They don't exclude field widths read from args. 539 */ 540 if (pi->width < 0) { 541 pi->left = 1; 542 pi->width = -pi->width; 543 } 544 } 545 if (pi->get_prec) 546 pi->prec = args[pi->get_prec].intarg; 547 ret += __printf_puts(&io, pi->begin, pi->end - pi->begin); 548 if (printf_tbl[pi->spec].gnurender != NULL) { 549 __printf_flush(&io); 550 pi->sofar = ret; 551 ret += printf_tbl[pi->spec].gnurender( 552 fp, pi, (const void *)pi->arg); 553 } else if (printf_tbl[pi->spec].render != NULL) { 554 pi->sofar = ret; 555 n = printf_tbl[pi->spec].render( 556 &io, pi, (const void *)pi->arg); 557 if (n < 0) 558 io.fp->_flags |= __SERR; 559 else 560 ret += n; 561 } else if (pi->begin == pi->end) 562 errx(1, "render[%c] = NULL", *fmt); 563 } 564 __printf_flush(&io); 565 return (ret); 566 } 567 568 extern int __fflush(FILE *fp); 569 570 /* 571 * Helper function for `fprintf to unbuffered unix file': creates a 572 * temporary buffer. We only work on write-only files; this avoids 573 * worries about ungetc buffers and so forth. 574 */ 575 static int 576 __v3printf(FILE *fp, const char *fmt, int pct, va_list ap) 577 { 578 int ret; 579 FILE fake = FAKE_FILE; 580 unsigned char buf[BUFSIZ]; 581 582 /* copy the important variables */ 583 fake._flags = fp->_flags & ~__SNBF; 584 fake._file = fp->_file; 585 fake._cookie = fp->_cookie; 586 fake._write = fp->_write; 587 fake._orientation = fp->_orientation; 588 fake._mbstate = fp->_mbstate; 589 590 /* set up the buffer */ 591 fake._bf._base = fake._p = buf; 592 fake._bf._size = fake._w = sizeof(buf); 593 fake._lbfsize = 0; /* not actually used, but Just In Case */ 594 595 /* do the work, then copy any error status */ 596 ret = __v2printf(&fake, fmt, pct, ap); 597 if (ret >= 0 && __fflush(&fake)) 598 ret = EOF; 599 if (fake._flags & __SERR) 600 fp->_flags |= __SERR; 601 return (ret); 602 } 603 604 int 605 __xvprintf(FILE *fp, const char *fmt0, va_list ap) 606 { 607 unsigned u; 608 const char *p; 609 610 /* Count number of '%' signs handling double '%' signs */ 611 for (p = fmt0, u = 0; *p; p++) { 612 if (*p != '%') 613 continue; 614 u++; 615 if (p[1] == '%') 616 p++; 617 } 618 619 /* optimise fprintf(stderr) (and other unbuffered Unix files) */ 620 if ((fp->_flags & (__SNBF|__SWR|__SRW)) == (__SNBF|__SWR) && 621 fp->_file >= 0) 622 return (__v3printf(fp, fmt0, u, ap)); 623 else 624 return (__v2printf(fp, fmt0, u, ap)); 625 } 626 627 /* extending ---------------------------------------------------------*/ 628 629 int 630 register_printf_function(int spec, printf_function *render, printf_arginfo_function *arginfo) 631 { 632 633 if (spec > 255 || spec < 0) 634 return (-1); 635 printf_tbl[spec].gnurender = render; 636 printf_tbl[spec].arginfo = arginfo; 637 __use_xprintf = 1; 638 return (0); 639 } 640 641 int 642 register_printf_render(int spec, printf_render *render, printf_arginfo_function *arginfo) 643 { 644 645 if (spec > 255 || spec < 0) 646 return (-1); 647 printf_tbl[spec].render = render; 648 printf_tbl[spec].arginfo = arginfo; 649 __use_xprintf = 1; 650 return (0); 651 } 652 653 int 654 register_printf_render_std(const char *specs) 655 { 656 657 for (; *specs != '\0'; specs++) { 658 switch (*specs) { 659 case 'H': 660 register_printf_render(*specs, 661 __printf_render_hexdump, 662 __printf_arginfo_hexdump); 663 break; 664 case 'M': 665 register_printf_render(*specs, 666 __printf_render_errno, 667 __printf_arginfo_errno); 668 break; 669 case 'Q': 670 register_printf_render(*specs, 671 __printf_render_quote, 672 __printf_arginfo_quote); 673 break; 674 case 'T': 675 register_printf_render(*specs, 676 __printf_render_time, 677 __printf_arginfo_time); 678 break; 679 case 'V': 680 register_printf_render(*specs, 681 __printf_render_vis, 682 __printf_arginfo_vis); 683 break; 684 default: 685 return (-1); 686 } 687 } 688 return (0); 689 } 690 691