WINGs/snprintf.c

   1 /*
   2  * Copyright Patrick Powell 1995
   3  * This code is based on code written by Patrick Powell (papowell@astart.com)
   4  * It may be used for any purpose as long as this notice remains intact
   5  * on all source code distributions
   6  */
   7
   8 /**************************************************************
   9  * Original:
  10  * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
  11  * A bombproof version of doprnt (dopr) included.
  12  * Sigh.  This sort of thing is always nasty do deal with.  Note that
  13  * the version here does not include floating point...
  14  *
  15  * snprintf() is used instead of sprintf() as it does limit checks
  16  * for string length.  This covers a nasty loophole.
  17  *
  18  * The other functions are there to prevent NULL pointers from
  19  * causing nast effects.
  20  *
  21  * More Recently:
  22  *  Brandon Long <blong@fiction.net> 9/15/96 for mutt 0.43
  23  *  This was ugly.  It is still ugly.  I opted out of floating point
  24  *  numbers, but the formatter understands just about everything
  25  *  from the normal C string format, at least as far as I can tell from
  26  *  the Solaris 2.5 printf(3S) man page.
  27  *
  28  *  Brandon Long <blong@fiction.net> 10/22/97 for mutt 0.87.1
  29  *    Ok, added some minimal floating point support, which means this
  30  *    probably requires libm on most operating systems.  Don't yet
  31  *    support the exponent (e,E) and sigfig (g,G).  Also, fmtint()
  32  *    was pretty badly broken, it just wasn't being exercised in ways
  33  *    which showed it, so that's been fixed.  Also, formated the code
  34  *    to mutt conventions, and removed dead code left over from the
  35  *    original.  Also, there is now a builtin-test, just compile with:
  36  *           gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm
  37  *    and run snprintf for results.
  38  *
  39  *  Thomas Roessler <roessler@guug.de> 01/27/98 for mutt 0.89i
  40  *    The PGP code was using unsigned hexadecimal formats.
  41  *    Unfortunately, unsigned formats simply didn't work.
  42  *
  43  *  Michael Elkins <me@cs.hmc.edu> 03/05/98 for mutt 0.90.8
  44  *    The original code assumed that both snprintf() and vsnprintf() were
  45  *    missing.  Some systems only have snprintf() but not vsnprintf(), so
  46  *    the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
  47  *
  48  *  Andrew Tridgell (tridge@samba.org) Oct 1998
  49  *    fixed handling of %.0f
  50  *    added test for HAVE_LONG_DOUBLE
  51  *
  52  * tridge@samba.org, idra@samba.org, April 2001
  53  *    got rid of fcvt code (twas buggy and made testing harder)
  54  *    added C99 semantics
  55  *
  56  **************************************************************/
  57
  58 #ifndef NO_CONFIG_H             /* for some tests */
  59 #include "config.h"
  60 #endif
  61
  62 #ifdef HAVE_STRING_H
  63 #include <string.h>
  64 #endif
  65
  66 #ifdef HAVE_STRINGS_H
  67 #include <strings.h>
  68 #endif
  69 #ifdef HAVE_CTYPE_H
  70 #include <ctype.h>
  71 #endif
  72 #include <sys/types.h>
  73 #include <stdarg.h>
  74 #ifdef HAVE_STDLIB_H
  75 #include <stdlib.h>
  76 #endif
  77
  78 #if defined(HAVE_SNPRINTF) && defined(HAVE_VSNPRINTF) && defined(HAVE_C99_VSNPRINTF)
  79 /* only include stdio.h if we are not re-defining snprintf or vsnprintf */
  80 #include <stdio.h>
  81 /* make the compiler happy with an empty file */
  82 void dummy_snprintf(void)
  83 {
  84 }
  85 #else
  86
  87 #ifdef HAVE_LONG_DOUBLE
  88 #define LDOUBLE long double
  89 #else
  90 #define LDOUBLE double
  91 #endif
  92
  93 #ifdef HAVE_LONG_LONG
  94 #define LLONG long long
  95 #else
  96 #define LLONG long
  97 #endif
  98
  99 static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args);
 100 static void fmtstr(char *buffer, size_t * currlen, size_t maxlen, char *value, int flags, int min, int max);
 101 static void fmtint(char *buffer, size_t * currlen, size_t maxlen,
 102                    long value, int base, int min, int max, int flags);
 103 static void fmtfp(char *buffer, size_t * currlen, size_t maxlen, LDOUBLE fvalue, int min, int max, int flags);
 104 static void dopr_outch(char *buffer, size_t * currlen, size_t maxlen, char c);
 105
 106 /*
 107  * dopr(): poor man's version of doprintf
 108  */
 109
 110 /* format read states */
 111 #define DP_S_DEFAULT 0
 112 #define DP_S_FLAGS   1
 113 #define DP_S_MIN     2
 114 #define DP_S_DOT     3
 115 #define DP_S_MAX     4
 116 #define DP_S_MOD     5
 117 #define DP_S_CONV    6
 118 #define DP_S_DONE    7
 119
 120 /* format flags - Bits */
 121 #define DP_F_MINUS      (1 << 0)
 122 #define DP_F_PLUS       (1 << 1)
 123 #define DP_F_SPACE      (1 << 2)
 124 #define DP_F_NUM        (1 << 3)
 125 #define DP_F_ZERO       (1 << 4)
 126 #define DP_F_UP         (1 << 5)
 127 #define DP_F_UNSIGNED   (1 << 6)
 128
 129 /* Conversion Flags */
 130 #define DP_C_SHORT   1
 131 #define DP_C_LONG    2
 132 #define DP_C_LDOUBLE 3
 133 #define DP_C_LLONG   4
 134
 135 #define char_to_int(p) ((p)- '0')
 136 #ifndef MAX
 137 #define MAX(p,q) (((p) >= (q)) ? (p) : (q))
 138 #endif
 139
 140 static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args)
 141 {
 142         char ch;
 143         LLONG value;
 144         LDOUBLE fvalue;
 145         char *strvalue;
 146         int min;
 147         int max;
 148         int state;
 149         int flags;
 150         int cflags;
 151         size_t currlen;
 152
 153         state = DP_S_DEFAULT;
 154         currlen = flags = cflags = min = 0;
 155         max = -1;
 156         ch = *format++;
 157
 158         while (state != DP_S_DONE) {
 159                 if (ch == '\0')
 160                         state = DP_S_DONE;
 161
 162                 switch (state) {
 163                 case DP_S_DEFAULT:
 164                         if (ch == '%')
 165                                 state = DP_S_FLAGS;
 166                         else
 167                                 dopr_outch(buffer, &currlen, maxlen, ch);
 168                         ch = *format++;
 169                         break;
 170                 case DP_S_FLAGS:
 171                         switch (ch) {
 172                         case '-':
 173                                 flags |= DP_F_MINUS;
 174                                 ch = *format++;
 175                                 break;
 176                         case '+':
 177                                 flags |= DP_F_PLUS;
 178                                 ch = *format++;
 179                                 break;
 180                         case ' ':
 181                                 flags |= DP_F_SPACE;
 182                                 ch = *format++;
 183                                 break;
 184                         case '#':
 185                                 flags |= DP_F_NUM;
 186                                 ch = *format++;
 187                                 break;
 188                         case '0':
 189                                 flags |= DP_F_ZERO;
 190                                 ch = *format++;
 191                                 break;
 192                         default:
 193                                 state = DP_S_MIN;
 194                                 break;
 195                         }
 196                         break;
 197                 case DP_S_MIN:
 198                         if (isdigit((unsigned char)ch)) {
 199                                 min = 10 * min + char_to_int(ch);
 200                                 ch = *format++;
 201                         } else if (ch == '*') {
 202                                 min = va_arg(args, int);
 203                                 ch = *format++;
 204                                 state = DP_S_DOT;
 205                         } else {
 206                                 state = DP_S_DOT;
 207                         }
 208                         break;
 209                 case DP_S_DOT:
 210                         if (ch == '.') {
 211                                 state = DP_S_MAX;
 212                                 ch = *format++;
 213                         } else {
 214                                 state = DP_S_MOD;
 215                         }
 216                         break;
 217                 case DP_S_MAX:
 218                         if (isdigit((unsigned char)ch)) {
 219                                 if (max < 0)
 220                                         max = 0;
 221                                 max = 10 * max + char_to_int(ch);
 222                                 ch = *format++;
 223                         } else if (ch == '*') {
 224                                 max = va_arg(args, int);
 225                                 ch = *format++;
 226                                 state = DP_S_MOD;
 227                         } else {
 228                                 state = DP_S_MOD;
 229                         }
 230                         break;
 231                 case DP_S_MOD:
 232                         switch (ch) {
 233                         case 'h':
 234                                 cflags = DP_C_SHORT;
 235                                 ch = *format++;
 236                                 break;
 237                         case 'l':
 238                                 cflags = DP_C_LONG;
 239                                 ch = *format++;
 240                                 if (ch == 'l') {        /* It's a long long */
 241                                         cflags = DP_C_LLONG;
 242                                         ch = *format++;
 243                                 }
 244                                 break;
 245                         case 'L':
 246                                 cflags = DP_C_LDOUBLE;
 247                                 ch = *format++;
 248                                 break;
 249                         default:
 250                                 break;
 251                         }
 252                         state = DP_S_CONV;
 253                         break;
 254                 case DP_S_CONV:
 255                         switch (ch) {
 256                         case 'd':
 257                         case 'i':
 258                                 if (cflags == DP_C_SHORT)
 259                                         value = va_arg(args, int);
 260                                 else if (cflags == DP_C_LONG)
 261                                         value = va_arg(args, long int);
 262                                 else if (cflags == DP_C_LLONG)
 263                                         value = va_arg(args, LLONG);
 264                                 else
 265                                         value = va_arg(args, int);
 266                                 fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags);
 267                                 break;
 268                         case 'o':
 269                                 flags |= DP_F_UNSIGNED;
 270                                 if (cflags == DP_C_SHORT)
 271                                         value = va_arg(args, unsigned int);
 272                                 else if (cflags == DP_C_LONG)
 273                                         value = (long)va_arg(args, unsigned long int);
 274                                 else if (cflags == DP_C_LLONG)
 275                                         value = (long)va_arg(args, unsigned LLONG);
 276                                 else
 277                                         value = (long)va_arg(args, unsigned int);
 278                                 fmtint(buffer, &currlen, maxlen, value, 8, min, max, flags);
 279                                 break;
 280                         case 'u':
 281                                 flags |= DP_F_UNSIGNED;
 282                                 if (cflags == DP_C_SHORT)
 283                                         value = va_arg(args, unsigned int);
 284                                 else if (cflags == DP_C_LONG)
 285                                         value = (long)va_arg(args, unsigned long int);
 286                                 else if (cflags == DP_C_LLONG)
 287                                         value = (LLONG) va_arg(args, unsigned LLONG);
 288                                 else
 289                                         value = (long)va_arg(args, unsigned int);
 290                                 fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags);
 291                                 break;
 292                         case 'X':
 293                                 flags |= DP_F_UP;
 294                         case 'x':
 295                                 flags |= DP_F_UNSIGNED;
 296                                 if (cflags == DP_C_SHORT)
 297                                         value = va_arg(args, unsigned int);
 298                                 else if (cflags == DP_C_LONG)
 299                                         value = (long)va_arg(args, unsigned long int);
 300                                 else if (cflags == DP_C_LLONG)
 301                                         value = (LLONG) va_arg(args, unsigned LLONG);
 302                                 else
 303                                         value = (long)va_arg(args, unsigned int);
 304                                 fmtint(buffer, &currlen, maxlen, value, 16, min, max, flags);
 305                                 break;
 306                         case 'f':
 307                                 if (cflags == DP_C_LDOUBLE)
 308                                         fvalue = va_arg(args, LDOUBLE);
 309                                 else
 310                                         fvalue = va_arg(args, double);
 311                                 /* um, floating point? */
 312                                 fmtfp(buffer, &currlen, maxlen, fvalue, min, max, flags);
 313                                 break;
 314                         case 'E':
 315                                 flags |= DP_F_UP;
 316                         case 'e':
 317                                 if (cflags == DP_C_LDOUBLE)
 318                                         fvalue = va_arg(args, LDOUBLE);
 319                                 else
 320                                         fvalue = va_arg(args, double);
 321                                 break;
 322                         case 'G':
 323                                 flags |= DP_F_UP;
 324                         case 'g':
 325                                 if (cflags == DP_C_LDOUBLE)
 326                                         fvalue = va_arg(args, LDOUBLE);
 327                                 else
 328                                         fvalue = va_arg(args, double);
 329                                 break;
 330                         case 'c':
 331                                 dopr_outch(buffer, &currlen, maxlen, va_arg(args, int));
 332                                 break;
 333                         case 's':
 334                                 strvalue = va_arg(args, char *);
 335                                 if (max == -1) {
 336                                         max = strlen(strvalue);
 337                                 }
 338                                 if (min > 0 && max >= 0 && min > max)
 339                                         max = min;
 340                                 fmtstr(buffer, &currlen, maxlen, strvalue, flags, min, max);
 341                                 break;
 342                         case 'p':
 343                                 strvalue = va_arg(args, void *);
 344                                 fmtint(buffer, &currlen, maxlen, (long)strvalue, 16, min, max, flags);
 345                                 break;
 346                         case 'n':
 347                                 if (cflags == DP_C_SHORT) {
 348                                         short int *num;
 349                                         num = va_arg(args, short int *);
 350                                         *num = currlen;
 351                                 } else if (cflags == DP_C_LONG) {
 352                                         long int *num;
 353                                         num = va_arg(args, long int *);
 354                                         *num = (long int)currlen;
 355                                 } else if (cflags == DP_C_LLONG) {
 356                                         LLONG *num;
 357                                         num = va_arg(args, LLONG *);
 358                                         *num = (LLONG) currlen;
 359                                 } else {
 360                                         int *num;
 361                                         num = va_arg(args, int *);
 362                                         *num = currlen;
 363                                 }
 364                                 break;
 365                         case '%':
 366                                 dopr_outch(buffer, &currlen, maxlen, ch);
 367                                 break;
 368                         case 'w':
 369                                 /* not supported yet, treat as next char */
 370                                 ch = *format++;
 371                                 break;
 372                         default:
 373                                 /* Unknown, skip */
 374                                 break;
 375                         }
 376                         ch = *format++;
 377                         state = DP_S_DEFAULT;
 378                         flags = cflags = min = 0;
 379                         max = -1;
 380                         break;
 381                 case DP_S_DONE:
 382                         break;
 383                 default:
 384                         /* hmm? */
 385                         break;  /* some picky compilers need this */
 386                 }
 387         }
 388         if (maxlen != 0) {
 389                 if (currlen < maxlen - 1)
 390                         buffer[currlen] = '\0';
 391                 else if (maxlen > 0)
 392                         buffer[maxlen - 1] = '\0';
 393         }
 394
 395         return currlen;
 396 }
 397
 398 static void fmtstr(char *buffer, size_t * currlen, size_t maxlen, char *value, int flags, int min, int max)
 399 {
 400         int padlen, strln;      /* amount to pad */
 401         int cnt = 0;
 402
 403 #ifdef DEBUG_SNPRINTF
 404         printf("fmtstr min=%d max=%d s=[%s]\n", min, max, value);
 405 #endif
 406         if (value == 0) {
 407                 value = "<NULL>";
 408         }
 409
 410         for (strln = 0; value[strln]; ++strln) ;        /* strlen */
 411         padlen = min - strln;
 412         if (padlen < 0)
 413                 padlen = 0;
 414         if (flags & DP_F_MINUS)
 415                 padlen = -padlen;       /* Left Justify */
 416
 417         while ((padlen > 0) && (cnt < max)) {
 418                 dopr_outch(buffer, currlen, maxlen, ' ');
 419                 --padlen;
 420                 ++cnt;
 421         }
 422         while (*value && (cnt < max)) {
 423                 dopr_outch(buffer, currlen, maxlen, *value++);
 424                 ++cnt;
 425         }
 426         while ((padlen < 0) && (cnt < max)) {
 427                 dopr_outch(buffer, currlen, maxlen, ' ');
 428                 ++padlen;
 429                 ++cnt;
 430         }
 431 }
 432
 433 /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
 434
 435 static void fmtint(char *buffer, size_t * currlen, size_t maxlen,
 436                    long value, int base, int min, int max, int flags)
 437 {
 438         int signvalue = 0;
 439         unsigned long uvalue;
 440         char convert[20];
 441         int place = 0;
 442         int spadlen = 0;        /* amount to space pad */
 443         int zpadlen = 0;        /* amount to zero pad */
 444         int caps = 0;
 445
 446         if (max < 0)
 447                 max = 0;
 448
 449         uvalue = value;
 450
 451         if (!(flags & DP_F_UNSIGNED)) {
 452                 if (value < 0) {
 453                         signvalue = '-';
 454                         uvalue = -value;
 455                 } else {
 456                         if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
 457                                 signvalue = '+';
 458                         else if (flags & DP_F_SPACE)
 459                                 signvalue = ' ';
 460                 }
 461         }
 462
 463         if (flags & DP_F_UP)
 464                 caps = 1;       /* Should characters be upper case? */
 465
 466         do {
 467                 convert[place++] = (caps ? "0123456789ABCDEF" : "0123456789abcdef")
 468                     [uvalue % (unsigned)base];
 469                 uvalue = (uvalue / (unsigned)base);
 470         } while (uvalue && (place < 20));
 471         if (place == 20)
 472                 place--;
 473         convert[place] = 0;
 474
 475         zpadlen = max - place;
 476         spadlen = min - MAX(max, place) - (signvalue ? 1 : 0);
 477         if (zpadlen < 0)
 478                 zpadlen = 0;
 479         if (spadlen < 0)
 480                 spadlen = 0;
 481         if (flags & DP_F_ZERO) {
 482                 zpadlen = MAX(zpadlen, spadlen);
 483                 spadlen = 0;
 484         }
 485         if (flags & DP_F_MINUS)
 486                 spadlen = -spadlen;     /* Left Justifty */
 487
 488 #ifdef DEBUG_SNPRINTF
 489         printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n", zpadlen, spadlen, min, max, place);
 490 #endif
 491
 492         /* Spaces */
 493         while (spadlen > 0) {
 494                 dopr_outch(buffer, currlen, maxlen, ' ');
 495                 --spadlen;
 496         }
 497
 498         /* Sign */
 499         if (signvalue)
 500                 dopr_outch(buffer, currlen, maxlen, signvalue);
 501
 502         /* Zeros */
 503         if (zpadlen > 0) {
 504                 while (zpadlen > 0) {
 505                         dopr_outch(buffer, currlen, maxlen, '0');
 506                         --zpadlen;
 507                 }
 508         }
 509
 510         /* Digits */
 511         while (place > 0)
 512                 dopr_outch(buffer, currlen, maxlen, convert[--place]);
 513
 514         /* Left Justified spaces */
 515         while (spadlen < 0) {
 516                 dopr_outch(buffer, currlen, maxlen, ' ');
 517                 ++spadlen;
 518         }
 519 }
 520
 521 static LDOUBLE abs_val(LDOUBLE value)
 522 {
 523         LDOUBLE result = value;
 524
 525         if (value < 0)
 526                 result = -value;
 527
 528         return result;
 529 }
 530
 531 static LDOUBLE POW10(int exp)
 532 {
 533         LDOUBLE result = 1;
 534
 535         while (exp) {
 536                 result *= 10;
 537                 exp--;
 538         }
 539
 540         return result;
 541 }
 542
 543 static LLONG ROUND(LDOUBLE value)
 544 {
 545         LLONG intpart;
 546
 547         intpart = (LLONG) value;
 548         value = value - intpart;
 549         if (value >= 0.5)
 550                 intpart++;
 551
 552         return intpart;
 553 }
 554
 555 /* a replacement for modf that doesn't need the math library. Should
 556  be portable, but slow */
 557 static double my_modf(double x0, double *iptr)
 558 {
 559         int i;
 560         long l;
 561         double x = x0;
 562         double f = 1.0;
 563
 564         for (i = 0; i < 100; i++) {
 565                 l = (long)x;
 566                 if (l <= (x + 1) && l >= (x - 1))
 567                         break;
 568                 x *= 0.1;
 569                 f *= 10.0;
 570         }
 571
 572         if (i == 100) {
 573                 /* yikes! the number is beyond what we can handle. What do we do? */
 574                 (*iptr) = 0;
 575                 return 0;
 576         }
 577
 578         if (i != 0) {
 579                 double i2;
 580                 double ret;
 581
 582                 ret = my_modf(x0 - l * f, &i2);
 583                 (*iptr) = l * f + i2;
 584                 return ret;
 585         }
 586
 587         (*iptr) = l;
 588         return x - (*iptr);
 589 }
 590
 591 static void fmtfp(char *buffer, size_t * currlen, size_t maxlen, LDOUBLE fvalue, int min, int max, int flags)
 592 {
 593         int signvalue = 0;
 594         double ufvalue;
 595         char iconvert[311];
 596         char fconvert[311];
 597         int iplace = 0;
 598         int fplace = 0;
 599         int padlen = 0;         /* amount to pad */
 600         int zpadlen = 0;
 601         int caps = 0;
 602         int index;
 603         double intpart;
 604         double fracpart;
 605         double temp;
 606
 607         /*
 608          * AIX manpage says the default is 0, but Solaris says the default
 609          * is 6, and sprintf on AIX defaults to 6
 610          */
 611         if (max < 0)
 612                 max = 6;
 613
 614         ufvalue = abs_val(fvalue);
 615
 616         if (fvalue < 0) {
 617                 signvalue = '-';
 618         } else {
 619                 if (flags & DP_F_PLUS) {        /* Do a sign (+/i) */
 620                         signvalue = '+';
 621                 } else {
 622                         if (flags & DP_F_SPACE)
 623                                 signvalue = ' ';
 624                 }
 625         }
 626
 627 #if 0
 628         if (flags & DP_F_UP)
 629                 caps = 1;       /* Should characters be upper case? */
 630 #endif
 631
 632 #if 0
 633         if (max == 0)
 634                 ufvalue += 0.5; /* if max = 0 we must round */
 635 #endif
 636
 637         /*
 638          * Sorry, we only support 16 digits past the decimal because of our
 639          * conversion method
 640          */
 641         if (max > 16)
 642                 max = 16;
 643
 644         /* We "cheat" by converting the fractional part to integer by
 645          * multiplying by a factor of 10
 646          */
 647
 648         temp = ufvalue;
 649         my_modf(temp, &intpart);
 650
 651         fracpart = ROUND((POW10(max)) * (ufvalue - intpart));
 652
 653         if (fracpart >= POW10(max)) {
 654                 intpart++;
 655                 fracpart -= POW10(max);
 656         }
 657
 658         /* Convert integer part */
 659         do {
 660                 temp = intpart;
 661                 my_modf(intpart * 0.1, &intpart);
 662                 temp = temp * 0.1;
 663                 index = (int)((temp - intpart + 0.05) * 10.0);
 664                 /* index = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */
 665                 /* printf ("%llf, %f, %x\n", temp, intpart, index); */
 666                 iconvert[iplace++] = (caps ? "0123456789ABCDEF" : "0123456789abcdef")[index];
 667         } while (intpart && (iplace < 311));
 668         if (iplace == 311)
 669                 iplace--;
 670         iconvert[iplace] = 0;
 671
 672         /* Convert fractional part */
 673         if (fracpart) {
 674                 do {
 675                         temp = fracpart;
 676                         my_modf(fracpart * 0.1, &fracpart);
 677                         temp = temp * 0.1;
 678                         index = (int)((temp - fracpart + 0.05) * 10.0);
 679                         /* index = (int) ((((temp/10) -fracpart) +0.05) *10); */
 680                         /* printf ("%lf, %lf, %ld\n", temp, fracpart, index); */
 681                         fconvert[fplace++] = (caps ? "0123456789ABCDEF" : "0123456789abcdef")[index];
 682                 } while (fracpart && (fplace < 311));
 683                 if (fplace == 311)
 684                         fplace--;
 685         }
 686         fconvert[fplace] = 0;
 687
 688         /* -1 for decimal point, another -1 if we are printing a sign */
 689         padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
 690         zpadlen = max - fplace;
 691         if (zpadlen < 0)
 692                 zpadlen = 0;
 693         if (padlen < 0)
 694                 padlen = 0;
 695         if (flags & DP_F_MINUS)
 696                 padlen = -padlen;       /* Left Justifty */
 697
 698         if ((flags & DP_F_ZERO) && (padlen > 0)) {
 699                 if (signvalue) {
 700                         dopr_outch(buffer, currlen, maxlen, signvalue);
 701                         --padlen;
 702                         signvalue = 0;
 703                 }
 704                 while (padlen > 0) {
 705                         dopr_outch(buffer, currlen, maxlen, '0');
 706                         --padlen;
 707                 }
 708         }
 709         while (padlen > 0) {
 710                 dopr_outch(buffer, currlen, maxlen, ' ');
 711                 --padlen;
 712         }
 713         if (signvalue)
 714                 dopr_outch(buffer, currlen, maxlen, signvalue);
 715
 716         while (iplace > 0)
 717                 dopr_outch(buffer, currlen, maxlen, iconvert[--iplace]);
 718
 719 #ifdef DEBUG_SNPRINTF
 720         printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
 721 #endif
 722
 723         /*
 724          * Decimal point.  This should probably use locale to find the correct
 725          * char to print out.
 726          */
 727         if (max > 0) {
 728                 dopr_outch(buffer, currlen, maxlen, '.');
 729
 730                 while (fplace > 0)
 731                         dopr_outch(buffer, currlen, maxlen, fconvert[--fplace]);
 732         }
 733
 734         while (zpadlen > 0) {
 735                 dopr_outch(buffer, currlen, maxlen, '0');
 736                 --zpadlen;
 737         }
 738
 739         while (padlen < 0) {
 740                 dopr_outch(buffer, currlen, maxlen, ' ');
 741                 ++padlen;
 742         }
 743 }
 744
 745 static void dopr_outch(char *buffer, size_t * currlen, size_t maxlen, char c)
 746 {
 747         if (*currlen < maxlen) {
 748                 buffer[(*currlen)] = c;
 749         }
 750         (*currlen)++;
 751 }
 752
 753 #if !defined(HAVE_VSNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
 754 int vsnprintf(char *str, size_t count, const char *fmt, va_list args)
 755 {
 756         return dopr(str, count, fmt, args);
 757 }
 758 #endif
 759
 760 #if !defined(HAVE_SNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
 761 int snprintf(char *str, size_t count, const char *fmt, ...)
 762 {
 763         size_t ret;
 764         va_list ap;
 765
 766         va_start(ap, fmt);
 767         ret = vsnprintf(str, count, fmt, ap);
 768         va_end(ap);
 769         return ret;
 770 }
 771 #endif
 772
 773 #endif
 774
 775 #ifndef HAVE_VASPRINTF
 776 int vasprintf(char **ptr, const char *format, va_list ap)
 777 {
 778         int ret;
 779
 780         ret = vsnprintf(NULL, 0, format, ap);
 781         if (ret <= 0)
 782                 return ret;
 783
 784         (*ptr) = (char *)malloc(ret + 1);
 785         if (!*ptr)
 786                 return -1;
 787         ret = vsnprintf(*ptr, ret + 1, format, ap);
 788
 789         return ret;
 790 }
 791 #endif
 792
 793 #ifndef HAVE_ASPRINTF
 794 int asprintf(char **ptr, const char *format, ...)
 795 {
 796         va_list ap;
 797         int ret;
 798
 799         va_start(ap, format);
 800         ret = vasprintf(ptr, format, ap);
 801         va_end(ap);
 802
 803         return ret;
 804 }
 805 #endif
 806
 807 #ifdef TEST_SNPRINTF
 808
 809 int sprintf(char *str, const char *fmt, ...);
 810
 811 int main(void)
 812 {
 813         char buf1[1024];
 814         char buf2[1024];
 815         char *fp_fmt[] = {
 816                 "%1.1f",
 817                 "%-1.5f",
 818                 "%1.5f",
 819                 "%123.9f",
 820                 "%10.5f",
 821                 "% 10.5f",
 822                 "%+22.9f",
 823                 "%+4.9f",
 824                 "%01.3f",
 825                 "%4f",
 826                 "%3.1f",
 827                 "%3.2f",
 828                 "%.0f",
 829                 "%f",
 830                 "-16.16f",
 831                 NULL
 832         };
 833         double fp_nums[] = { 6442452944.1234, -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996,
 834                 0.9996, 1.996, 4.136, 0
 835         };
 836         char *int_fmt[] = {
 837                 "%-1.5d",
 838                 "%1.5d",
 839                 "%123.9d",
 840                 "%5.5d",
 841                 "%10.5d",
 842                 "% 10.5d",
 843                 "%+22.33d",
 844                 "%01.3d",
 845                 "%4d",
 846                 "%d",
 847                 NULL
 848         };
 849         long int_nums[] = { -1, 134, 91340, 341, 0203, 0 };
 850         char *str_fmt[] = {
 851                 "10.5s",
 852                 "5.10s",
 853                 "10.1s",
 854                 "0.10s",
 855                 "10.0s",
 856                 "1.10s",
 857                 "%s",
 858                 "%.1s",
 859                 "%.10s",
 860                 "%10s",
 861                 NULL
 862         };
 863         char *str_vals[] = { "hello", "a", "", "a longer string", NULL };
 864         int x, y;
 865         int fail = 0;
 866         int num = 0;
 867
 868         printf("Testing snprintf format codes against system sprintf...\n");
 869
 870         for (x = 0; fp_fmt[x]; x++) {
 871                 for (y = 0; fp_nums[y] != 0; y++) {
 872                         int l1 = snprintf(NULL, 0, fp_fmt[x], fp_nums[y]);
 873                         int l2 = snprintf(buf1, sizeof(buf1), fp_fmt[x], fp_nums[y]);
 874                         sprintf(buf2, fp_fmt[x], fp_nums[y]);
 875                         if (strcmp(buf1, buf2)) {
 876                                 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
 877                                        fp_fmt[x], buf1, buf2);
 878                                 fail++;
 879                         }
 880                         if (l1 != l2) {
 881                                 printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, fp_fmt[x]);
 882                                 fail++;
 883                         }
 884                         num++;
 885                 }
 886         }
 887
 888         for (x = 0; int_fmt[x]; x++) {
 889                 for (y = 0; int_nums[y] != 0; y++) {
 890                         int l1 = snprintf(NULL, 0, int_fmt[x], int_nums[y]);
 891                         int l2 = snprintf(buf1, sizeof(buf1), int_fmt[x], int_nums[y]);
 892                         sprintf(buf2, int_fmt[x], int_nums[y]);
 893                         if (strcmp(buf1, buf2)) {
 894                                 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
 895                                        int_fmt[x], buf1, buf2);
 896                                 fail++;
 897                         }
 898                         if (l1 != l2) {
 899                                 printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, int_fmt[x]);
 900                                 fail++;
 901                         }
 902                         num++;
 903                 }
 904         }
 905
 906         for (x = 0; str_fmt[x]; x++) {
 907                 for (y = 0; str_vals[y] != 0; y++) {
 908                         int l1 = snprintf(NULL, 0, str_fmt[x], str_vals[y]);
 909                         int l2 = snprintf(buf1, sizeof(buf1), str_fmt[x], str_vals[y]);
 910                         sprintf(buf2, str_fmt[x], str_vals[y]);
 911                         if (strcmp(buf1, buf2)) {
 912                                 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
 913                                        str_fmt[x], buf1, buf2);
 914                                 fail++;
 915                         }
 916                         if (l1 != l2) {
 917                                 printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, str_fmt[x]);
 918                                 fail++;
 919                         }
 920                         num++;
 921                 }
 922         }
 923
 924         printf("%d tests failed out of %d.\n", fail, num);
 925
 926         printf("seeing how many digits we support\n");
 927         {
 928                 double v0 = 0.12345678901234567890123456789012345678901;
 929                 for (x = 0; x < 100; x++) {
 930                         snprintf(buf1, sizeof(buf1), "%1.1f", v0 * pow(10, x));
 931                         sprintf(buf2, "%1.1f", v0 * pow(10, x));
 932                         if (strcmp(buf1, buf2)) {
 933                                 printf("we seem to support %d digits\n", x - 1);
 934                                 break;
 935                         }
 936                 }
 937         }
 938
 939         return 0;
 940 }
 941 #endif                          /* SNPRINTF_TEST */