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