printf.c revision 1.59
1 /* $NetBSD: printf.c,v 1.59 2024/11/24 12:33:00 kre Exp $ */ 2 3 /* 4 * Copyright (c) 1989, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 #if !defined(BUILTIN) && !defined(SHELL) 35 __COPYRIGHT("@(#) Copyright (c) 1989, 1993\ 36 The Regents of the University of California. All rights reserved."); 37 #endif 38 #endif 39 40 #ifndef lint 41 #if 0 42 static char sccsid[] = "@(#)printf.c 8.2 (Berkeley) 3/22/95"; 43 #else 44 __RCSID("$NetBSD: printf.c,v 1.59 2024/11/24 12:33:00 kre Exp $"); 45 #endif 46 #endif /* not lint */ 47 48 #include <sys/types.h> 49 50 #include <ctype.h> 51 #include <err.h> 52 #include <errno.h> 53 #include <inttypes.h> 54 #include <limits.h> 55 #include <locale.h> 56 #include <stdarg.h> 57 #include <stdio.h> 58 #include <stdlib.h> 59 #include <string.h> 60 #include <unistd.h> 61 62 #ifdef __GNUC__ 63 #define ESCAPE '\e' 64 #else 65 #define ESCAPE 033 66 #endif 67 68 static void conv_escape_str(char *, void (*)(int), int); 69 static char *conv_escape(char *, char *, int); 70 static char *conv_expand(const char *); 71 static wchar_t getchr(void); 72 static long double getdouble(void); 73 static int getwidth(void); 74 static intmax_t getintmax(void); 75 static char *getstr(void); 76 static char *mklong(const char *, char, char); 77 static intmax_t wide_char(const char *, int); 78 static void check_conversion(const char *, const char *); 79 static void usage(void); 80 81 static void b_count(int); 82 static void b_output(int); 83 static size_t b_length; 84 static char *b_fmt; 85 86 static int rval; 87 static char ** gargv, ** firstarg; 88 static int long_double; 89 90 #define ARGNUM ((int)(gargv - firstarg)) 91 92 #ifdef BUILTIN /* csh builtin */ 93 #define main progprintf 94 #endif 95 96 #ifdef SHELL /* sh (aka ash) builtin */ 97 #define main printfcmd 98 #include "../../bin/sh/bltin/bltin.h" 99 #endif /* SHELL */ 100 101 #define PF(f, func) { \ 102 if (fieldwidth != -1) { \ 103 if (precision != -1) \ 104 error = printf(f, fieldwidth, precision, func); \ 105 else \ 106 error = printf(f, fieldwidth, func); \ 107 } else if (precision != -1) \ 108 error = printf(f, precision, func); \ 109 else \ 110 error = printf(f, func); \ 111 } 112 113 #define APF(cpp, f, func) { \ 114 if (fieldwidth != -1) { \ 115 if (precision != -1) \ 116 error = asprintf(cpp, f, fieldwidth, precision, func); \ 117 else \ 118 error = asprintf(cpp, f, fieldwidth, func); \ 119 } else if (precision != -1) \ 120 error = asprintf(cpp, f, precision, func); \ 121 else \ 122 error = asprintf(cpp, f, func); \ 123 } 124 125 #define isodigit(c) ((c) >= '0' && (c) <= '7') 126 #define octtobin(c) ((c) - '0') 127 #define check(c, a) (c) >= (a) && (c) <= (a) + 5 ? (c) - (a) + 10 128 #define hextobin(c) (check(c, 'a') : check(c, 'A') : (c) - '0') 129 130 #ifdef main 131 int main(int, char *[]); 132 #endif 133 134 int 135 main(int argc, char *argv[]) 136 { 137 char *fmt, *start; 138 int fieldwidth, precision; 139 char nextch; 140 char *format; 141 char ch; 142 int error; 143 144 #if !defined(SHELL) && !defined(BUILTIN) 145 (void)setlocale (LC_ALL, ""); 146 #endif 147 148 rval = 0; /* clear for builtin versions (avoid holdover) */ 149 long_double = 0; 150 clearerr(stdout); /* for the builtin version */ 151 152 if (argc > 2 && strchr(argv[1], '%') == NULL) { 153 int o; 154 155 /* 156 * We only do this for argc > 2, as: 157 * 158 * for argc <= 1 159 * at best we have a bare "printf" so there cannot be 160 * any options, thus getopts() would be a waste of time. 161 * The usage() below is assured. 162 * 163 * for argc == 2 164 * There is only one arg (argv[1]) which logically must 165 * be intended to be the (required) format string for 166 * printf, without which we can do nothing so rather 167 * than usage() if it happens to start with a '-' we 168 * just avoid getopts() and treat it as a format string. 169 * 170 * Then, for argc > 2, we also skip this if there is a '%' 171 * anywhere in argv[1] as it is likely that would be intended 172 * to be the format string, rather than options, even if it 173 * starts with a '-' so we skip getopts() in that case as well. 174 * 175 * Note that this would fail should there ever be an option 176 * which takes an arbitrary string value, which could be given 177 * as -Oabc%def so should that ever become possible, remove 178 * the strchr() test above. 179 */ 180 181 while ((o = getopt(argc, argv, "L")) != -1) { 182 switch (o) { 183 case 'L': 184 long_double = 1; 185 break; 186 case '?': 187 default: 188 usage(); 189 return 1; 190 } 191 } 192 argc -= optind; 193 argv += optind; 194 } else { 195 argc -= 1; /* drop argv[0] (the program name) */ 196 argv += 1; 197 } 198 199 if (argc < 1) { /* Nothing left at all? */ 200 usage(); 201 return 1; 202 } 203 204 format = *argv; /* First remaining arg is the format string */ 205 firstarg = gargv = ++argv; /* remaining args are for that to consume */ 206 207 #define SKIP1 "#-+ 0'" 208 #define SKIP2 "0123456789" 209 do { 210 /* 211 * Basic algorithm is to scan the format string for conversion 212 * specifications -- once one is found, find out if the field 213 * width or precision is a '*'; if it is, gather up value. 214 * Note, format strings are reused as necessary to use up the 215 * provided arguments, arguments of zero/null string are 216 * provided to use up the format string. 217 */ 218 219 /* find next format specification */ 220 for (fmt = format; (ch = *fmt++) != '\0';) { 221 if (ch == '\\') { 222 char c_ch; 223 224 fmt = conv_escape(fmt, &c_ch, 0); 225 putchar(c_ch); 226 continue; 227 } 228 if (ch != '%' || (*fmt == '%' && ++fmt)) { 229 (void)putchar(ch); 230 continue; 231 } 232 233 /* 234 * Ok - we've found a format specification, 235 * Save its address for a later printf(). 236 */ 237 start = fmt - 1; 238 239 /* skip to field width */ 240 fmt += strspn(fmt, SKIP1); 241 if (*fmt == '*') { 242 fmt++; 243 fieldwidth = getwidth(); 244 } else { 245 fieldwidth = -1; 246 247 /* skip to possible '.' for precision */ 248 fmt += strspn(fmt, SKIP2); 249 } 250 251 if (*fmt == '.') { 252 /* get following precision */ 253 fmt++; 254 if (*fmt == '*') { 255 fmt++; 256 precision = getwidth(); 257 } else { 258 precision = -1; 259 fmt += strspn(fmt, SKIP2); 260 } 261 } else 262 precision = -1; 263 264 ch = *fmt; 265 if (!ch) { 266 warnx("%s: missing format character", start); 267 return 1; 268 } 269 270 /* 271 * null terminate format string to we can use it 272 * as an argument to printf. 273 */ 274 nextch = fmt[1]; 275 fmt[1] = 0; 276 277 switch (ch) { 278 279 case 'B': { 280 const char *p = conv_expand(getstr()); 281 282 if (p == NULL) 283 goto out; 284 *fmt = 's'; 285 PF(start, p); 286 if (error < 0) 287 goto out; 288 break; 289 } 290 case 'b': { 291 /* 292 * There has to be a better way to do this, 293 * but the string we generate might have 294 * embedded nulls 295 */ 296 static char *a, *t; 297 char *cp = getstr(); 298 299 /* Free on entry in case shell longjumped out */ 300 if (a != NULL) 301 free(a); 302 a = NULL; 303 if (t != NULL) 304 free(t); 305 t = NULL; 306 307 /* Count number of bytes we want to output */ 308 b_length = 0; 309 conv_escape_str(cp, b_count, 0); 310 t = malloc(b_length + 1); 311 if (t == NULL) 312 goto out; 313 (void)memset(t, 'x', b_length); 314 t[b_length] = 0; 315 316 /* Get printf to calculate the lengths */ 317 *fmt = 's'; 318 APF(&a, start, t); 319 if (error == -1) 320 goto out; 321 b_fmt = a; 322 323 /* Output leading spaces and data bytes */ 324 conv_escape_str(cp, b_output, 1); 325 326 /* Add any trailing spaces */ 327 printf("%s", b_fmt); 328 break; 329 } 330 case 'C': { 331 wchar_t p = (wchar_t)getintmax(); 332 char *f = mklong(start, 'c', 'l'); 333 334 PF(f, p); 335 if (error < 0) 336 goto out; 337 break; 338 } 339 case 'c': { 340 wchar_t p = getchr(); 341 char *f = mklong(start, ch, 'l'); 342 343 PF(f, p); 344 if (error < 0) 345 goto out; 346 break; 347 } 348 case 's': { 349 char *p = getstr(); 350 351 PF(start, p); 352 if (error < 0) 353 goto out; 354 break; 355 } 356 case 'd': 357 case 'i': { 358 intmax_t p = getintmax(); 359 char *f = mklong(start, ch, 'j'); 360 361 PF(f, p); 362 if (error < 0) 363 goto out; 364 break; 365 } 366 case 'o': 367 case 'u': 368 case 'x': 369 case 'X': { 370 uintmax_t p = (uintmax_t)getintmax(); 371 char *f = mklong(start, ch, 'j'); 372 373 PF(f, p); 374 if (error < 0) 375 goto out; 376 break; 377 } 378 case 'a': 379 case 'A': 380 case 'e': 381 case 'E': 382 case 'f': 383 case 'F': 384 case 'g': 385 case 'G': { 386 long double p = getdouble(); 387 388 if (long_double) { 389 char * f = mklong(start, ch, 'L'); 390 PF(f, p); 391 } else { 392 double pp = (double)p; 393 PF(start, pp); 394 } 395 if (error < 0) 396 goto out; 397 break; 398 } 399 case '%': 400 /* Don't ask, but this is useful ... */ 401 if (fieldwidth == 'N' && precision == 'B') 402 return 0; 403 /* FALLTHROUGH */ 404 default: 405 warnx("%s: invalid directive", start); 406 return 1; 407 } 408 *fmt++ = ch; 409 *fmt = nextch; 410 /* escape if a \c was encountered */ 411 if (rval & 0x100) 412 goto done; 413 } 414 } while (gargv != argv && *gargv); 415 416 done:; 417 (void)fflush(stdout); 418 if (ferror(stdout)) { 419 clearerr(stdout); 420 err(1, "write error"); 421 } 422 return rval & ~0x100; 423 out:; 424 warn("print failed"); 425 return 1; 426 } 427 428 /* helper functions for conv_escape_str */ 429 430 static void 431 /*ARGSUSED*/ 432 b_count(int ch) 433 { 434 b_length++; 435 } 436 437 /* Output one converted character for every 'x' in the 'format' */ 438 439 static void 440 b_output(int ch) 441 { 442 for (;;) { 443 switch (*b_fmt++) { 444 case 0: 445 b_fmt--; 446 return; 447 case ' ': 448 putchar(' '); 449 break; 450 default: 451 putchar(ch); 452 return; 453 } 454 } 455 } 456 457 458 /* 459 * Print SysV echo(1) style escape string 460 * Halts processing string if a \c escape is encountered. 461 */ 462 static void 463 conv_escape_str(char *str, void (*do_putchar)(int), int quiet) 464 { 465 int value; 466 int ch; 467 char c; 468 469 while ((ch = *str++) != '\0') { 470 if (ch != '\\') { 471 do_putchar(ch); 472 continue; 473 } 474 475 ch = *str++; 476 if (ch == 'c') { 477 /* \c as in SYSV echo - abort all processing.... */ 478 rval |= 0x100; 479 break; 480 } 481 482 /* 483 * %b string octal constants are not like those in C. 484 * They start with a \0, and are followed by 0, 1, 2, 485 * or 3 octal digits. 486 */ 487 if (ch == '0') { 488 int octnum = 0, i; 489 490 for (i = 0; i < 3; i++) { 491 if (!isdigit((unsigned char)*str) || *str > '7') 492 break; 493 octnum = (octnum << 3) | (*str++ - '0'); 494 } 495 do_putchar(octnum); 496 continue; 497 } 498 499 /* \[M][^|-]C as defined by vis(3) */ 500 if (ch == 'M' && *str == '-') { 501 do_putchar(0200 | str[1]); 502 str += 2; 503 continue; 504 } 505 if (ch == 'M' && *str == '^') { 506 str++; 507 value = 0200; 508 ch = '^'; 509 } else 510 value = 0; 511 if (ch == '^') { 512 ch = *str++; 513 if (ch == '?') 514 value |= 0177; 515 else 516 value |= ch & 037; 517 do_putchar(value); 518 continue; 519 } 520 521 /* Finally test for sequences valid in the format string */ 522 str = conv_escape(str - 1, &c, quiet); 523 do_putchar(c); 524 } 525 } 526 527 /* 528 * Print "standard" escape characters 529 */ 530 static char * 531 conv_escape(char *str, char *conv_ch, int quiet) 532 { 533 int value = 0; 534 char ch, *begin; 535 int c; 536 537 ch = *str++; 538 539 switch (ch) { 540 case '\0': 541 if (!quiet) 542 warnx("incomplete escape sequence"); 543 rval = 1; 544 value = '\\'; 545 --str; 546 break; 547 548 case '0': case '1': case '2': case '3': 549 case '4': case '5': case '6': case '7': 550 str--; 551 for (c = 3; c-- && isodigit(*str); str++) { 552 value <<= 3; 553 value += octtobin(*str); 554 } 555 break; 556 557 case 'x': 558 /* 559 * Hexadecimal character constants are not required to be 560 * supported (by SuS v1) because there is no consistent 561 * way to detect the end of the constant. 562 * Supporting 2 byte constants is a compromise. 563 */ 564 begin = str; 565 for (c = 2; c-- && isxdigit((unsigned char)*str); str++) { 566 value <<= 4; 567 value += hextobin(*str); 568 } 569 if (str == begin) { 570 if (!quiet) 571 warnx("\\x%s: missing hexadecimal number " 572 "in escape", begin); 573 rval = 1; 574 } 575 break; 576 577 case '\\': value = '\\'; break; /* backslash */ 578 case '\'': value = '\''; break; /* single quote */ 579 case '"': value = '"'; break; /* double quote */ 580 case 'a': value = '\a'; break; /* alert */ 581 case 'b': value = '\b'; break; /* backspace */ 582 case 'e': value = ESCAPE; break; /* escape */ 583 case 'E': value = ESCAPE; break; /* escape */ 584 case 'f': value = '\f'; break; /* form-feed */ 585 case 'n': value = '\n'; break; /* newline */ 586 case 'r': value = '\r'; break; /* carriage-return */ 587 case 't': value = '\t'; break; /* tab */ 588 case 'v': value = '\v'; break; /* vertical-tab */ 589 590 default: 591 if (!quiet) 592 warnx("unknown escape sequence `\\%c'", ch); 593 rval = 1; 594 value = ch; 595 break; 596 } 597 598 *conv_ch = (char)value; 599 return str; 600 } 601 602 /* expand a string so that everything is printable */ 603 604 static char * 605 conv_expand(const char *str) 606 { 607 static char *conv_str; 608 char *cp; 609 char ch; 610 611 if (conv_str) 612 free(conv_str); 613 /* get a buffer that is definitely large enough.... */ 614 conv_str = malloc(4 * strlen(str) + 1); 615 if (!conv_str) 616 return NULL; 617 cp = conv_str; 618 619 while ((ch = *(const char *)str++) != '\0') { 620 switch (ch) { 621 /* Use C escapes for expected control characters */ 622 case '\\': ch = '\\'; break; /* backslash */ 623 case '\'': ch = '\''; break; /* single quote */ 624 case '"': ch = '"'; break; /* double quote */ 625 case '\a': ch = 'a'; break; /* alert */ 626 case '\b': ch = 'b'; break; /* backspace */ 627 case ESCAPE: ch = 'e'; break; /* escape */ 628 case '\f': ch = 'f'; break; /* form-feed */ 629 case '\n': ch = 'n'; break; /* newline */ 630 case '\r': ch = 'r'; break; /* carriage-return */ 631 case '\t': ch = 't'; break; /* tab */ 632 case '\v': ch = 'v'; break; /* vertical-tab */ 633 default: 634 /* Copy anything printable */ 635 if (isprint((unsigned char)ch)) { 636 *cp++ = ch; 637 continue; 638 } 639 /* Use vis(3) encodings for the rest */ 640 *cp++ = '\\'; 641 if (ch & 0200) { 642 *cp++ = 'M'; 643 ch &= (char)~0200; 644 } 645 if (ch == 0177) { 646 *cp++ = '^'; 647 *cp++ = '?'; 648 continue; 649 } 650 if (ch < 040) { 651 *cp++ = '^'; 652 *cp++ = ch | 0100; 653 continue; 654 } 655 *cp++ = '-'; 656 *cp++ = ch; 657 continue; 658 } 659 *cp++ = '\\'; 660 *cp++ = ch; 661 } 662 663 *cp = 0; 664 return conv_str; 665 } 666 667 static char * 668 mklong(const char *str, char ch, char longer) 669 { 670 static char copy[64]; 671 size_t len; 672 673 len = strlen(str) + 2; 674 if (len > sizeof copy) { 675 warnx("format \"%s\" too complex", str); 676 len = 4; 677 rval = 1; 678 } 679 (void)memmove(copy, str, len - 3); 680 copy[len - 3] = longer; 681 copy[len - 2] = ch; 682 copy[len - 1] = '\0'; 683 return copy; 684 } 685 686 static wchar_t 687 getchr(void) 688 { 689 if (!*gargv) 690 return 0; 691 return (wchar_t)wide_char(*gargv++, 0); 692 } 693 694 static char * 695 getstr(void) 696 { 697 static char empty[] = ""; 698 699 if (!*gargv) 700 return empty; 701 return *gargv++; 702 } 703 704 static int 705 getwidth(void) 706 { 707 unsigned long val; 708 char *s, *ep; 709 710 s = *gargv; 711 if (s == NULL) 712 return 0; 713 gargv++; 714 715 errno = 0; 716 val = strtoul(s, &ep, 0); 717 if (!isdigit(*(unsigned char *)s)) { 718 warnx("Arg %d: '%s' value for '*' width/precision" 719 " must be an unsigned integer", ARGNUM, s); 720 rval = 1; 721 val = 0; 722 } else 723 check_conversion(s, ep); 724 725 /* Arbitrarily 'restrict' field widths to 1Mbyte */ 726 if (val > 1 << 20) { 727 warnx("Arg %d: %s: invalid field width/precision", ARGNUM, s); 728 rval = 1; 729 return 0; 730 } 731 732 return (int)val; 733 } 734 735 static intmax_t 736 getintmax(void) 737 { 738 intmax_t val; 739 char *cp, *ep; 740 741 cp = *gargv; 742 if (cp == NULL) 743 return 0; 744 gargv++; 745 746 if (*cp == '\"' || *cp == '\'') 747 return wide_char(cp, 1); 748 749 errno = 0; 750 val = strtoimax(cp, &ep, 0); 751 if (*cp != '+' && *cp != '-' && !isdigit(*(unsigned char *)cp)) { 752 warnx("Arg %d: '%s' numeric value required", ARGNUM, cp); 753 rval = 1; 754 } else 755 check_conversion(cp, ep); 756 return val; 757 } 758 759 static long double 760 getdouble(void) 761 { 762 long double val; 763 char *ep; 764 765 if (!*gargv) 766 return 0.0; 767 768 /* This is a NetBSD extension, not required by POSIX (it is useless) */ 769 if (*(ep = *gargv) == '\"' || *ep == '\'') 770 return (long double)wide_char(ep, 1); 771 772 errno = 0; 773 val = strtold(*gargv, &ep); 774 check_conversion(*gargv++, ep); 775 return val; 776 } 777 778 /* 779 * Fetch a wide character from the string given 780 * 781 * if all that character must consume the entire string 782 * after an initial leading byte (ascii char) is ignored, 783 * (used for parsing intger args using the 'X syntax) 784 * 785 * if !all then there is no requirement that the whole 786 * string be consumed (remaining characters are just ignored) 787 * but the character is to start at *p. 788 * (used for fetching the first chartacter of a string arg for %c) 789 */ 790 static intmax_t 791 wide_char(const char *p, int all) 792 { 793 wchar_t wch; 794 size_t len; 795 int n; 796 797 (void)mbtowc(NULL, NULL, 0); 798 n = mbtowc(&wch, p + all, (len = strlen(p + all)) + 1); 799 if (n < 0) { 800 warn("Arg %d: %s", ARGNUM, p); 801 rval = 1; 802 } else if (all && (size_t)n != len) { 803 warnx("Arg %d: %s: not completely converted", 804 ARGNUM, p); 805 rval = 1; 806 } 807 808 return (intmax_t) wch; 809 } 810 811 static void 812 check_conversion(const char *s, const char *ep) 813 { 814 if (!*s) { 815 warnx("Arg %d: unexpected empty value ('')", ARGNUM); 816 rval = 1; 817 return; 818 } 819 820 if (*ep) { 821 if (ep == s) 822 warnx("Arg %d: %s: numeric value expected", ARGNUM, s); 823 else 824 warnx("Arg %d: %s: not completely converted", 825 ARGNUM, s); 826 rval = 1; 827 return; 828 } 829 830 if (errno == ERANGE) { 831 warnx("Arg %d: %s: %s", ARGNUM, s, strerror(ERANGE)); 832 rval = 1; 833 } 834 } 835 836 static void 837 usage(void) 838 { 839 (void)fprintf(stderr, 840 "Usage: %s [-L] format [arg ...]\n", getprogname()); 841 } 842
Indexes created Fri Sep 26 20:09:58 GMT 2025