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 #include <math.h>
  75 #ifdef HAVE_STDLIB_H
  76 #include <stdlib.h>
  77 #endif
  78
  79 #ifdef HAVE_LONG_DOUBLE
  80 #define LDOUBLE long double
  81 #else
  82 #define LDOUBLE double
  83 #endif
  84
  85 #ifdef HAVE_LONG_LONG
  86 #define LLONG long long
  87 #else
  88 #define LLONG long
  89 #endif
  90
  91 static size_t dopr(char *buffer, size_t maxlen, const char *format,
  92                    va_list args);
  93 static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
  94                     char *value, int flags, int min, int max);
  95 static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
  96                     long value, int base, int min, int max, int flags);
  97 static void fmtfp(char *buffer, size_t *currlen, size_t maxlen,
  98                    LDOUBLE fvalue, int min, int max, int flags);
  99 static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c);
 100
 101 /*
 102  * dopr(): poor man's version of doprintf
 103  */
 104
 105 /* format read states */
 106 #define DP_S_DEFAULT 0
 107 #define DP_S_FLAGS   1
 108 #define DP_S_MIN     2
 109 #define DP_S_DOT     3
 110 #define DP_S_MAX     4
 111 #define DP_S_MOD     5
 112 #define DP_S_CONV    6
 113 #define DP_S_DONE    7
 114
 115 /* format flags - Bits */
 116 #define DP_F_MINUS      (1 << 0)
 117 #define DP_F_PLUS       (1 << 1)
 118 #define DP_F_SPACE      (1 << 2)
 119 #define DP_F_NUM        (1 << 3)
 120 #define DP_F_ZERO       (1 << 4)
 121 #define DP_F_UP         (1 << 5)
 122 #define DP_F_UNSIGNED   (1 << 6)
 123
 124 /* Conversion Flags */
 125 #define DP_C_SHORT   1
 126 #define DP_C_LONG    2
 127 #define DP_C_LDOUBLE 3
 128 #define DP_C_LLONG   4
 129
 130 #define char_to_int(p) ((p)- '0')
 131 #ifndef MAX
 132 #define MAX(p,q) (((p) >= (q)) ? (p) : (q))
 133 #endif
 134
 135 static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args)
 136 {
 137         char ch;
 138         LLONG value;
 139         LDOUBLE fvalue;
 140         char *strvalue;
 141         int min;
 142         int max;
 143         int state;
 144         int flags;
 145         int cflags;
 146         size_t currlen;
 147
 148         state = DP_S_DEFAULT;
 149         currlen = flags = cflags = min = 0;
 150         max = -1;
 151         ch = *format++;
 152
 153         while (state != DP_S_DONE) {
 154                 if (ch == '\0')
 155                         state = DP_S_DONE;
 156
 157                 switch(state) {
 158                 case DP_S_DEFAULT:
 159                         if (ch == '%')
 160                                 state = DP_S_FLAGS;
 161                         else
 162                                 dopr_outch (buffer, &currlen, maxlen, ch);
 163                         ch = *format++;
 164                         break;
 165                 case DP_S_FLAGS:
 166                         switch (ch) {
 167                         case '-':
 168                                 flags |= DP_F_MINUS;
 169                                 ch = *format++;
 170                                 break;
 171                         case '+':
 172                                 flags |= DP_F_PLUS;
 173                                 ch = *format++;
 174                                 break;
 175                         case ' ':
 176                                 flags |= DP_F_SPACE;
 177                                 ch = *format++;
 178                                 break;
 179                         case '#':
 180                                 flags |= DP_F_NUM;
 181                                 ch = *format++;
 182                                 break;
 183                         case '0':
 184                                 flags |= DP_F_ZERO;
 185                                 ch = *format++;
 186                                 break;
 187                         default:
 188                                 state = DP_S_MIN;
 189                                 break;
 190                         }
 191                         break;
 192                 case DP_S_MIN:
 193                         if (isdigit((unsigned char)ch)) {
 194                                 min = 10*min + char_to_int (ch);
 195                                 ch = *format++;
 196                         } else if (ch == '*') {
 197                                 min = va_arg (args, int);
 198                                 ch = *format++;
 199                                 state = DP_S_DOT;
 200                         } else {
 201                                 state = DP_S_DOT;
 202                         }
 203                         break;
 204                 case DP_S_DOT:
 205                         if (ch == '.') {
 206                                 state = DP_S_MAX;
 207                                 ch = *format++;
 208                         } else {
 209                                 state = DP_S_MOD;
 210                         }
 211                         break;
 212                 case DP_S_MAX:
 213                         if (isdigit((unsigned char)ch)) {
 214                                 if (max < 0)
 215                                         max = 0;
 216                                 max = 10*max + char_to_int (ch);
 217                                 ch = *format++;
 218                         } else if (ch == '*') {
 219                                 max = va_arg (args, int);
 220                                 ch = *format++;
 221                                 state = DP_S_MOD;
 222                         } else {
 223                                 state = DP_S_MOD;
 224                         }
 225                         break;
 226                 case DP_S_MOD:
 227                         switch (ch) {
 228                         case 'h':
 229                                 cflags = DP_C_SHORT;
 230                                 ch = *format++;
 231                                 break;
 232                         case 'l':
 233                                 cflags = DP_C_LONG;
 234                                 ch = *format++;
 235                                 if (ch == 'l') {        /* It's a long long */
 236                                         cflags = DP_C_LLONG;
 237                                         ch = *format++;
 238                                 }
 239                                 break;
 240                         case 'L':
 241                                 cflags = DP_C_LDOUBLE;
 242                                 ch = *format++;
 243                                 break;
 244                         default:
 245                                 break;
 246                         }
 247                         state = DP_S_CONV;
 248                         break;
 249                 case DP_S_CONV:
 250                         switch (ch) {
 251                         case 'd':
 252                         case 'i':
 253                                 if (cflags == DP_C_SHORT)
 254                                         value = va_arg (args, int);
 255                                 else if (cflags == DP_C_LONG)
 256                                         value = va_arg (args, long int);
 257                                 else if (cflags == DP_C_LLONG)
 258                                         value = va_arg (args, LLONG);
 259                                 else
 260                                         value = va_arg (args, int);
 261                                 fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
 262                                 break;
 263                         case 'o':
 264                                 flags |= DP_F_UNSIGNED;
 265                                 if (cflags == DP_C_SHORT)
 266                                         value = va_arg (args, unsigned int);
 267                                 else if (cflags == DP_C_LONG)
 268                                         value = (long)va_arg (args, unsigned long int);
 269                                 else if (cflags == DP_C_LLONG)
 270                                         value = (long)va_arg (args, unsigned LLONG);
 271                                 else
 272                                         value = (long)va_arg (args, unsigned int);
 273                                 fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
 274                                 break;
 275                         case 'u':
 276                                 flags |= DP_F_UNSIGNED;
 277                                 if (cflags == DP_C_SHORT)
 278                                         value = va_arg (args, unsigned int);
 279                                 else if (cflags == DP_C_LONG)
 280                                         value = (long)va_arg (args, unsigned long int);
 281                                 else if (cflags == DP_C_LLONG)
 282                                         value = (LLONG)va_arg (args, unsigned LLONG);
 283                                 else
 284                                         value = (long)va_arg (args, unsigned int);
 285                                 fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
 286                                 break;
 287                         case 'X':
 288                                 flags |= DP_F_UP;
 289                         case 'x':
 290                                 flags |= DP_F_UNSIGNED;
 291                                 if (cflags == DP_C_SHORT)
 292                                         value = va_arg (args, unsigned int);
 293                                 else if (cflags == DP_C_LONG)
 294                                         value = (long)va_arg (args, unsigned long int);
 295                                 else if (cflags == DP_C_LLONG)
 296                                         value = (LLONG)va_arg (args, unsigned LLONG);
 297                                 else
 298                                         value = (long)va_arg (args, unsigned int);
 299                                 fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
 300                                 break;
 301                         case 'f':
 302                                 if (cflags == DP_C_LDOUBLE)
 303                                         fvalue = va_arg (args, LDOUBLE);
 304                                 else
 305                                         fvalue = va_arg (args, double);
 306                                 /* um, floating point? */
 307                                 fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
 308                                 break;
 309                         case 'E':
 310                                 flags |= DP_F_UP;
 311                         case 'e':
 312                                 if (cflags == DP_C_LDOUBLE)
 313                                         fvalue = va_arg (args, LDOUBLE);
 314                                 else
 315                                         fvalue = va_arg (args, double);
 316                                 break;
 317                         case 'G':
 318                                 flags |= DP_F_UP;
 319                         case 'g':
 320                                 if (cflags == DP_C_LDOUBLE)
 321                                         fvalue = va_arg (args, LDOUBLE);
 322                                 else
 323                                         fvalue = va_arg (args, double);
 324                                 break;
 325                         case 'c':
 326                                 dopr_outch (buffer, &currlen, maxlen, va_arg (args, int));
 327                                 break;
 328                         case 's':
 329                                 strvalue = va_arg (args, char *);
 330                                 if (max == -1) {
 331                                         max = strlen(strvalue);
 332                                 }
 333                                 if (min > 0 && max >= 0 && min > max) max = min;
 334                                 fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
 335                                 break;
 336                         case 'p':
 337                                 strvalue = va_arg (args, void *);
 338                                 fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
 339                                 break;
 340                         case 'n':
 341                                 if (cflags == DP_C_SHORT) {
 342                                         short int *num;
 343                                         num = va_arg (args, short int *);
 344                                         *num = currlen;
 345                                 } else if (cflags == DP_C_LONG) {
 346                                         long int *num;
 347                                         num = va_arg (args, long int *);
 348                                         *num = (long int)currlen;
 349                                 } else if (cflags == DP_C_LLONG) {
 350                                         LLONG *num;
 351                                         num = va_arg (args, LLONG *);
 352                                         *num = (LLONG)currlen;
 353                                 } else {
 354                                         int *num;
 355                                         num = va_arg (args, int *);
 356                                         *num = currlen;
 357                                 }
 358                                 break;
 359                         case '%':
 360                                 dopr_outch (buffer, &currlen, maxlen, ch);
 361                                 break;
 362                         case 'w':
 363                                 /* not supported yet, treat as next char */
 364                                 ch = *format++;
 365                                 break;
 366                         default:
 367                                 /* Unknown, skip */
 368                                 break;
 369                         }
 370                         ch = *format++;
 371                         state = DP_S_DEFAULT;
 372                         flags = cflags = min = 0;
 373                         max = -1;
 374                         break;
 375                 case DP_S_DONE:
 376                         break;
 377                 default:
 378                         /* hmm? */
 379                         break; /* some picky compilers need this */
 380                 }
 381         }
 382         if (maxlen != 0) {
 383                 if (currlen < maxlen - 1)
 384                         buffer[currlen] = '\0';
 385                 else if (maxlen > 0)
 386                         buffer[maxlen - 1] = '\0';
 387         }
 388
 389         return currlen;
 390 }
 391
 392 static void fmtstr (char *buffer, size_t *currlen, size_t maxlen,
 393                     char *value, int flags, int min, int max)
 394 {
 395         int padlen, strln;     /* amount to pad */
 396         int cnt = 0;
 397
 398 #ifdef DEBUG_SNPRINTF
 399         printf("fmtstr min=%d max=%d s=[%s]\n", min, max, value);
 400 #endif
 401         if (value == 0) {
 402                 value = "<NULL>";
 403         }
 404
 405         for (strln = 0; value[strln]; ++strln); /* strlen */
 406         padlen = min - strln;
 407         if (padlen < 0)
 408                 padlen = 0;
 409         if (flags & DP_F_MINUS)
 410                 padlen = -padlen; /* Left Justify */
 411
 412         while ((padlen > 0) && (cnt < max)) {
 413                 dopr_outch (buffer, currlen, maxlen, ' ');
 414                 --padlen;
 415                 ++cnt;
 416         }
 417         while (*value && (cnt < max)) {
 418                 dopr_outch (buffer, currlen, maxlen, *value++);
 419                 ++cnt;
 420         }
 421         while ((padlen < 0) && (cnt < max)) {
 422                 dopr_outch (buffer, currlen, maxlen, ' ');
 423                 ++padlen;
 424                 ++cnt;
 425         }
 426 }
 427
 428 /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
 429
 430 static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
 431                     long value, int base, int min, int max, int flags)
 432 {
 433         int signvalue = 0;
 434         unsigned long uvalue;
 435         char convert[20];
 436         int place = 0;
 437         int spadlen = 0; /* amount to space pad */
 438         int zpadlen = 0; /* amount to zero pad */
 439         int caps = 0;
 440
 441         if (max < 0)
 442                 max = 0;
 443
 444         uvalue = value;
 445
 446         if(!(flags & DP_F_UNSIGNED)) {
 447                 if( value < 0 ) {
 448                         signvalue = '-';
 449                         uvalue = -value;
 450                 } else {
 451                         if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
 452                                 signvalue = '+';
 453                         else if (flags & DP_F_SPACE)
 454                                 signvalue = ' ';
 455                 }
 456         }
 457
 458         if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
 459
 460         do {
 461                 convert[place++] =
 462                         (caps? "0123456789ABCDEF":"0123456789abcdef")
 463                         [uvalue % (unsigned)base  ];
 464                 uvalue = (uvalue / (unsigned)base );
 465         } while(uvalue && (place < 20));
 466         if (place == 20) place--;
 467         convert[place] = 0;
 468
 469         zpadlen = max - place;
 470         spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
 471         if (zpadlen < 0) zpadlen = 0;
 472         if (spadlen < 0) spadlen = 0;
 473         if (flags & DP_F_ZERO) {
 474                 zpadlen = MAX(zpadlen, spadlen);
 475                 spadlen = 0;
 476         }
 477         if (flags & DP_F_MINUS)
 478                 spadlen = -spadlen; /* Left Justifty */
 479
 480 #ifdef DEBUG_SNPRINTF
 481         printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
 482                zpadlen, spadlen, min, max, place);
 483 #endif
 484
 485         /* Spaces */
 486         while (spadlen > 0) {
 487                 dopr_outch (buffer, currlen, maxlen, ' ');
 488                 --spadlen;
 489         }
 490
 491         /* Sign */
 492         if (signvalue)
 493                 dopr_outch (buffer, currlen, maxlen, signvalue);
 494
 495         /* Zeros */
 496         if (zpadlen > 0) {
 497                 while (zpadlen > 0) {
 498                         dopr_outch (buffer, currlen, maxlen, '0');
 499                         --zpadlen;
 500                 }
 501         }
 502
 503         /* Digits */
 504         while (place > 0)
 505                 dopr_outch (buffer, currlen, maxlen, convert[--place]);
 506
 507         /* Left Justified spaces */
 508         while (spadlen < 0) {
 509                 dopr_outch (buffer, currlen, maxlen, ' ');
 510                 ++spadlen;
 511         }
 512 }
 513
 514 static LDOUBLE abs_val (LDOUBLE value)
 515 {
 516         LDOUBLE result = value;
 517
 518         if (value < 0)
 519                 result = -value;
 520
 521         return result;
 522 }
 523
 524 static LDOUBLE pow10 (int exp)
 525 {
 526         LDOUBLE result = 1;
 527
 528         while (exp) {
 529                 result *= 10;
 530                 exp--;
 531         }
 532
 533         return result;
 534 }
 535
 536 static LLONG round (LDOUBLE value)
 537 {
 538         LLONG intpart;
 539
 540         intpart = (LLONG)value;
 541         value = value - intpart;
 542         if (value >= 0.5) intpart++;
 543
 544         return intpart;
 545 }
 546
 547 static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
 548                    LDOUBLE fvalue, int min, int max, int flags)
 549 {
 550         int signvalue = 0;
 551         double ufvalue;
 552         char iconvert[311];
 553         char fconvert[311];
 554         int iplace = 0;
 555         int fplace = 0;
 556         int padlen = 0; /* amount to pad */
 557         int zpadlen = 0;
 558         int caps = 0;
 559         int index;
 560         double intpart;
 561         double fracpart;
 562         double temp;
 563
 564         /*
 565          * AIX manpage says the default is 0, but Solaris says the default
 566          * is 6, and sprintf on AIX defaults to 6
 567          */
 568         if (max < 0)
 569                 max = 6;
 570
 571         ufvalue = abs_val (fvalue);
 572
 573         if (fvalue < 0) {
 574                 signvalue = '-';
 575         } else {
 576                 if (flags & DP_F_PLUS) { /* Do a sign (+/i) */
 577                         signvalue = '+';
 578                 } else {
 579                         if (flags & DP_F_SPACE)
 580                                 signvalue = ' ';
 581                 }
 582         }
 583
 584 #if 0
 585         if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
 586 #endif
 587
 588 #if 0
 589          if (max == 0) ufvalue += 0.5; /* if max = 0 we must round */
 590 #endif
 591
 592         /*
 593          * Sorry, we only support 16 digits past the decimal because of our
 594          * conversion method
 595          */
 596         if (max > 16)
 597                 max = 16;
 598
 599         /* We "cheat" by converting the fractional part to integer by
 600          * multiplying by a factor of 10
 601          */
 602
 603         temp = ufvalue;
 604         modf(temp, &intpart);
 605
 606         fracpart = round ((pow10(max)) * (ufvalue - intpart));
 607
 608         if (fracpart >= pow10(max)) {
 609                 intpart++;
 610                 fracpart -= pow10(max);
 611         }
 612
 613
 614         /* Convert integer part */
 615         do {
 616                 temp = intpart;
 617                 modf (intpart*0.1, &intpart);
 618                 temp = temp*0.1;
 619                 index = (int) ((temp -intpart +0.05)* 10.0);
 620                 /* index = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */
 621                 /* printf ("%llf, %f, %x\n", temp, intpart, index); */
 622                 iconvert[iplace++] =
 623                         (caps? "0123456789ABCDEF":"0123456789abcdef")[index];
 624         } while (intpart && (iplace < 311));
 625         if (iplace == 311) iplace--;
 626         iconvert[iplace] = 0;
 627
 628         /* Convert fractional part */
 629         if (fracpart)
 630         {
 631                 do {
 632                         temp = fracpart;
 633                         modf (fracpart*0.1, &fracpart);
 634                         temp = temp*0.1;
 635                         index = (int) ((temp -fracpart +0.05)* 10.0);
 636                         /* index = (int) ((((temp/10) -fracpart) +0.05) *10); */
 637                         /* printf ("%lf, %lf, %ld\n", temp, fracpart, index); */
 638                         fconvert[fplace++] =
 639                         (caps? "0123456789ABCDEF":"0123456789abcdef")[index];
 640                 } while(fracpart && (fplace < 311));
 641                 if (fplace == 311) fplace--;
 642         }
 643         fconvert[fplace] = 0;
 644
 645         /* -1 for decimal point, another -1 if we are printing a sign */
 646         padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
 647         zpadlen = max - fplace;
 648         if (zpadlen < 0) zpadlen = 0;
 649         if (padlen < 0)
 650                 padlen = 0;
 651         if (flags & DP_F_MINUS)
 652                 padlen = -padlen; /* Left Justifty */
 653
 654         if ((flags & DP_F_ZERO) && (padlen > 0)) {
 655                 if (signvalue) {
 656                         dopr_outch (buffer, currlen, maxlen, signvalue);
 657                         --padlen;
 658                         signvalue = 0;
 659                 }
 660                 while (padlen > 0) {
 661                         dopr_outch (buffer, currlen, maxlen, '0');
 662                         --padlen;
 663                 }
 664         }
 665         while (padlen > 0) {
 666                 dopr_outch (buffer, currlen, maxlen, ' ');
 667                 --padlen;
 668         }
 669         if (signvalue)
 670                 dopr_outch (buffer, currlen, maxlen, signvalue);
 671
 672         while (iplace > 0)
 673                 dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]);
 674
 675 #ifdef DEBUG_SNPRINTF
 676         printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
 677 #endif
 678
 679         /*
 680          * Decimal point.  This should probably use locale to find the correct
 681          * char to print out.
 682          */
 683         if (max > 0) {
 684                 dopr_outch (buffer, currlen, maxlen, '.');
 685
 686                 while (fplace > 0)
 687                         dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]);
 688         }
 689
 690         while (zpadlen > 0) {
 691                 dopr_outch (buffer, currlen, maxlen, '0');
 692                 --zpadlen;
 693         }
 694
 695         while (padlen < 0) {
 696                 dopr_outch (buffer, currlen, maxlen, ' ');
 697                 ++padlen;
 698         }
 699 }
 700
 701 static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c)
 702 {
 703         if (*currlen < maxlen) {
 704                 buffer[(*currlen)] = c;
 705         }
 706         (*currlen)++;
 707 }
 708
 709 #ifndef HAVE_VSNPRINTF
 710  int vsnprintf (char *str, size_t count, const char *fmt, va_list args)
 711 {
 712         return dopr(str, count, fmt, args);
 713 }
 714 #endif
 715
 716 #ifndef HAVE_SNPRINTF
 717  int snprintf (char *str,size_t count,const char *fmt,...)
 718 {
 719         size_t ret;
 720         va_list ap;
 721
 722         va_start(ap, fmt);
 723         ret = vsnprintf(str, count, fmt, ap);
 724         va_end(ap);
 725         return ret;
 726 }
 727 #endif
 728
 729  int vasprintf(char **buf, const char *fmt, va_list args)
 730 {
 731         int ret;
 732
 733         ret = vsnprintf(NULL, 0, format, ap);
 734         if (ret == -1) return NULL;
 735
 736         str = (char *)malloc(ret+1);
 737         if (!str) return NULL;
 738         ret = vsnprintf(str, ret+1, format, ap);
 739         va_end(ap);
 740 }
 741
 742
 743 #ifndef HAVE_ASPRINTF
 744  char *asprintf(const char *format, ...)
 745 {
 746         va_list ap;
 747         int ret;
 748         char *str;
 749
 750         va_start(ap, format);
 751         ret = vsnprintf(NULL, 0, format, ap);
 752         va_end(ap);
 753
 754         if (ret == -1) return NULL;
 755
 756         va_start(ap, format);
 757         str = (char *)malloc(ret+1);
 758         if (!str) return NULL;
 759         ret = vsnprintf(str, ret+1, format, ap);
 760         va_end(ap);
 761
 762         return str;
 763 }
 764 #endif
 765
 766 #ifdef TEST_SNPRINTF
 767 #define LONG_STRING 1024
 768
 769  int sprintf(char *str,const char *fmt,...);
 770
 771  int main (void)
 772 {
 773         char buf1[LONG_STRING];
 774         char buf2[LONG_STRING];
 775         char *fp_fmt[] = {
 776                 "%1.1f",
 777                 "%-1.5f",
 778                 "%1.5f",
 779                 "%123.9f",
 780                 "%10.5f",
 781                 "% 10.5f",
 782                 "%+22.9f",
 783                 "%+4.9f",
 784                 "%01.3f",
 785                 "%4f",
 786                 "%3.1f",
 787                 "%3.2f",
 788                 "%.0f",
 789                 "%f",
 790                 "-16.16f",
 791                 NULL
 792         };
 793         double fp_nums[] = { 6442452944.1234, -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996,
 794                              0.9996, 1.996, 4.136,  0};
 795         char *int_fmt[] = {
 796                 "%-1.5d",
 797                 "%1.5d",
 798                 "%123.9d",
 799                 "%5.5d",
 800                 "%10.5d",
 801                 "% 10.5d",
 802                 "%+22.33d",
 803                 "%01.3d",
 804                 "%4d",
 805                 "%d",
 806                 NULL
 807         };
 808         long int_nums[] = { -1, 134, 91340, 341, 0203, 0};
 809         char *str_fmt[] = {
 810                 "10.5s",
 811                 "5.10s",
 812                 "10.1s",
 813                 "0.10s",
 814                 "10.0s",
 815                 "1.10s",
 816                 "%s",
 817                 "%.1s",
 818                 "%.10s",
 819                 "%10s",
 820                 NULL
 821         };
 822         char *str_vals[] = {"hello", "a", "", "a longer string", NULL};
 823         int x, y;
 824         int fail = 0;
 825         int num = 0;
 826
 827         printf ("Testing snprintf format codes against system sprintf...\n");
 828
 829         for (x = 0; fp_fmt[x] ; x++) {
 830                 for (y = 0; fp_nums[y] != 0 ; y++) {
 831                         int l1 = snprintf(NULL, 0, fp_fmt[x], fp_nums[y]);
 832                         int l2 = snprintf(buf1, sizeof(buf1), fp_fmt[x], fp_nums[y]);
 833                         sprintf (buf2, fp_fmt[x], fp_nums[y]);
 834                         if (strcmp (buf1, buf2)) {
 835                                 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
 836                                        fp_fmt[x], buf1, buf2);
 837                                 fail++;
 838                         }
 839                         if (l1 != l2) {
 840                                 printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, fp_fmt[x]);
 841                                 fail++;
 842                         }
 843                         num++;
 844                 }
 845         }
 846
 847         for (x = 0; int_fmt[x] ; x++) {
 848                 for (y = 0; int_nums[y] != 0 ; y++) {
 849                         int l1 = snprintf(NULL, 0, int_fmt[x], int_nums[y]);
 850                         int l2 = snprintf(buf1, sizeof(buf1), int_fmt[x], int_nums[y]);
 851                         sprintf (buf2, int_fmt[x], int_nums[y]);
 852                         if (strcmp (buf1, buf2)) {
 853                                 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
 854                                        int_fmt[x], buf1, buf2);
 855                                 fail++;
 856                         }
 857                         if (l1 != l2) {
 858                                 printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, int_fmt[x]);
 859                                 fail++;
 860                         }
 861                         num++;
 862                 }
 863         }
 864
 865         for (x = 0; str_fmt[x] ; x++) {
 866                 for (y = 0; str_vals[y] != 0 ; y++) {
 867                         int l1 = snprintf(NULL, 0, str_fmt[x], str_vals[y]);
 868                         int l2 = snprintf(buf1, sizeof(buf1), str_fmt[x], str_vals[y]);
 869                         sprintf (buf2, str_fmt[x], str_vals[y]);
 870                         if (strcmp (buf1, buf2)) {
 871                                 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
 872                                        str_fmt[x], buf1, buf2);
 873                                 fail++;
 874                         }
 875                         if (l1 != l2) {
 876                                 printf("snprintf l1 != l2 (%d %d) %s\n", l1, l2, str_fmt[x]);
 877                                 fail++;
 878                         }
 879                         num++;
 880                 }
 881         }
 882
 883         printf ("%d tests failed out of %d.\n", fail, num);
 884
 885         printf("seeing how many digits we support\n");
 886         {
 887                 double v0 = 0.12345678901234567890123456789012345678901;
 888                 for (x=0; x<100; x++) {
 889                         snprintf(buf1, sizeof(buf1), "%1.1f", v0*pow(10, x));
 890                         sprintf(buf2,                "%1.1f", v0*pow(10, x));
 891                         if (strcmp(buf1, buf2)) {
 892                                 printf("we seem to support %d digits\n", x-1);
 893                                 break;
 894                         }
 895                 }
 896         }
 897
 898         return 0;
 899 }
 900 #endif /* SNPRINTF_TEST */