src/portab/vsnprintf.c

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