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