chiark / gitweb /
Fix up more warnings. Actually read from connections
[inn-innduct.git] / lib / snprintf.c
1 /*  $Id: snprintf.c 7230 2005-04-16 23:33:17Z rra $
2 **
3 **  Replacement for a missing snprintf or vsnprintf.
4 **
5 **  The following implementation of snprintf was taken mostly verbatim from
6 **  <http://www.fiction.net/~blong/programs/>; it is the version of snprintf
7 **  used in Mutt.
8 **
9 **  Please do not reformat or otherwise change this file more than
10 **  necessary so that later merges with the original source are easy.
11 **  Bug fixes and improvements should be sent back to the original author.
12 */
13
14 /* If we're running the test suite, rename snprintf and vsnprintf to avoid
15    conflicts with the system version. */
16 #if TESTING
17 # define snprintf test_snprintf
18 # define vsnprintf test_vsnprintf
19 #endif
20
21 /*
22  * Copyright Patrick Powell 1995
23  * This code is based on code written by Patrick Powell (papowell@astart.com)
24  * It may be used for any purpose as long as this notice remains intact
25  * on all source code distributions
26  */
27
28 /**************************************************************
29  * Original:
30  * 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) Oct 1998
69  *    fixed handling of %.0f
70  *    added test for HAVE_LONG_DOUBLE
71  *
72  *  Russ Allbery <rra@stanford.edu> 2000-08-26
73  *    fixed return value to comply with C99
74  *    fixed handling of snprintf(NULL, ...)
75  *
76  *  Hrvoje Niksic <hniksic@arsdigita.com> 2000-11-04
77  *    include <stdio.h> for NULL.
78  *    added support for long long.
79  *    don't declare argument types to (v)snprintf if stdarg is not used.
80  *
81  **************************************************************/
82
83 #include "config.h"
84 #include <string.h>
85 #include <ctype.h>
86 #include <sys/types.h>
87
88 #ifndef NULL
89 # define NULL 0
90 #endif
91
92 /* varargs declarations: */
93
94 #include <stdarg.h>
95 #define HAVE_STDARGS    /* let's hope that works everywhere (mj) */
96 #define VA_LOCAL_DECL   va_list ap
97 #define VA_START(f)     va_start(ap, f)
98 #define VA_SHIFT(v,t)  ;   /* no-op for ANSI */
99 #define VA_END          va_end(ap)
100
101 #ifdef HAVE_LONG_DOUBLE
102 #define LDOUBLE long double
103 #else
104 #define LDOUBLE double
105 #endif
106
107 #ifdef HAVE_LONG_LONG
108 # define LLONG long long
109 #else
110 # define LLONG long
111 #endif
112
113 int snprintf (char *str, size_t count, const char *fmt, ...);
114 int vsnprintf (char *str, size_t count, const char *fmt, va_list arg);
115
116 static int dopr (char *buffer, size_t maxlen, const char *format, 
117                  va_list args);
118 static int fmtstr (char *buffer, size_t *currlen, size_t maxlen,
119                    const char *value, int flags, int min, int max);
120 static int fmtint (char *buffer, size_t *currlen, size_t maxlen,
121                    LLONG value, int base, int min, int max, int flags);
122 static int fmtfp (char *buffer, size_t *currlen, size_t maxlen,
123                   LDOUBLE fvalue, int min, int max, int flags);
124 static int 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_MOD_L   6
138 #define DP_S_CONV    7
139 #define DP_S_DONE    8
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_LLONG   3
154 #define DP_C_LDOUBLE 4
155
156 #define char_to_int(p) (p - '0')
157 #define MAX(p,q) ((p >= q) ? p : q)
158 #define MIN(p,q) ((p <= q) ? p : q)
159
160 static int 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   int total;
172   size_t currlen;
173   
174   state = DP_S_DEFAULT;
175   currlen = flags = cflags = min = 0;
176   max = -1;
177   ch = *format++;
178   total = 0;
179
180   while (state != DP_S_DONE)
181   {
182     if (ch == '\0')
183       state = DP_S_DONE;
184
185     switch(state) 
186     {
187     case DP_S_DEFAULT:
188       if (ch == '%') 
189         state = DP_S_FLAGS;
190       else 
191         total += dopr_outch (buffer, &currlen, maxlen, ch);
192       ch = *format++;
193       break;
194     case DP_S_FLAGS:
195       switch (ch) 
196       {
197       case '-':
198         flags |= DP_F_MINUS;
199         ch = *format++;
200         break;
201       case '+':
202         flags |= DP_F_PLUS;
203         ch = *format++;
204         break;
205       case ' ':
206         flags |= DP_F_SPACE;
207         ch = *format++;
208         break;
209       case '#':
210         flags |= DP_F_NUM;
211         ch = *format++;
212         break;
213       case '0':
214         flags |= DP_F_ZERO;
215         ch = *format++;
216         break;
217       default:
218         state = DP_S_MIN;
219         break;
220       }
221       break;
222     case DP_S_MIN:
223       if ('0' <= ch && ch <= '9') 
224       {
225         min = 10*min + char_to_int (ch);
226         ch = *format++;
227       } 
228       else if (ch == '*') 
229       {
230         min = va_arg (args, int);
231         ch = *format++;
232         state = DP_S_DOT;
233       } 
234       else 
235         state = DP_S_DOT;
236       break;
237     case DP_S_DOT:
238       if (ch == '.') 
239       {
240         state = DP_S_MAX;
241         ch = *format++;
242       } 
243       else 
244         state = DP_S_MOD;
245       break;
246     case DP_S_MAX:
247       if ('0' <= ch && ch <= '9')
248       {
249         if (max < 0)
250           max = 0;
251         max = 10*max + char_to_int (ch);
252         ch = *format++;
253       } 
254       else if (ch == '*') 
255       {
256         max = va_arg (args, int);
257         ch = *format++;
258         state = DP_S_MOD;
259       } 
260       else 
261         state = DP_S_MOD;
262       break;
263     case DP_S_MOD:
264       switch (ch) 
265       {
266       case 'h':
267         cflags = DP_C_SHORT;
268         ch = *format++;
269         break;
270       case 'l':
271         cflags = DP_C_LONG;
272         ch = *format++;
273         break;
274       case 'L':
275         cflags = DP_C_LDOUBLE;
276         ch = *format++;
277         break;
278       default:
279         break;
280       }
281       if (cflags != DP_C_LONG)
282         state = DP_S_CONV;
283       else
284         state = DP_S_MOD_L;
285       break;
286     case DP_S_MOD_L:
287       switch (ch)
288       {
289       case 'l':
290         cflags = DP_C_LLONG;
291         ch = *format++;
292         break;
293       default:
294         break;
295       }
296       state = DP_S_CONV;
297       break;
298     case DP_S_CONV:
299       switch (ch) 
300       {
301       case 'd':
302       case 'i':
303         if (cflags == DP_C_SHORT) 
304           value = (short int) va_arg (args, int);
305         else if (cflags == DP_C_LONG)
306           value = va_arg (args, long int);
307         else if (cflags == DP_C_LLONG)
308           value = va_arg (args, LLONG);
309         else
310           value = va_arg (args, int);
311         total += fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
312         break;
313       case 'o':
314         flags |= DP_F_UNSIGNED;
315         if (cflags == DP_C_SHORT)
316           value = (unsigned short int) va_arg (args, unsigned int);
317         else if (cflags == DP_C_LONG)
318           value = va_arg (args, unsigned long int);
319         else if (cflags == DP_C_LLONG)
320           value = va_arg (args, unsigned LLONG);
321         else
322           value = va_arg (args, unsigned int);
323         total += fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
324         break;
325       case 'u':
326         flags |= DP_F_UNSIGNED;
327         if (cflags == DP_C_SHORT)
328           value = (unsigned short int) va_arg (args, unsigned int);
329         else if (cflags == DP_C_LONG)
330           value = va_arg (args, unsigned long int);
331         else if (cflags == DP_C_LLONG)
332           value = va_arg (args, unsigned LLONG);
333         else
334           value = va_arg (args, unsigned int);
335         total += fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
336         break;
337       case 'X':
338         flags |= DP_F_UP;
339       case 'x':
340         flags |= DP_F_UNSIGNED;
341         if (cflags == DP_C_SHORT)
342           value = (unsigned short int) va_arg (args, unsigned int);
343         else if (cflags == DP_C_LONG)
344           value = va_arg (args, unsigned long int);
345         else if (cflags == DP_C_LLONG)
346           value = va_arg (args, unsigned LLONG);
347         else
348           value = va_arg (args, unsigned int);
349         total += fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
350         break;
351       case 'f':
352         if (cflags == DP_C_LDOUBLE)
353           fvalue = va_arg (args, LDOUBLE);
354         else
355           fvalue = va_arg (args, double);
356         /* um, floating point? */
357         total += fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
358         break;
359       case 'E':
360         flags |= DP_F_UP;
361       case 'e':
362         if (cflags == DP_C_LDOUBLE)
363           fvalue = va_arg (args, LDOUBLE);
364         else
365           fvalue = va_arg (args, double);
366         break;
367       case 'G':
368         flags |= DP_F_UP;
369       case 'g':
370         if (cflags == DP_C_LDOUBLE)
371           fvalue = va_arg (args, LDOUBLE);
372         else
373           fvalue = va_arg (args, double);
374         break;
375       case 'c':
376         total += dopr_outch (buffer, &currlen, maxlen, va_arg (args, int));
377         break;
378       case 's':
379         strvalue = va_arg (args, char *);
380         total += fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
381         break;
382       case 'p':
383         strvalue = va_arg (args, void *);
384         total += fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min,
385                          max, flags);
386         break;
387       case 'n':
388         if (cflags == DP_C_SHORT) 
389         {
390           short int *num;
391           num = va_arg (args, short int *);
392           *num = currlen;
393         } 
394         else if (cflags == DP_C_LONG) 
395         {
396           long int *num;
397           num = va_arg (args, long int *);
398           *num = currlen;
399         }
400         else if (cflags == DP_C_LLONG) 
401         {
402           LLONG *num;
403           num = va_arg (args, LLONG *);
404           *num = currlen;
405         } 
406         else 
407         {
408           int *num;
409           num = va_arg (args, int *);
410           *num = currlen;
411         }
412         break;
413       case '%':
414         total += dopr_outch (buffer, &currlen, maxlen, ch);
415         break;
416       case 'w':
417         /* not supported yet, treat as next char */
418         ch = *format++;
419         break;
420       default:
421         /* Unknown, skip */
422         break;
423       }
424       ch = *format++;
425       state = DP_S_DEFAULT;
426       flags = cflags = min = 0;
427       max = -1;
428       break;
429     case DP_S_DONE:
430       break;
431     default:
432       /* hmm? */
433       break; /* some picky compilers need this */
434     }
435   }
436   if (buffer != NULL)
437   {
438     if (currlen < maxlen - 1) 
439       buffer[currlen] = '\0';
440     else 
441       buffer[maxlen - 1] = '\0';
442   }
443   return total;
444 }
445
446 static int fmtstr (char *buffer, size_t *currlen, size_t maxlen,
447                    const char *value, int flags, int min, int max)
448 {
449   int padlen, strln;     /* amount to pad */
450   int cnt = 0;
451   int total = 0;
452   
453   if (value == 0)
454   {
455     value = "<NULL>";
456   }
457
458   for (strln = 0; value[strln]; ++strln); /* strlen */
459   if (max >= 0 && max < strln)
460     strln = max;
461   padlen = min - strln;
462   if (padlen < 0) 
463     padlen = 0;
464   if (flags & DP_F_MINUS) 
465     padlen = -padlen; /* Left Justify */
466
467   while (padlen > 0)
468   {
469     total += dopr_outch (buffer, currlen, maxlen, ' ');
470     --padlen;
471   }
472   while (*value && ((max < 0) || (cnt < max)))
473   {
474     total += dopr_outch (buffer, currlen, maxlen, *value++);
475     ++cnt;
476   }
477   while (padlen < 0)
478   {
479     total += dopr_outch (buffer, currlen, maxlen, ' ');
480     ++padlen;
481   }
482   return total;
483 }
484
485 /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
486
487 static int fmtint (char *buffer, size_t *currlen, size_t maxlen,
488                    LLONG value, int base, int min, int max, int flags)
489 {
490   int signvalue = 0;
491   unsigned LLONG uvalue;
492   char convert[24];
493   unsigned int place = 0;
494   int spadlen = 0; /* amount to space pad */
495   int zpadlen = 0; /* amount to zero pad */
496   const char *digits;
497   int total = 0;
498   
499   if (max < 0)
500     max = 0;
501
502   uvalue = value;
503
504   if(!(flags & DP_F_UNSIGNED))
505   {
506     if( value < 0 ) {
507       signvalue = '-';
508       uvalue = -value;
509     }
510     else
511       if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
512         signvalue = '+';
513     else
514       if (flags & DP_F_SPACE)
515         signvalue = ' ';
516   }
517   
518   if (flags & DP_F_UP)
519     /* Should characters be upper case? */
520     digits = "0123456789ABCDEF";
521   else
522     digits = "0123456789abcdef";
523
524   do {
525     convert[place++] = digits[uvalue % (unsigned)base];
526     uvalue = (uvalue / (unsigned)base );
527   } while(uvalue && (place < sizeof (convert)));
528   if (place == sizeof (convert)) place--;
529   convert[place] = 0;
530
531   zpadlen = max - place;
532   spadlen = min - MAX ((unsigned int)max, place) - (signvalue ? 1 : 0);
533   if (zpadlen < 0) zpadlen = 0;
534   if (spadlen < 0) spadlen = 0;
535   if (flags & DP_F_ZERO)
536   {
537     zpadlen = MAX(zpadlen, spadlen);
538     spadlen = 0;
539   }
540   if (flags & DP_F_MINUS) 
541     spadlen = -spadlen; /* Left Justifty */
542
543 #ifdef DEBUG_SNPRINTF
544   dprint (1, (debugfile, "zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
545       zpadlen, spadlen, min, max, place));
546 #endif
547
548   /* Spaces */
549   while (spadlen > 0) 
550   {
551     total += dopr_outch (buffer, currlen, maxlen, ' ');
552     --spadlen;
553   }
554
555   /* Sign */
556   if (signvalue) 
557     total += dopr_outch (buffer, currlen, maxlen, signvalue);
558
559   /* Zeros */
560   if (zpadlen > 0) 
561   {
562     while (zpadlen > 0)
563     {
564       total += dopr_outch (buffer, currlen, maxlen, '0');
565       --zpadlen;
566     }
567   }
568
569   /* Digits */
570   while (place > 0) 
571     total += dopr_outch (buffer, currlen, maxlen, convert[--place]);
572   
573   /* Left Justified spaces */
574   while (spadlen < 0) {
575     total += dopr_outch (buffer, currlen, maxlen, ' ');
576     ++spadlen;
577   }
578
579   return total;
580 }
581
582 static LDOUBLE abs_val (LDOUBLE value)
583 {
584   LDOUBLE result = value;
585
586   if (value < 0)
587     result = -value;
588
589   return result;
590 }
591
592 static LDOUBLE pow10 (int exp)
593 {
594   LDOUBLE result = 1;
595
596   while (exp)
597   {
598     result *= 10;
599     exp--;
600   }
601   
602   return result;
603 }
604
605 static LLONG round (LDOUBLE value)
606 {
607   LLONG intpart;
608
609   intpart = value;
610   value = value - intpart;
611   if (value >= 0.5)
612     intpart++;
613
614   return intpart;
615 }
616
617 static int fmtfp (char *buffer, size_t *currlen, size_t maxlen,
618                   LDOUBLE fvalue, int min, int max, int flags)
619 {
620   int signvalue = 0;
621   LDOUBLE ufvalue;
622   char iconvert[20];
623   char fconvert[20];
624   int iplace = 0;
625   int fplace = 0;
626   int padlen = 0; /* amount to pad */
627   int zpadlen = 0; 
628   int caps = 0;
629   int total = 0;
630   LLONG intpart;
631   LLONG fracpart;
632   
633   /* 
634    * AIX manpage says the default is 0, but Solaris says the default
635    * is 6, and sprintf on AIX defaults to 6
636    */
637   if (max < 0)
638     max = 6;
639
640   ufvalue = abs_val (fvalue);
641
642   if (fvalue < 0)
643     signvalue = '-';
644   else
645     if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
646       signvalue = '+';
647     else
648       if (flags & DP_F_SPACE)
649         signvalue = ' ';
650
651 #if 0
652   if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
653 #endif
654
655   intpart = ufvalue;
656
657   /* 
658    * Sorry, we only support 9 digits past the decimal because of our 
659    * conversion method
660    */
661   if (max > 9)
662     max = 9;
663
664   /* We "cheat" by converting the fractional part to integer by
665    * multiplying by a factor of 10
666    */
667   fracpart = round ((pow10 (max)) * (ufvalue - intpart));
668
669   if (fracpart >= pow10 (max))
670   {
671     intpart++;
672     fracpart -= pow10 (max);
673   }
674
675 #ifdef DEBUG_SNPRINTF
676   dprint (1, (debugfile, "fmtfp: %f =? %d.%d\n", fvalue, intpart, fracpart));
677 #endif
678
679   /* Convert integer part */
680   do {
681     iconvert[iplace++] =
682       (caps? "0123456789ABCDEF":"0123456789abcdef")[intpart % 10];
683     intpart = (intpart / 10);
684   } while(intpart && (iplace < 20));
685   if (iplace == 20) iplace--;
686   iconvert[iplace] = 0;
687
688   /* Convert fractional part */
689   do {
690     fconvert[fplace++] =
691       (caps? "0123456789ABCDEF":"0123456789abcdef")[fracpart % 10];
692     fracpart = (fracpart / 10);
693   } while(fracpart && (fplace < 20));
694   if (fplace == 20) fplace--;
695   fconvert[fplace] = 0;
696
697   /* -1 for decimal point, another -1 if we are printing a sign */
698   padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); 
699   zpadlen = max - fplace;
700   if (zpadlen < 0)
701     zpadlen = 0;
702   if (padlen < 0) 
703     padlen = 0;
704   if (flags & DP_F_MINUS) 
705     padlen = -padlen; /* Left Justifty */
706
707   if ((flags & DP_F_ZERO) && (padlen > 0)) 
708   {
709     if (signvalue) 
710     {
711       total += dopr_outch (buffer, currlen, maxlen, signvalue);
712       --padlen;
713       signvalue = 0;
714     }
715     while (padlen > 0)
716     {
717       total += dopr_outch (buffer, currlen, maxlen, '0');
718       --padlen;
719     }
720   }
721   while (padlen > 0)
722   {
723     total += dopr_outch (buffer, currlen, maxlen, ' ');
724     --padlen;
725   }
726   if (signvalue) 
727     total += dopr_outch (buffer, currlen, maxlen, signvalue);
728
729   while (iplace > 0) 
730     total += dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]);
731
732   /*
733    * Decimal point.  This should probably use locale to find the correct
734    * char to print out.
735    */
736   if (max > 0)
737   {
738     total += dopr_outch (buffer, currlen, maxlen, '.');
739
740     while (fplace > 0) 
741       total += dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]);
742   }
743
744   while (zpadlen > 0)
745   {
746     total += dopr_outch (buffer, currlen, maxlen, '0');
747     --zpadlen;
748   }
749
750   while (padlen < 0) 
751   {
752     total += dopr_outch (buffer, currlen, maxlen, ' ');
753     ++padlen;
754   }
755
756   return total;
757 }
758
759 static int dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c)
760 {
761   if (*currlen + 1 < maxlen)
762     buffer[(*currlen)++] = c;
763   return 1;
764 }
765
766 int vsnprintf (char *str, size_t count, const char *fmt, va_list args)
767 {
768   if (str != NULL)
769     str[0] = 0;
770   return dopr(str, count, fmt, args);
771 }
772
773 /* VARARGS3 */
774 #ifdef HAVE_STDARGS
775 int snprintf (char *str,size_t count,const char *fmt,...)
776 #else
777 int snprintf (va_alist) va_dcl
778 #endif
779 {
780 #ifndef HAVE_STDARGS
781   char *str;
782   size_t count;
783   char *fmt;
784 #endif
785   VA_LOCAL_DECL;
786   int total;
787     
788   VA_START (fmt);
789   VA_SHIFT (str, char *);
790   VA_SHIFT (count, size_t );
791   VA_SHIFT (fmt, char *);
792   total = vsnprintf(str, count, fmt, ap);
793   VA_END;
794   return total;
795 }
796
797 #ifdef TEST_SNPRINTF
798 #ifndef LONG_STRING
799 #define LONG_STRING 1024
800 #endif
801 int main (void)
802 {
803   char buf1[LONG_STRING];
804   char buf2[LONG_STRING];
805   char *fp_fmt[] = {
806     "%-1.5f",
807     "%1.5f",
808     "%123.9f",
809     "%10.5f",
810     "% 10.5f",
811     "%+22.9f",
812     "%+4.9f",
813     "%01.3f",
814     "%4f",
815     "%3.1f",
816     "%3.2f",
817     "%.0f",
818     "%.1f",
819     NULL
820   };
821   double fp_nums[] = { -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996, 
822     0.9996, 1.996, 4.136, 0};
823   char *int_fmt[] = {
824     "%-1.5d",
825     "%1.5d",
826     "%123.9d",
827     "%5.5d",
828     "%10.5d",
829     "% 10.5d",
830     "%+22.33d",
831     "%01.3d",
832     "%4d",
833     NULL
834   };
835   long int_nums[] = { -1, 134, 91340, 341, 0203, 0};
836   int x, y;
837   int fail = 0;
838   int num = 0;
839
840   printf ("Testing snprintf format codes against system sprintf...\n");
841
842   for (x = 0; fp_fmt[x] != NULL ; x++)
843     for (y = 0; fp_nums[y] != 0 ; y++)
844     {
845       snprintf (buf1, sizeof (buf1), fp_fmt[x], fp_nums[y]);
846       sprintf (buf2, fp_fmt[x], fp_nums[y]);
847       if (strcmp (buf1, buf2))
848       {
849         printf("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf  = %s\n", 
850             fp_fmt[x], buf1, buf2);
851         fail++;
852       }
853       num++;
854     }
855
856   for (x = 0; int_fmt[x] != NULL ; x++)
857     for (y = 0; int_nums[y] != 0 ; y++)
858     {
859       snprintf (buf1, sizeof (buf1), int_fmt[x], int_nums[y]);
860       sprintf (buf2, int_fmt[x], int_nums[y]);
861       if (strcmp (buf1, buf2))
862       {
863         printf("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf  = %s\n", 
864             int_fmt[x], buf1, buf2);
865         fail++;
866       }
867       num++;
868     }
869   printf ("%d tests failed out of %d.\n", fail, num);
870 }
871 #endif /* SNPRINTF_TEST */