vasnprintf.c revision 1.2
1 /* vsprintf with automatic memory allocation. 2 Copyright (C) 1999, 2002-2005 Free Software Foundation, Inc. 3 4 This program is free software; you can redistribute it and/or modify 5 it under the terms of the GNU General Public License as published by 6 the Free Software Foundation; either version 2, or (at your option) 7 any later version. 8 9 This program is distributed in the hope that it will be useful, 10 but WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 GNU General Public License for more details. 13 14 You should have received a copy of the GNU General Public License along 15 with this program; if not, write to the Free Software Foundation, 16 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ 17 18 /* Tell glibc's <stdio.h> to provide a prototype for snprintf(). 19 This must come before <config.h> because <config.h> may include 20 <features.h>, and once <features.h> has been included, it's too late. */ 21 #ifndef _GNU_SOURCE 22 # define _GNU_SOURCE 1 23 #endif 24 25 #ifdef HAVE_CONFIG_H 26 # include <config.h> 27 #endif 28 #ifdef __SSP__ 29 #undef HAVE_ALLOCA 30 #endif 31 #ifndef __NetBSD__ 32 #ifndef IN_LIBINTL 33 # include <alloca.h> 34 #endif 35 #endif 36 37 /* Specification. */ 38 #if WIDE_CHAR_VERSION 39 # include "vasnwprintf.h" 40 #else 41 # include "vasnprintf.h" 42 #endif 43 44 #include <stdio.h> /* snprintf(), sprintf() */ 45 #include <stdlib.h> /* abort(), malloc(), realloc(), free() */ 46 #include <string.h> /* memcpy(), strlen() */ 47 #include <errno.h> /* errno */ 48 #include <limits.h> /* CHAR_BIT, INT_MAX */ 49 #include <float.h> /* DBL_MAX_EXP, LDBL_MAX_EXP */ 50 #if WIDE_CHAR_VERSION 51 # include "wprintf-parse.h" 52 #else 53 # include "printf-parse.h" 54 #endif 55 56 /* Checked size_t computations. */ 57 #include "xsize.h" 58 59 /* Some systems, like OSF/1 4.0 and Woe32, don't have EOVERFLOW. */ 60 #ifndef EOVERFLOW 61 # define EOVERFLOW E2BIG 62 #endif 63 64 #ifdef HAVE_WCHAR_T 65 # ifdef HAVE_WCSLEN 66 # define local_wcslen wcslen 67 # else 68 /* Solaris 2.5.1 has wcslen() in a separate library libw.so. To avoid 69 a dependency towards this library, here is a local substitute. 70 Define this substitute only once, even if this file is included 71 twice in the same compilation unit. */ 72 # ifndef local_wcslen_defined 73 # define local_wcslen_defined 1 74 static size_t 75 local_wcslen (const wchar_t *s) 76 { 77 const wchar_t *ptr; 78 79 for (ptr = s; *ptr != (wchar_t) 0; ptr++) 80 ; 81 return ptr - s; 82 } 83 # endif 84 # endif 85 #endif 86 87 #if WIDE_CHAR_VERSION 88 # define VASNPRINTF vasnwprintf 89 # define CHAR_T wchar_t 90 # define DIRECTIVE wchar_t_directive 91 # define DIRECTIVES wchar_t_directives 92 # define PRINTF_PARSE wprintf_parse 93 # define USE_SNPRINTF 1 94 # if HAVE_DECL__SNWPRINTF 95 /* On Windows, the function swprintf() has a different signature than 96 on Unix; we use the _snwprintf() function instead. */ 97 # define SNPRINTF _snwprintf 98 # else 99 /* Unix. */ 100 # define SNPRINTF swprintf 101 # endif 102 #else 103 # define VASNPRINTF vasnprintf 104 # define CHAR_T char 105 # define DIRECTIVE char_directive 106 # define DIRECTIVES char_directives 107 # define PRINTF_PARSE printf_parse 108 # define USE_SNPRINTF (HAVE_DECL__SNPRINTF || HAVE_SNPRINTF) 109 # if HAVE_DECL__SNPRINTF 110 /* Windows. */ 111 # define SNPRINTF _snprintf 112 # else 113 /* Unix. */ 114 # define SNPRINTF snprintf 115 # endif 116 #endif 117 118 CHAR_T * 119 VASNPRINTF (CHAR_T *resultbuf, size_t *lengthp, const CHAR_T *format, va_list args) 120 { 121 DIRECTIVES d; 122 arguments a; 123 124 if (PRINTF_PARSE (format, &d, &a) < 0) 125 { 126 errno = EINVAL; 127 return NULL; 128 } 129 130 #define CLEANUP() \ 131 free (d.dir); \ 132 if (a.arg) \ 133 free (a.arg); 134 135 if (printf_fetchargs (args, &a) < 0) 136 { 137 CLEANUP (); 138 errno = EINVAL; 139 return NULL; 140 } 141 142 { 143 size_t buf_neededlength; 144 CHAR_T *buf; 145 CHAR_T *buf_malloced; 146 const CHAR_T *cp; 147 size_t i; 148 DIRECTIVE *dp; 149 /* Output string accumulator. */ 150 CHAR_T *result; 151 size_t allocated; 152 size_t length; 153 154 /* Allocate a small buffer that will hold a directive passed to 155 sprintf or snprintf. */ 156 buf_neededlength = 157 xsum4 (7, d.max_width_length, d.max_precision_length, 6); 158 #if HAVE_ALLOCA 159 if (buf_neededlength < 4000 / sizeof (CHAR_T)) 160 { 161 buf = (CHAR_T *) alloca (buf_neededlength * sizeof (CHAR_T)); 162 buf_malloced = NULL; 163 } 164 else 165 #endif 166 { 167 size_t buf_memsize = xtimes (buf_neededlength, sizeof (CHAR_T)); 168 if (size_overflow_p (buf_memsize)) 169 goto out_of_memory_1; 170 buf = (CHAR_T *) malloc (buf_memsize); 171 if (buf == NULL) 172 goto out_of_memory_1; 173 buf_malloced = buf; 174 } 175 176 if (resultbuf != NULL) 177 { 178 result = resultbuf; 179 allocated = *lengthp; 180 } 181 else 182 { 183 result = NULL; 184 allocated = 0; 185 } 186 length = 0; 187 /* Invariants: 188 result is either == resultbuf or == NULL or malloc-allocated. 189 If length > 0, then result != NULL. */ 190 191 /* Ensures that allocated >= needed. Aborts through a jump to 192 out_of_memory if needed is SIZE_MAX or otherwise too big. */ 193 #define ENSURE_ALLOCATION(needed) \ 194 if ((needed) > allocated) \ 195 { \ 196 size_t memory_size; \ 197 CHAR_T *memory; \ 198 \ 199 allocated = (allocated > 0 ? xtimes (allocated, 2) : 12); \ 200 if ((needed) > allocated) \ 201 allocated = (needed); \ 202 memory_size = xtimes (allocated, sizeof (CHAR_T)); \ 203 if (size_overflow_p (memory_size)) \ 204 goto out_of_memory; \ 205 if (result == resultbuf || result == NULL) \ 206 memory = (CHAR_T *) malloc (memory_size); \ 207 else \ 208 memory = (CHAR_T *) realloc (result, memory_size); \ 209 if (memory == NULL) \ 210 goto out_of_memory; \ 211 if (result == resultbuf && length > 0) \ 212 memcpy (memory, result, length * sizeof (CHAR_T)); \ 213 result = memory; \ 214 } 215 216 for (cp = format, i = 0, dp = &d.dir[0]; ; cp = dp->dir_end, i++, dp++) 217 { 218 if (cp != dp->dir_start) 219 { 220 size_t n = dp->dir_start - cp; 221 size_t augmented_length = xsum (length, n); 222 223 ENSURE_ALLOCATION (augmented_length); 224 memcpy (result + length, cp, n * sizeof (CHAR_T)); 225 length = augmented_length; 226 } 227 if (i == d.count) 228 break; 229 230 /* Execute a single directive. */ 231 if (dp->conversion == '%') 232 { 233 size_t augmented_length; 234 235 if (!(dp->arg_index == ARG_NONE)) 236 abort (); 237 augmented_length = xsum (length, 1); 238 ENSURE_ALLOCATION (augmented_length); 239 result[length] = '%'; 240 length = augmented_length; 241 } 242 else 243 { 244 if (!(dp->arg_index != ARG_NONE)) 245 abort (); 246 247 if (dp->conversion == 'n') 248 { 249 switch (a.arg[dp->arg_index].type) 250 { 251 case TYPE_COUNT_SCHAR_POINTER: 252 *a.arg[dp->arg_index].a.a_count_schar_pointer = length; 253 break; 254 case TYPE_COUNT_SHORT_POINTER: 255 *a.arg[dp->arg_index].a.a_count_short_pointer = length; 256 break; 257 case TYPE_COUNT_INT_POINTER: 258 *a.arg[dp->arg_index].a.a_count_int_pointer = length; 259 break; 260 case TYPE_COUNT_LONGINT_POINTER: 261 *a.arg[dp->arg_index].a.a_count_longint_pointer = length; 262 break; 263 #ifdef HAVE_LONG_LONG 264 case TYPE_COUNT_LONGLONGINT_POINTER: 265 *a.arg[dp->arg_index].a.a_count_longlongint_pointer = length; 266 break; 267 #endif 268 default: 269 abort (); 270 } 271 } 272 else 273 { 274 arg_type type = a.arg[dp->arg_index].type; 275 CHAR_T *p; 276 unsigned int prefix_count; 277 int prefixes[2]; 278 #if !USE_SNPRINTF 279 size_t tmp_length; 280 CHAR_T tmpbuf[700]; 281 CHAR_T *tmp; 282 283 /* Allocate a temporary buffer of sufficient size for calling 284 sprintf. */ 285 { 286 size_t width; 287 size_t precision; 288 289 width = 0; 290 if (dp->width_start != dp->width_end) 291 { 292 if (dp->width_arg_index != ARG_NONE) 293 { 294 int arg; 295 296 if (!(a.arg[dp->width_arg_index].type == TYPE_INT)) 297 abort (); 298 arg = a.arg[dp->width_arg_index].a.a_int; 299 width = (arg < 0 ? (unsigned int) (-arg) : arg); 300 } 301 else 302 { 303 const CHAR_T *digitp = dp->width_start; 304 305 do 306 width = xsum (xtimes (width, 10), *digitp++ - '0'); 307 while (digitp != dp->width_end); 308 } 309 } 310 311 precision = 6; 312 if (dp->precision_start != dp->precision_end) 313 { 314 if (dp->precision_arg_index != ARG_NONE) 315 { 316 int arg; 317 318 if (!(a.arg[dp->precision_arg_index].type == TYPE_INT)) 319 abort (); 320 arg = a.arg[dp->precision_arg_index].a.a_int; 321 precision = (arg < 0 ? 0 : arg); 322 } 323 else 324 { 325 const CHAR_T *digitp = dp->precision_start + 1; 326 327 precision = 0; 328 while (digitp != dp->precision_end) 329 precision = xsum (xtimes (precision, 10), *digitp++ - '0'); 330 } 331 } 332 333 switch (dp->conversion) 334 { 335 336 case 'd': case 'i': case 'u': 337 # ifdef HAVE_LONG_LONG 338 if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT) 339 tmp_length = 340 (unsigned int) (sizeof (unsigned long long) * CHAR_BIT 341 * 0.30103 /* binary -> decimal */ 342 * 2 /* estimate for FLAG_GROUP */ 343 ) 344 + 1 /* turn floor into ceil */ 345 + 1; /* account for leading sign */ 346 else 347 # endif 348 if (type == TYPE_LONGINT || type == TYPE_ULONGINT) 349 tmp_length = 350 (unsigned int) (sizeof (unsigned long) * CHAR_BIT 351 * 0.30103 /* binary -> decimal */ 352 * 2 /* estimate for FLAG_GROUP */ 353 ) 354 + 1 /* turn floor into ceil */ 355 + 1; /* account for leading sign */ 356 else 357 tmp_length = 358 (unsigned int) (sizeof (unsigned int) * CHAR_BIT 359 * 0.30103 /* binary -> decimal */ 360 * 2 /* estimate for FLAG_GROUP */ 361 ) 362 + 1 /* turn floor into ceil */ 363 + 1; /* account for leading sign */ 364 break; 365 366 case 'o': 367 # ifdef HAVE_LONG_LONG 368 if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT) 369 tmp_length = 370 (unsigned int) (sizeof (unsigned long long) * CHAR_BIT 371 * 0.333334 /* binary -> octal */ 372 ) 373 + 1 /* turn floor into ceil */ 374 + 1; /* account for leading sign */ 375 else 376 # endif 377 if (type == TYPE_LONGINT || type == TYPE_ULONGINT) 378 tmp_length = 379 (unsigned int) (sizeof (unsigned long) * CHAR_BIT 380 * 0.333334 /* binary -> octal */ 381 ) 382 + 1 /* turn floor into ceil */ 383 + 1; /* account for leading sign */ 384 else 385 tmp_length = 386 (unsigned int) (sizeof (unsigned int) * CHAR_BIT 387 * 0.333334 /* binary -> octal */ 388 ) 389 + 1 /* turn floor into ceil */ 390 + 1; /* account for leading sign */ 391 break; 392 393 case 'x': case 'X': 394 # ifdef HAVE_LONG_LONG 395 if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT) 396 tmp_length = 397 (unsigned int) (sizeof (unsigned long long) * CHAR_BIT 398 * 0.25 /* binary -> hexadecimal */ 399 ) 400 + 1 /* turn floor into ceil */ 401 + 2; /* account for leading sign or alternate form */ 402 else 403 # endif 404 if (type == TYPE_LONGINT || type == TYPE_ULONGINT) 405 tmp_length = 406 (unsigned int) (sizeof (unsigned long) * CHAR_BIT 407 * 0.25 /* binary -> hexadecimal */ 408 ) 409 + 1 /* turn floor into ceil */ 410 + 2; /* account for leading sign or alternate form */ 411 else 412 tmp_length = 413 (unsigned int) (sizeof (unsigned int) * CHAR_BIT 414 * 0.25 /* binary -> hexadecimal */ 415 ) 416 + 1 /* turn floor into ceil */ 417 + 2; /* account for leading sign or alternate form */ 418 break; 419 420 case 'f': case 'F': 421 # ifdef HAVE_LONG_DOUBLE 422 if (type == TYPE_LONGDOUBLE) 423 tmp_length = 424 (unsigned int) (LDBL_MAX_EXP 425 * 0.30103 /* binary -> decimal */ 426 * 2 /* estimate for FLAG_GROUP */ 427 ) 428 + 1 /* turn floor into ceil */ 429 + 10; /* sign, decimal point etc. */ 430 else 431 # endif 432 tmp_length = 433 (unsigned int) (DBL_MAX_EXP 434 * 0.30103 /* binary -> decimal */ 435 * 2 /* estimate for FLAG_GROUP */ 436 ) 437 + 1 /* turn floor into ceil */ 438 + 10; /* sign, decimal point etc. */ 439 tmp_length = xsum (tmp_length, precision); 440 break; 441 442 case 'e': case 'E': case 'g': case 'G': 443 case 'a': case 'A': 444 tmp_length = 445 12; /* sign, decimal point, exponent etc. */ 446 tmp_length = xsum (tmp_length, precision); 447 break; 448 449 case 'c': 450 # if defined HAVE_WINT_T && !WIDE_CHAR_VERSION 451 if (type == TYPE_WIDE_CHAR) 452 tmp_length = MB_CUR_MAX; 453 else 454 # endif 455 tmp_length = 1; 456 break; 457 458 case 's': 459 # ifdef HAVE_WCHAR_T 460 if (type == TYPE_WIDE_STRING) 461 { 462 tmp_length = 463 local_wcslen (a.arg[dp->arg_index].a.a_wide_string); 464 465 # if !WIDE_CHAR_VERSION 466 tmp_length = xtimes (tmp_length, MB_CUR_MAX); 467 # endif 468 } 469 else 470 # endif 471 tmp_length = strlen (a.arg[dp->arg_index].a.a_string); 472 break; 473 474 case 'p': 475 tmp_length = 476 (unsigned int) (sizeof (void *) * CHAR_BIT 477 * 0.25 /* binary -> hexadecimal */ 478 ) 479 + 1 /* turn floor into ceil */ 480 + 2; /* account for leading 0x */ 481 break; 482 483 default: 484 abort (); 485 } 486 487 if (tmp_length < width) 488 tmp_length = width; 489 490 tmp_length = xsum (tmp_length, 1); /* account for trailing NUL */ 491 } 492 493 if (tmp_length <= sizeof (tmpbuf) / sizeof (CHAR_T)) 494 tmp = tmpbuf; 495 else 496 { 497 size_t tmp_memsize = xtimes (tmp_length, sizeof (CHAR_T)); 498 499 if (size_overflow_p (tmp_memsize)) 500 /* Overflow, would lead to out of memory. */ 501 goto out_of_memory; 502 tmp = (CHAR_T *) malloc (tmp_memsize); 503 if (tmp == NULL) 504 /* Out of memory. */ 505 goto out_of_memory; 506 } 507 #endif 508 509 /* Construct the format string for calling snprintf or 510 sprintf. */ 511 p = buf; 512 *p++ = '%'; 513 if (dp->flags & FLAG_GROUP) 514 *p++ = '\''; 515 if (dp->flags & FLAG_LEFT) 516 *p++ = '-'; 517 if (dp->flags & FLAG_SHOWSIGN) 518 *p++ = '+'; 519 if (dp->flags & FLAG_SPACE) 520 *p++ = ' '; 521 if (dp->flags & FLAG_ALT) 522 *p++ = '#'; 523 if (dp->flags & FLAG_ZERO) 524 *p++ = '0'; 525 if (dp->width_start != dp->width_end) 526 { 527 size_t n = dp->width_end - dp->width_start; 528 memcpy (p, dp->width_start, n * sizeof (CHAR_T)); 529 p += n; 530 } 531 if (dp->precision_start != dp->precision_end) 532 { 533 size_t n = dp->precision_end - dp->precision_start; 534 memcpy (p, dp->precision_start, n * sizeof (CHAR_T)); 535 p += n; 536 } 537 538 switch (type) 539 { 540 #ifdef HAVE_LONG_LONG 541 case TYPE_LONGLONGINT: 542 case TYPE_ULONGLONGINT: 543 *p++ = 'l'; 544 /*FALLTHROUGH*/ 545 #endif 546 case TYPE_LONGINT: 547 case TYPE_ULONGINT: 548 #ifdef HAVE_WINT_T 549 case TYPE_WIDE_CHAR: 550 #endif 551 #ifdef HAVE_WCHAR_T 552 case TYPE_WIDE_STRING: 553 #endif 554 *p++ = 'l'; 555 break; 556 #ifdef HAVE_LONG_DOUBLE 557 case TYPE_LONGDOUBLE: 558 *p++ = 'L'; 559 break; 560 #endif 561 default: 562 break; 563 } 564 *p = dp->conversion; 565 #if USE_SNPRINTF 566 p[1] = '%'; 567 p[2] = 'n'; 568 p[3] = '\0'; 569 #else 570 p[1] = '\0'; 571 #endif 572 573 /* Construct the arguments for calling snprintf or sprintf. */ 574 prefix_count = 0; 575 if (dp->width_arg_index != ARG_NONE) 576 { 577 if (!(a.arg[dp->width_arg_index].type == TYPE_INT)) 578 abort (); 579 prefixes[prefix_count++] = a.arg[dp->width_arg_index].a.a_int; 580 } 581 if (dp->precision_arg_index != ARG_NONE) 582 { 583 if (!(a.arg[dp->precision_arg_index].type == TYPE_INT)) 584 abort (); 585 prefixes[prefix_count++] = a.arg[dp->precision_arg_index].a.a_int; 586 } 587 588 #if USE_SNPRINTF 589 /* Prepare checking whether snprintf returns the count 590 via %n. */ 591 ENSURE_ALLOCATION (xsum (length, 1)); 592 result[length] = '\0'; 593 #endif 594 595 for (;;) 596 { 597 size_t maxlen; 598 int count; 599 int retcount; 600 601 maxlen = allocated - length; 602 count = -1; 603 retcount = 0; 604 605 #if USE_SNPRINTF 606 # define SNPRINTF_BUF(arg) \ 607 switch (prefix_count) \ 608 { \ 609 case 0: \ 610 retcount = SNPRINTF (result + length, maxlen, buf, \ 611 arg, &count); \ 612 break; \ 613 case 1: \ 614 retcount = SNPRINTF (result + length, maxlen, buf, \ 615 prefixes[0], arg, &count); \ 616 break; \ 617 case 2: \ 618 retcount = SNPRINTF (result + length, maxlen, buf, \ 619 prefixes[0], prefixes[1], arg, \ 620 &count); \ 621 break; \ 622 default: \ 623 abort (); \ 624 } 625 #else 626 # define SNPRINTF_BUF(arg) \ 627 switch (prefix_count) \ 628 { \ 629 case 0: \ 630 count = sprintf (tmp, buf, arg); \ 631 break; \ 632 case 1: \ 633 count = sprintf (tmp, buf, prefixes[0], arg); \ 634 break; \ 635 case 2: \ 636 count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ 637 arg); \ 638 break; \ 639 default: \ 640 abort (); \ 641 } 642 #endif 643 644 switch (type) 645 { 646 case TYPE_SCHAR: 647 { 648 int arg = a.arg[dp->arg_index].a.a_schar; 649 SNPRINTF_BUF (arg); 650 } 651 break; 652 case TYPE_UCHAR: 653 { 654 unsigned int arg = a.arg[dp->arg_index].a.a_uchar; 655 SNPRINTF_BUF (arg); 656 } 657 break; 658 case TYPE_SHORT: 659 { 660 int arg = a.arg[dp->arg_index].a.a_short; 661 SNPRINTF_BUF (arg); 662 } 663 break; 664 case TYPE_USHORT: 665 { 666 unsigned int arg = a.arg[dp->arg_index].a.a_ushort; 667 SNPRINTF_BUF (arg); 668 } 669 break; 670 case TYPE_INT: 671 { 672 int arg = a.arg[dp->arg_index].a.a_int; 673 SNPRINTF_BUF (arg); 674 } 675 break; 676 case TYPE_UINT: 677 { 678 unsigned int arg = a.arg[dp->arg_index].a.a_uint; 679 SNPRINTF_BUF (arg); 680 } 681 break; 682 case TYPE_LONGINT: 683 { 684 long int arg = a.arg[dp->arg_index].a.a_longint; 685 SNPRINTF_BUF (arg); 686 } 687 break; 688 case TYPE_ULONGINT: 689 { 690 unsigned long int arg = a.arg[dp->arg_index].a.a_ulongint; 691 SNPRINTF_BUF (arg); 692 } 693 break; 694 #ifdef HAVE_LONG_LONG 695 case TYPE_LONGLONGINT: 696 { 697 long long int arg = a.arg[dp->arg_index].a.a_longlongint; 698 SNPRINTF_BUF (arg); 699 } 700 break; 701 case TYPE_ULONGLONGINT: 702 { 703 unsigned long long int arg = a.arg[dp->arg_index].a.a_ulonglongint; 704 SNPRINTF_BUF (arg); 705 } 706 break; 707 #endif 708 case TYPE_DOUBLE: 709 { 710 double arg = a.arg[dp->arg_index].a.a_double; 711 SNPRINTF_BUF (arg); 712 } 713 break; 714 #ifdef HAVE_LONG_DOUBLE 715 case TYPE_LONGDOUBLE: 716 { 717 long double arg = a.arg[dp->arg_index].a.a_longdouble; 718 SNPRINTF_BUF (arg); 719 } 720 break; 721 #endif 722 case TYPE_CHAR: 723 { 724 int arg = a.arg[dp->arg_index].a.a_char; 725 SNPRINTF_BUF (arg); 726 } 727 break; 728 #ifdef HAVE_WINT_T 729 case TYPE_WIDE_CHAR: 730 { 731 wint_t arg = a.arg[dp->arg_index].a.a_wide_char; 732 SNPRINTF_BUF (arg); 733 } 734 break; 735 #endif 736 case TYPE_STRING: 737 { 738 const char *arg = a.arg[dp->arg_index].a.a_string; 739 SNPRINTF_BUF (arg); 740 } 741 break; 742 #ifdef HAVE_WCHAR_T 743 case TYPE_WIDE_STRING: 744 { 745 const wchar_t *arg = a.arg[dp->arg_index].a.a_wide_string; 746 SNPRINTF_BUF (arg); 747 } 748 break; 749 #endif 750 case TYPE_POINTER: 751 { 752 void *arg = a.arg[dp->arg_index].a.a_pointer; 753 SNPRINTF_BUF (arg); 754 } 755 break; 756 default: 757 abort (); 758 } 759 760 #if USE_SNPRINTF 761 /* Portability: Not all implementations of snprintf() 762 are ISO C 99 compliant. Determine the number of 763 bytes that snprintf() has produced or would have 764 produced. */ 765 if (count >= 0) 766 { 767 /* Verify that snprintf() has NUL-terminated its 768 result. */ 769 if (count < maxlen && result[length + count] != '\0') 770 abort (); 771 /* Portability hack. */ 772 if (retcount > count) 773 count = retcount; 774 } 775 else 776 { 777 /* snprintf() doesn't understand the '%n' 778 directive. */ 779 if (p[1] != '\0') 780 { 781 /* Don't use the '%n' directive; instead, look 782 at the snprintf() return value. */ 783 p[1] = '\0'; 784 continue; 785 } 786 else 787 { 788 /* Look at the snprintf() return value. */ 789 if (retcount < 0) 790 { 791 /* HP-UX 10.20 snprintf() is doubly deficient: 792 It doesn't understand the '%n' directive, 793 *and* it returns -1 (rather than the length 794 that would have been required) when the 795 buffer is too small. */ 796 size_t bigger_need = 797 xsum (xtimes (allocated, 2), 12); 798 ENSURE_ALLOCATION (bigger_need); 799 continue; 800 } 801 else 802 count = retcount; 803 } 804 } 805 #endif 806 807 /* Attempt to handle failure. */ 808 if (count < 0) 809 { 810 if (!(result == resultbuf || result == NULL)) 811 free (result); 812 if (buf_malloced != NULL) 813 free (buf_malloced); 814 CLEANUP (); 815 errno = EINVAL; 816 return NULL; 817 } 818 819 #if !USE_SNPRINTF 820 if (count >= tmp_length) 821 /* tmp_length was incorrectly calculated - fix the 822 code above! */ 823 abort (); 824 #endif 825 826 /* Make room for the result. */ 827 if (count >= maxlen) 828 { 829 /* Need at least count bytes. But allocate 830 proportionally, to avoid looping eternally if 831 snprintf() reports a too small count. */ 832 size_t n = 833 xmax (xsum (length, count), xtimes (allocated, 2)); 834 835 ENSURE_ALLOCATION (n); 836 #if USE_SNPRINTF 837 continue; 838 #endif 839 } 840 841 #if USE_SNPRINTF 842 /* The snprintf() result did fit. */ 843 #else 844 /* Append the sprintf() result. */ 845 memcpy (result + length, tmp, count * sizeof (CHAR_T)); 846 if (tmp != tmpbuf) 847 free (tmp); 848 #endif 849 850 length += count; 851 break; 852 } 853 } 854 } 855 } 856 857 /* Add the final NUL. */ 858 ENSURE_ALLOCATION (xsum (length, 1)); 859 result[length] = '\0'; 860 861 if (result != resultbuf && length + 1 < allocated) 862 { 863 /* Shrink the allocated memory if possible. */ 864 CHAR_T *memory; 865 866 memory = (CHAR_T *) realloc (result, (length + 1) * sizeof (CHAR_T)); 867 if (memory != NULL) 868 result = memory; 869 } 870 871 if (buf_malloced != NULL) 872 free (buf_malloced); 873 CLEANUP (); 874 *lengthp = length; 875 if (length > INT_MAX) 876 goto length_overflow; 877 return result; 878 879 length_overflow: 880 /* We could produce such a big string, but its length doesn't fit into 881 an 'int'. POSIX says that snprintf() fails with errno = EOVERFLOW in 882 this case. */ 883 if (result != resultbuf) 884 free (result); 885 errno = EOVERFLOW; 886 return NULL; 887 888 out_of_memory: 889 if (!(result == resultbuf || result == NULL)) 890 free (result); 891 if (buf_malloced != NULL) 892 free (buf_malloced); 893 out_of_memory_1: 894 CLEANUP (); 895 errno = ENOMEM; 896 return NULL; 897 } 898 } 899 900 #undef SNPRINTF 901 #undef USE_SNPRINTF 902 #undef PRINTF_PARSE 903 #undef DIRECTIVES 904 #undef DIRECTIVE 905 #undef CHAR_T 906 #undef VASNPRINTF 907
Indexes created Fri Apr 03 00:24:04 UTC 2026