lib/mprintf.c

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