lib/mprintf.c

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