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