Annotation of embedaddon/curl/lib/mprintf.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1999 - 2019, Daniel Stenberg, <daniel@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(0)
! 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: for(; len && *str; len--)
! 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: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mprintf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib