1 /*************************************************************************** 2 * _ _ ____ _ 3 * Project ___| | | | _ \| | 4 * / __| | | | |_) | | 5 * | (__| |_| | _ <| |___ 6 * \___|\___/|_| \_\_____| 7 * 8 * Copyright (C) 1999 - 2017, Daniel Stenberg, <daniel (at) haxx.se>, et al. 9 * 10 * This software is licensed as described in the file COPYING, which 11 * you should have received as part of this distribution. The terms 12 * are also available at https://curl.haxx.se/docs/copyright.html. 13 * 14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell 15 * copies of the Software, and permit persons to whom the Software is 16 * furnished to do so, under the terms of the COPYING file. 17 * 18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY 19 * KIND, either express or implied. 20 * 21 * 22 * Purpose: 23 * A merge of Bjorn Reese's format() function and Daniel's dsprintf() 24 * 1.0. A full blooded printf() clone with full support for <num>$ 25 * everywhere (parameters, widths and precisions) including variabled 26 * sized parameters (like doubles, long longs, long doubles and even 27 * void * in 64-bit architectures). 28 * 29 * Current restrictions: 30 * - Max 128 parameters 31 * - No 'long double' support. 32 * 33 * If you ever want truly portable and good *printf() clones, the project that 34 * took on from here is named 'Trio' and you find more details on the trio web 35 * page at https://daniel.haxx.se/projects/trio/ 36 */ 37 38 #include "curl_setup.h" 39 #include <curl/mprintf.h> 40 41 #include "curl_memory.h" 42 /* The last #include file should be: */ 43 #include "memdebug.h" 44 45 /* 46 * If SIZEOF_SIZE_T has not been defined, default to the size of long. 47 */ 48 49 #ifdef HAVE_LONGLONG 50 # define LONG_LONG_TYPE long long 51 # define HAVE_LONG_LONG_TYPE 52 #else 53 # if defined(_MSC_VER) && (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64) 54 # define LONG_LONG_TYPE __int64 55 # define HAVE_LONG_LONG_TYPE 56 # else 57 # undef LONG_LONG_TYPE 58 # undef HAVE_LONG_LONG_TYPE 59 # endif 60 #endif 61 62 /* 63 * Non-ANSI integer extensions 64 */ 65 66 #if (defined(__BORLANDC__) && (__BORLANDC__ >= 0x520)) || \ 67 (defined(__WATCOMC__) && defined(__386__)) || \ 68 (defined(__POCC__) && defined(_MSC_VER)) || \ 69 (defined(_WIN32_WCE)) || \ 70 (defined(__MINGW32__)) || \ 71 (defined(_MSC_VER) && (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64)) 72 # define MP_HAVE_INT_EXTENSIONS 73 #endif 74 75 /* 76 * Max integer data types that mprintf.c is capable 77 */ 78 79 #ifdef HAVE_LONG_LONG_TYPE 80 # define mp_intmax_t LONG_LONG_TYPE 81 # define mp_uintmax_t unsigned LONG_LONG_TYPE 82 #else 83 # define mp_intmax_t long 84 # define mp_uintmax_t unsigned long 85 #endif 86 87 #define BUFFSIZE 326 /* buffer for long-to-str and float-to-str calcs, should 88 fit negative DBL_MAX (317 letters) */ 89 #define MAX_PARAMETERS 128 /* lame static limit */ 90 91 #ifdef __AMIGA__ 92 # undef FORMAT_INT 93 #endif 94 95 /* Lower-case digits. */ 96 static const char lower_digits[] = "0123456789abcdefghijklmnopqrstuvwxyz"; 97 98 /* Upper-case digits. */ 99 static const char upper_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 100 101 #define OUTCHAR(x) \ 102 do{ \ 103 if(stream((unsigned char)(x), (FILE *)data) != -1) \ 104 done++; \ 105 else \ 106 return done; /* return immediately on failure */ \ 107 } WHILE_FALSE 108 109 /* Data type to read from the arglist */ 110 typedef enum { 111 FORMAT_UNKNOWN = 0, 112 FORMAT_STRING, 113 FORMAT_PTR, 114 FORMAT_INT, 115 FORMAT_INTPTR, 116 FORMAT_LONG, 117 FORMAT_LONGLONG, 118 FORMAT_DOUBLE, 119 FORMAT_LONGDOUBLE, 120 FORMAT_WIDTH /* For internal use */ 121 } FormatType; 122 123 /* conversion and display flags */ 124 enum { 125 FLAGS_NEW = 0, 126 FLAGS_SPACE = 1<<0, 127 FLAGS_SHOWSIGN = 1<<1, 128 FLAGS_LEFT = 1<<2, 129 FLAGS_ALT = 1<<3, 130 FLAGS_SHORT = 1<<4, 131 FLAGS_LONG = 1<<5, 132 FLAGS_LONGLONG = 1<<6, 133 FLAGS_LONGDOUBLE = 1<<7, 134 FLAGS_PAD_NIL = 1<<8, 135 FLAGS_UNSIGNED = 1<<9, 136 FLAGS_OCTAL = 1<<10, 137 FLAGS_HEX = 1<<11, 138 FLAGS_UPPER = 1<<12, 139 FLAGS_WIDTH = 1<<13, /* '*' or '*<num>$' used */ 140 FLAGS_WIDTHPARAM = 1<<14, /* width PARAMETER was specified */ 141 FLAGS_PREC = 1<<15, /* precision was specified */ 142 FLAGS_PRECPARAM = 1<<16, /* precision PARAMETER was specified */ 143 FLAGS_CHAR = 1<<17, /* %c story */ 144 FLAGS_FLOATE = 1<<18, /* %e or %E */ 145 FLAGS_FLOATG = 1<<19 /* %g or %G */ 146 }; 147 148 typedef struct { 149 FormatType type; 150 int flags; 151 long width; /* width OR width parameter number */ 152 long precision; /* precision OR precision parameter number */ 153 union { 154 char *str; 155 void *ptr; 156 union { 157 mp_intmax_t as_signed; 158 mp_uintmax_t as_unsigned; 159 } num; 160 double dnum; 161 } data; 162 } va_stack_t; 163 164 struct nsprintf { 165 char *buffer; 166 size_t length; 167 size_t max; 168 }; 169 170 struct asprintf { 171 char *buffer; /* allocated buffer */ 172 size_t len; /* length of string */ 173 size_t alloc; /* length of alloc */ 174 int fail; /* (!= 0) if an alloc has failed and thus 175 the output is not the complete data */ 176 }; 177 178 static long dprintf_DollarString(char *input, char **end) 179 { 180 int number = 0; 181 while(ISDIGIT(*input)) { 182 number *= 10; 183 number += *input-'0'; 184 input++; 185 } 186 if(number && ('$'==*input++)) { 187 *end = input; 188 return number; 189 } 190 return 0; 191 } 192 193 static bool dprintf_IsQualifierNoDollar(const char *fmt) 194 { 195 #if defined(MP_HAVE_INT_EXTENSIONS) 196 if(!strncmp(fmt, "I32", 3) || !strncmp(fmt, "I64", 3)) { 197 return TRUE; 198 } 199 #endif 200 201 switch(*fmt) { 202 case '-': case '+': case ' ': case '#': case '.': 203 case '0': case '1': case '2': case '3': case '4': 204 case '5': case '6': case '7': case '8': case '9': 205 case 'h': case 'l': case 'L': case 'z': case 'q': 206 case '*': case 'O': 207 #if defined(MP_HAVE_INT_EXTENSIONS) 208 case 'I': 209 #endif 210 return TRUE; 211 212 default: 213 return FALSE; 214 } 215 } 216 217 /****************************************************************** 218 * 219 * Pass 1: 220 * Create an index with the type of each parameter entry and its 221 * value (may vary in size) 222 * 223 * Returns zero on success. 224 * 225 ******************************************************************/ 226 227 static int dprintf_Pass1(const char *format, va_stack_t *vto, char **endpos, 228 va_list arglist) 229 { 230 char *fmt = (char *)format; 231 int param_num = 0; 232 long this_param; 233 long width; 234 long precision; 235 int flags; 236 long max_param = 0; 237 long i; 238 239 while(*fmt) { 240 if(*fmt++ == '%') { 241 if(*fmt == '%') { 242 fmt++; 243 continue; /* while */ 244 } 245 246 flags = FLAGS_NEW; 247 248 /* Handle the positional case (N$) */ 249 250 param_num++; 251 252 this_param = dprintf_DollarString(fmt, &fmt); 253 if(0 == this_param) 254 /* we got no positional, get the next counter */ 255 this_param = param_num; 256 257 if(this_param > max_param) 258 max_param = this_param; 259 260 /* 261 * The parameter with number 'i' should be used. Next, we need 262 * to get SIZE and TYPE of the parameter. Add the information 263 * to our array. 264 */ 265 266 width = 0; 267 precision = 0; 268 269 /* Handle the flags */ 270 271 while(dprintf_IsQualifierNoDollar(fmt)) { 272 #if defined(MP_HAVE_INT_EXTENSIONS) 273 if(!strncmp(fmt, "I32", 3)) { 274 flags |= FLAGS_LONG; 275 fmt += 3; 276 } 277 else if(!strncmp(fmt, "I64", 3)) { 278 flags |= FLAGS_LONGLONG; 279 fmt += 3; 280 } 281 else 282 #endif 283 284 switch(*fmt++) { 285 case ' ': 286 flags |= FLAGS_SPACE; 287 break; 288 case '+': 289 flags |= FLAGS_SHOWSIGN; 290 break; 291 case '-': 292 flags |= FLAGS_LEFT; 293 flags &= ~FLAGS_PAD_NIL; 294 break; 295 case '#': 296 flags |= FLAGS_ALT; 297 break; 298 case '.': 299 if('*' == *fmt) { 300 /* The precision is picked from a specified parameter */ 301 302 flags |= FLAGS_PRECPARAM; 303 fmt++; 304 param_num++; 305 306 i = dprintf_DollarString(fmt, &fmt); 307 if(i) 308 precision = i; 309 else 310 precision = param_num; 311 312 if(precision > max_param) 313 max_param = precision; 314 } 315 else { 316 flags |= FLAGS_PREC; 317 precision = strtol(fmt, &fmt, 10); 318 } 319 break; 320 case 'h': 321 flags |= FLAGS_SHORT; 322 break; 323 #if defined(MP_HAVE_INT_EXTENSIONS) 324 case 'I': 325 #if (SIZEOF_CURL_OFF_T > SIZEOF_LONG) 326 flags |= FLAGS_LONGLONG; 327 #else 328 flags |= FLAGS_LONG; 329 #endif 330 break; 331 #endif 332 case 'l': 333 if(flags & FLAGS_LONG) 334 flags |= FLAGS_LONGLONG; 335 else 336 flags |= FLAGS_LONG; 337 break; 338 case 'L': 339 flags |= FLAGS_LONGDOUBLE; 340 break; 341 case 'q': 342 flags |= FLAGS_LONGLONG; 343 break; 344 case 'z': 345 /* the code below generates a warning if -Wunreachable-code is 346 used */ 347 #if (SIZEOF_SIZE_T > SIZEOF_LONG) 348 flags |= FLAGS_LONGLONG; 349 #else 350 flags |= FLAGS_LONG; 351 #endif 352 break; 353 case 'O': 354 #if (SIZEOF_CURL_OFF_T > SIZEOF_LONG) 355 flags |= FLAGS_LONGLONG; 356 #else 357 flags |= FLAGS_LONG; 358 #endif 359 break; 360 case '0': 361 if(!(flags & FLAGS_LEFT)) 362 flags |= FLAGS_PAD_NIL; 363 /* FALLTHROUGH */ 364 case '1': case '2': case '3': case '4': 365 case '5': case '6': case '7': case '8': case '9': 366 flags |= FLAGS_WIDTH; 367 width = strtol(fmt-1, &fmt, 10); 368 break; 369 case '*': /* Special case */ 370 flags |= FLAGS_WIDTHPARAM; 371 param_num++; 372 373 i = dprintf_DollarString(fmt, &fmt); 374 if(i) 375 width = i; 376 else 377 width = param_num; 378 if(width > max_param) 379 max_param = width; 380 break; 381 default: 382 break; 383 } 384 } /* switch */ 385 386 /* Handle the specifier */ 387 388 i = this_param - 1; 389 390 if((i < 0) || (i >= MAX_PARAMETERS)) 391 /* out of allowed range */ 392 return 1; 393 394 switch (*fmt) { 395 case 'S': 396 flags |= FLAGS_ALT; 397 /* FALLTHROUGH */ 398 case 's': 399 vto[i].type = FORMAT_STRING; 400 break; 401 case 'n': 402 vto[i].type = FORMAT_INTPTR; 403 break; 404 case 'p': 405 vto[i].type = FORMAT_PTR; 406 break; 407 case 'd': case 'i': 408 vto[i].type = FORMAT_INT; 409 break; 410 case 'u': 411 vto[i].type = FORMAT_INT; 412 flags |= FLAGS_UNSIGNED; 413 break; 414 case 'o': 415 vto[i].type = FORMAT_INT; 416 flags |= FLAGS_OCTAL; 417 break; 418 case 'x': 419 vto[i].type = FORMAT_INT; 420 flags |= FLAGS_HEX|FLAGS_UNSIGNED; 421 break; 422 case 'X': 423 vto[i].type = FORMAT_INT; 424 flags |= FLAGS_HEX|FLAGS_UPPER|FLAGS_UNSIGNED; 425 break; 426 case 'c': 427 vto[i].type = FORMAT_INT; 428 flags |= FLAGS_CHAR; 429 break; 430 case 'f': 431 vto[i].type = FORMAT_DOUBLE; 432 break; 433 case 'e': 434 vto[i].type = FORMAT_DOUBLE; 435 flags |= FLAGS_FLOATE; 436 break; 437 case 'E': 438 vto[i].type = FORMAT_DOUBLE; 439 flags |= FLAGS_FLOATE|FLAGS_UPPER; 440 break; 441 case 'g': 442 vto[i].type = FORMAT_DOUBLE; 443 flags |= FLAGS_FLOATG; 444 break; 445 case 'G': 446 vto[i].type = FORMAT_DOUBLE; 447 flags |= FLAGS_FLOATG|FLAGS_UPPER; 448 break; 449 default: 450 vto[i].type = FORMAT_UNKNOWN; 451 break; 452 } /* switch */ 453 454 vto[i].flags = flags; 455 vto[i].width = width; 456 vto[i].precision = precision; 457 458 if(flags & FLAGS_WIDTHPARAM) { 459 /* we have the width specified from a parameter, so we make that 460 parameter's info setup properly */ 461 long k = width - 1; 462 vto[i].width = k; 463 vto[k].type = FORMAT_WIDTH; 464 vto[k].flags = FLAGS_NEW; 465 /* can't use width or precision of width! */ 466 vto[k].width = 0; 467 vto[k].precision = 0; 468 } 469 if(flags & FLAGS_PRECPARAM) { 470 /* we have the precision specified from a parameter, so we make that 471 parameter's info setup properly */ 472 long k = precision - 1; 473 vto[i].precision = k; 474 vto[k].type = FORMAT_WIDTH; 475 vto[k].flags = FLAGS_NEW; 476 /* can't use width or precision of width! */ 477 vto[k].width = 0; 478 vto[k].precision = 0; 479 } 480 *endpos++ = fmt + 1; /* end of this sequence */ 481 } 482 } 483 484 /* Read the arg list parameters into our data list */ 485 for(i = 0; i<max_param; i++) { 486 /* Width/precision arguments must be read before the main argument 487 they are attached to */ 488 if(vto[i].flags & FLAGS_WIDTHPARAM) { 489 vto[vto[i].width].data.num.as_signed = 490 (mp_intmax_t)va_arg(arglist, int); 491 } 492 if(vto[i].flags & FLAGS_PRECPARAM) { 493 vto[vto[i].precision].data.num.as_signed = 494 (mp_intmax_t)va_arg(arglist, int); 495 } 496 497 switch(vto[i].type) { 498 case FORMAT_STRING: 499 vto[i].data.str = va_arg(arglist, char *); 500 break; 501 502 case FORMAT_INTPTR: 503 case FORMAT_UNKNOWN: 504 case FORMAT_PTR: 505 vto[i].data.ptr = va_arg(arglist, void *); 506 break; 507 508 case FORMAT_INT: 509 #ifdef HAVE_LONG_LONG_TYPE 510 if((vto[i].flags & FLAGS_LONGLONG) && (vto[i].flags & FLAGS_UNSIGNED)) 511 vto[i].data.num.as_unsigned = 512 (mp_uintmax_t)va_arg(arglist, mp_uintmax_t); 513 else if(vto[i].flags & FLAGS_LONGLONG) 514 vto[i].data.num.as_signed = 515 (mp_intmax_t)va_arg(arglist, mp_intmax_t); 516 else 517 #endif 518 { 519 if((vto[i].flags & FLAGS_LONG) && (vto[i].flags & FLAGS_UNSIGNED)) 520 vto[i].data.num.as_unsigned = 521 (mp_uintmax_t)va_arg(arglist, unsigned long); 522 else if(vto[i].flags & FLAGS_LONG) 523 vto[i].data.num.as_signed = 524 (mp_intmax_t)va_arg(arglist, long); 525 else if(vto[i].flags & FLAGS_UNSIGNED) 526 vto[i].data.num.as_unsigned = 527 (mp_uintmax_t)va_arg(arglist, unsigned int); 528 else 529 vto[i].data.num.as_signed = 530 (mp_intmax_t)va_arg(arglist, int); 531 } 532 break; 533 534 case FORMAT_DOUBLE: 535 vto[i].data.dnum = va_arg(arglist, double); 536 break; 537 538 case FORMAT_WIDTH: 539 /* Argument has been read. Silently convert it into an integer 540 * for later use 541 */ 542 vto[i].type = FORMAT_INT; 543 break; 544 545 default: 546 break; 547 } 548 } 549 550 return 0; 551 552 } 553 554 static int dprintf_formatf( 555 void *data, /* untouched by format(), just sent to the stream() function in 556 the second argument */ 557 /* function pointer called for each output character */ 558 int (*stream)(int, FILE *), 559 const char *format, /* %-formatted string */ 560 va_list ap_save) /* list of parameters */ 561 { 562 /* Base-36 digits for numbers. */ 563 const char *digits = lower_digits; 564 565 /* Pointer into the format string. */ 566 char *f; 567 568 /* Number of characters written. */ 569 int done = 0; 570 571 long param; /* current parameter to read */ 572 long param_num = 0; /* parameter counter */ 573 574 va_stack_t vto[MAX_PARAMETERS]; 575 char *endpos[MAX_PARAMETERS]; 576 char **end; 577 578 char work[BUFFSIZE]; 579 580 va_stack_t *p; 581 582 /* 'workend' points to the final buffer byte position, but with an extra 583 byte as margin to avoid the (false?) warning Coverity gives us 584 otherwise */ 585 char *workend = &work[sizeof(work) - 2]; 586 587 /* Do the actual %-code parsing */ 588 if(dprintf_Pass1(format, vto, endpos, ap_save)) 589 return -1; 590 591 end = &endpos[0]; /* the initial end-position from the list dprintf_Pass1() 592 created for us */ 593 594 f = (char *)format; 595 while(*f != '\0') { 596 /* Format spec modifiers. */ 597 int is_alt; 598 599 /* Width of a field. */ 600 long width; 601 602 /* Precision of a field. */ 603 long prec; 604 605 /* Decimal integer is negative. */ 606 int is_neg; 607 608 /* Base of a number to be written. */ 609 unsigned long base; 610 611 /* Integral values to be written. */ 612 mp_uintmax_t num; 613 614 /* Used to convert negative in positive. */ 615 mp_intmax_t signed_num; 616 617 char *w; 618 619 if(*f != '%') { 620 /* This isn't a format spec, so write everything out until the next one 621 OR end of string is reached. */ 622 do { 623 OUTCHAR(*f); 624 } while(*++f && ('%' != *f)); 625 continue; 626 } 627 628 ++f; 629 630 /* Check for "%%". Note that although the ANSI standard lists 631 '%' as a conversion specifier, it says "The complete format 632 specification shall be `%%'," so we can avoid all the width 633 and precision processing. */ 634 if(*f == '%') { 635 ++f; 636 OUTCHAR('%'); 637 continue; 638 } 639 640 /* If this is a positional parameter, the position must follow immediately 641 after the %, thus create a %<num>$ sequence */ 642 param = dprintf_DollarString(f, &f); 643 644 if(!param) 645 param = param_num; 646 else 647 --param; 648 649 param_num++; /* increase this always to allow "%2$s %1$s %s" and then the 650 third %s will pick the 3rd argument */ 651 652 p = &vto[param]; 653 654 /* pick up the specified width */ 655 if(p->flags & FLAGS_WIDTHPARAM) { 656 width = (long)vto[p->width].data.num.as_signed; 657 param_num++; /* since the width is extracted from a parameter, we 658 must skip that to get to the next one properly */ 659 if(width < 0) { 660 /* "A negative field width is taken as a '-' flag followed by a 661 positive field width." */ 662 width = -width; 663 p->flags |= FLAGS_LEFT; 664 p->flags &= ~FLAGS_PAD_NIL; 665 } 666 } 667 else 668 width = p->width; 669 670 /* pick up the specified precision */ 671 if(p->flags & FLAGS_PRECPARAM) { 672 prec = (long)vto[p->precision].data.num.as_signed; 673 param_num++; /* since the precision is extracted from a parameter, we 674 must skip that to get to the next one properly */ 675 if(prec < 0) 676 /* "A negative precision is taken as if the precision were 677 omitted." */ 678 prec = -1; 679 } 680 else if(p->flags & FLAGS_PREC) 681 prec = p->precision; 682 else 683 prec = -1; 684 685 is_alt = (p->flags & FLAGS_ALT) ? 1 : 0; 686 687 switch(p->type) { 688 case FORMAT_INT: 689 num = p->data.num.as_unsigned; 690 if(p->flags & FLAGS_CHAR) { 691 /* Character. */ 692 if(!(p->flags & FLAGS_LEFT)) 693 while(--width > 0) 694 OUTCHAR(' '); 695 OUTCHAR((char) num); 696 if(p->flags & FLAGS_LEFT) 697 while(--width > 0) 698 OUTCHAR(' '); 699 break; 700 } 701 if(p->flags & FLAGS_OCTAL) { 702 /* Octal unsigned integer. */ 703 base = 8; 704 goto unsigned_number; 705 } 706 else if(p->flags & FLAGS_HEX) { 707 /* Hexadecimal unsigned integer. */ 708 709 digits = (p->flags & FLAGS_UPPER)? upper_digits : lower_digits; 710 base = 16; 711 goto unsigned_number; 712 } 713 else if(p->flags & FLAGS_UNSIGNED) { 714 /* Decimal unsigned integer. */ 715 base = 10; 716 goto unsigned_number; 717 } 718 719 /* Decimal integer. */ 720 base = 10; 721 722 is_neg = (p->data.num.as_signed < (mp_intmax_t)0) ? 1 : 0; 723 if(is_neg) { 724 /* signed_num might fail to hold absolute negative minimum by 1 */ 725 signed_num = p->data.num.as_signed + (mp_intmax_t)1; 726 signed_num = -signed_num; 727 num = (mp_uintmax_t)signed_num; 728 num += (mp_uintmax_t)1; 729 } 730 731 goto number; 732 733 unsigned_number: 734 /* Unsigned number of base BASE. */ 735 is_neg = 0; 736 737 number: 738 /* Number of base BASE. */ 739 740 /* Supply a default precision if none was given. */ 741 if(prec == -1) 742 prec = 1; 743 744 /* Put the number in WORK. */ 745 w = workend; 746 while(num > 0) { 747 *w-- = digits[num % base]; 748 num /= base; 749 } 750 width -= (long)(workend - w); 751 prec -= (long)(workend - w); 752 753 if(is_alt && base == 8 && prec <= 0) { 754 *w-- = '0'; 755 --width; 756 } 757 758 if(prec > 0) { 759 width -= prec; 760 while(prec-- > 0) 761 *w-- = '0'; 762 } 763 764 if(is_alt && base == 16) 765 width -= 2; 766 767 if(is_neg || (p->flags & FLAGS_SHOWSIGN) || (p->flags & FLAGS_SPACE)) 768 --width; 769 770 if(!(p->flags & FLAGS_LEFT) && !(p->flags & FLAGS_PAD_NIL)) 771 while(width-- > 0) 772 OUTCHAR(' '); 773 774 if(is_neg) 775 OUTCHAR('-'); 776 else if(p->flags & FLAGS_SHOWSIGN) 777 OUTCHAR('+'); 778 else if(p->flags & FLAGS_SPACE) 779 OUTCHAR(' '); 780 781 if(is_alt && base == 16) { 782 OUTCHAR('0'); 783 if(p->flags & FLAGS_UPPER) 784 OUTCHAR('X'); 785 else 786 OUTCHAR('x'); 787 } 788 789 if(!(p->flags & FLAGS_LEFT) && (p->flags & FLAGS_PAD_NIL)) 790 while(width-- > 0) 791 OUTCHAR('0'); 792 793 /* Write the number. */ 794 while(++w <= workend) { 795 OUTCHAR(*w); 796 } 797 798 if(p->flags & FLAGS_LEFT) 799 while(width-- > 0) 800 OUTCHAR(' '); 801 break; 802 803 case FORMAT_STRING: 804 /* String. */ 805 { 806 static const char null[] = "(nil)"; 807 const char *str; 808 size_t len; 809 810 str = (char *) p->data.str; 811 if(str == NULL) { 812 /* Write null[] if there's space. */ 813 if(prec == -1 || prec >= (long) sizeof(null) - 1) { 814 str = null; 815 len = sizeof(null) - 1; 816 /* Disable quotes around (nil) */ 817 p->flags &= (~FLAGS_ALT); 818 } 819 else { 820 str = ""; 821 len = 0; 822 } 823 } 824 else if(prec != -1) 825 len = (size_t)prec; 826 else 827 len = strlen(str); 828 829 width -= (len > LONG_MAX) ? LONG_MAX : (long)len; 830 831 if(p->flags & FLAGS_ALT) 832 OUTCHAR('"'); 833 834 if(!(p->flags&FLAGS_LEFT)) 835 while(width-- > 0) 836 OUTCHAR(' '); 837 838 while((len-- > 0) && *str) 839 OUTCHAR(*str++); 840 if(p->flags&FLAGS_LEFT) 841 while(width-- > 0) 842 OUTCHAR(' '); 843 844 if(p->flags & FLAGS_ALT) 845 OUTCHAR('"'); 846 } 847 break; 848 849 case FORMAT_PTR: 850 /* Generic pointer. */ 851 { 852 void *ptr; 853 ptr = (void *) p->data.ptr; 854 if(ptr != NULL) { 855 /* If the pointer is not NULL, write it as a %#x spec. */ 856 base = 16; 857 digits = (p->flags & FLAGS_UPPER)? upper_digits : lower_digits; 858 is_alt = 1; 859 num = (size_t) ptr; 860 is_neg = 0; 861 goto number; 862 } 863 else { 864 /* Write "(nil)" for a nil pointer. */ 865 static const char strnil[] = "(nil)"; 866 const char *point; 867 868 width -= (long)(sizeof(strnil) - 1); 869 if(p->flags & FLAGS_LEFT) 870 while(width-- > 0) 871 OUTCHAR(' '); 872 for(point = strnil; *point != '\0'; ++point) 873 OUTCHAR(*point); 874 if(! (p->flags & FLAGS_LEFT)) 875 while(width-- > 0) 876 OUTCHAR(' '); 877 } 878 } 879 break; 880 881 case FORMAT_DOUBLE: 882 { 883 char formatbuf[32]="%"; 884 char *fptr = &formatbuf[1]; 885 size_t left = sizeof(formatbuf)-strlen(formatbuf); 886 int len; 887 888 width = -1; 889 if(p->flags & FLAGS_WIDTH) 890 width = p->width; 891 else if(p->flags & FLAGS_WIDTHPARAM) 892 width = (long)vto[p->width].data.num.as_signed; 893 894 prec = -1; 895 if(p->flags & FLAGS_PREC) 896 prec = p->precision; 897 else if(p->flags & FLAGS_PRECPARAM) 898 prec = (long)vto[p->precision].data.num.as_signed; 899 900 if(p->flags & FLAGS_LEFT) 901 *fptr++ = '-'; 902 if(p->flags & FLAGS_SHOWSIGN) 903 *fptr++ = '+'; 904 if(p->flags & FLAGS_SPACE) 905 *fptr++ = ' '; 906 if(p->flags & FLAGS_ALT) 907 *fptr++ = '#'; 908 909 *fptr = 0; 910 911 if(width >= 0) { 912 if(width >= (long)sizeof(work)) 913 width = sizeof(work)-1; 914 /* RECURSIVE USAGE */ 915 len = curl_msnprintf(fptr, left, "%ld", width); 916 fptr += len; 917 left -= len; 918 } 919 if(prec >= 0) { 920 /* for each digit in the integer part, we can have one less 921 precision */ 922 size_t maxprec = sizeof(work) - 2; 923 double val = p->data.dnum; 924 while(val >= 10.0) { 925 val /= 10; 926 maxprec--; 927 } 928 929 if(prec > (long)maxprec) 930 prec = (long)maxprec-1; 931 /* RECURSIVE USAGE */ 932 len = curl_msnprintf(fptr, left, ".%ld", prec); 933 fptr += len; 934 } 935 if(p->flags & FLAGS_LONG) 936 *fptr++ = 'l'; 937 938 if(p->flags & FLAGS_FLOATE) 939 *fptr++ = (char)((p->flags & FLAGS_UPPER) ? 'E':'e'); 940 else if(p->flags & FLAGS_FLOATG) 941 *fptr++ = (char)((p->flags & FLAGS_UPPER) ? 'G' : 'g'); 942 else 943 *fptr++ = 'f'; 944 945 *fptr = 0; /* and a final zero termination */ 946 947 /* NOTE NOTE NOTE!! Not all sprintf implementations return number of 948 output characters */ 949 (sprintf)(work, formatbuf, p->data.dnum); 950 DEBUGASSERT(strlen(work) <= sizeof(work)); 951 for(fptr = work; *fptr; fptr++) 952 OUTCHAR(*fptr); 953 } 954 break; 955 956 case FORMAT_INTPTR: 957 /* Answer the count of characters written. */ 958 #ifdef HAVE_LONG_LONG_TYPE 959 if(p->flags & FLAGS_LONGLONG) 960 *(LONG_LONG_TYPE *) p->data.ptr = (LONG_LONG_TYPE)done; 961 else 962 #endif 963 if(p->flags & FLAGS_LONG) 964 *(long *) p->data.ptr = (long)done; 965 else if(!(p->flags & FLAGS_SHORT)) 966 *(int *) p->data.ptr = (int)done; 967 else 968 *(short *) p->data.ptr = (short)done; 969 break; 970 971 default: 972 break; 973 } 974 f = *end++; /* goto end of %-code */ 975 976 } 977 return done; 978 } 979 980 /* fputc() look-alike */ 981 static int addbyter(int output, FILE *data) 982 { 983 struct nsprintf *infop = (struct nsprintf *)data; 984 unsigned char outc = (unsigned char)output; 985 986 if(infop->length < infop->max) { 987 /* only do this if we haven't reached max length yet */ 988 infop->buffer[0] = outc; /* store */ 989 infop->buffer++; /* increase pointer */ 990 infop->length++; /* we are now one byte larger */ 991 return outc; /* fputc() returns like this on success */ 992 } 993 return -1; 994 } 995 996 int curl_mvsnprintf(char *buffer, size_t maxlength, const char *format, 997 va_list ap_save) 998 { 999 int retcode; 1000 struct nsprintf info; 1001 1002 info.buffer = buffer; 1003 info.length = 0; 1004 info.max = maxlength; 1005 1006 retcode = dprintf_formatf(&info, addbyter, format, ap_save); 1007 if((retcode != -1) && info.max) { 1008 /* we terminate this with a zero byte */ 1009 if(info.max == info.length) 1010 /* we're at maximum, scrap the last letter */ 1011 info.buffer[-1] = 0; 1012 else 1013 info.buffer[0] = 0; 1014 } 1015 return retcode; 1016 } 1017 1018 int curl_msnprintf(char *buffer, size_t maxlength, const char *format, ...) 1019 { 1020 int retcode; 1021 va_list ap_save; /* argument pointer */ 1022 va_start(ap_save, format); 1023 retcode = curl_mvsnprintf(buffer, maxlength, format, ap_save); 1024 va_end(ap_save); 1025 return retcode; 1026 } 1027 1028 /* fputc() look-alike */ 1029 static int alloc_addbyter(int output, FILE *data) 1030 { 1031 struct asprintf *infop = (struct asprintf *)data; 1032 unsigned char outc = (unsigned char)output; 1033 1034 if(!infop->buffer) { 1035 infop->buffer = malloc(32); 1036 if(!infop->buffer) { 1037 infop->fail = 1; 1038 return -1; /* fail */ 1039 } 1040 infop->alloc = 32; 1041 infop->len = 0; 1042 } 1043 else if(infop->len + 1 >= infop->alloc) { 1044 char *newptr = NULL; 1045 size_t newsize = infop->alloc*2; 1046 1047 /* detect wrap-around or other overflow problems */ 1048 if(newsize > infop->alloc) 1049 newptr = realloc(infop->buffer, newsize); 1050 1051 if(!newptr) { 1052 infop->fail = 1; 1053 return -1; /* fail */ 1054 } 1055 infop->buffer = newptr; 1056 infop->alloc = newsize; 1057 } 1058 1059 infop->buffer[ infop->len ] = outc; 1060 1061 infop->len++; 1062 1063 return outc; /* fputc() returns like this on success */ 1064 } 1065 1066 char *curl_maprintf(const char *format, ...) 1067 { 1068 va_list ap_save; /* argument pointer */ 1069 int retcode; 1070 struct asprintf info; 1071 1072 info.buffer = NULL; 1073 info.len = 0; 1074 info.alloc = 0; 1075 info.fail = 0; 1076 1077 va_start(ap_save, format); 1078 retcode = dprintf_formatf(&info, alloc_addbyter, format, ap_save); 1079 va_end(ap_save); 1080 if((-1 == retcode) || info.fail) { 1081 if(info.alloc) 1082 free(info.buffer); 1083 return NULL; 1084 } 1085 if(info.alloc) { 1086 info.buffer[info.len] = 0; /* we terminate this with a zero byte */ 1087 return info.buffer; 1088 } 1089 return strdup(""); 1090 } 1091 1092 char *curl_mvaprintf(const char *format, va_list ap_save) 1093 { 1094 int retcode; 1095 struct asprintf info; 1096 1097 info.buffer = NULL; 1098 info.len = 0; 1099 info.alloc = 0; 1100 info.fail = 0; 1101 1102 retcode = dprintf_formatf(&info, alloc_addbyter, format, ap_save); 1103 if((-1 == retcode) || info.fail) { 1104 if(info.alloc) 1105 free(info.buffer); 1106 return NULL; 1107 } 1108 1109 if(info.alloc) { 1110 info.buffer[info.len] = 0; /* we terminate this with a zero byte */ 1111 return info.buffer; 1112 } 1113 return strdup(""); 1114 } 1115 1116 static int storebuffer(int output, FILE *data) 1117 { 1118 char **buffer = (char **)data; 1119 unsigned char outc = (unsigned char)output; 1120 **buffer = outc; 1121 (*buffer)++; 1122 return outc; /* act like fputc() ! */ 1123 } 1124 1125 int curl_msprintf(char *buffer, const char *format, ...) 1126 { 1127 va_list ap_save; /* argument pointer */ 1128 int retcode; 1129 va_start(ap_save, format); 1130 retcode = dprintf_formatf(&buffer, storebuffer, format, ap_save); 1131 va_end(ap_save); 1132 *buffer = 0; /* we terminate this with a zero byte */ 1133 return retcode; 1134 } 1135 1136 int curl_mprintf(const char *format, ...) 1137 { 1138 int retcode; 1139 va_list ap_save; /* argument pointer */ 1140 va_start(ap_save, format); 1141 1142 retcode = dprintf_formatf(stdout, fputc, format, ap_save); 1143 va_end(ap_save); 1144 return retcode; 1145 } 1146 1147 int curl_mfprintf(FILE *whereto, const char *format, ...) 1148 { 1149 int retcode; 1150 va_list ap_save; /* argument pointer */ 1151 va_start(ap_save, format); 1152 retcode = dprintf_formatf(whereto, fputc, format, ap_save); 1153 va_end(ap_save); 1154 return retcode; 1155 } 1156 1157 int curl_mvsprintf(char *buffer, const char *format, va_list ap_save) 1158 { 1159 int retcode; 1160 retcode = dprintf_formatf(&buffer, storebuffer, format, ap_save); 1161 *buffer = 0; /* we terminate this with a zero byte */ 1162 return retcode; 1163 } 1164 1165 int curl_mvprintf(const char *format, va_list ap_save) 1166 { 1167 return dprintf_formatf(stdout, fputc, format, ap_save); 1168 } 1169 1170 int curl_mvfprintf(FILE *whereto, const char *format, va_list ap_save) 1171 { 1172 return dprintf_formatf(whereto, fputc, format, ap_save); 1173 } 1174
