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