r13401: remove the rename of the snprintf functions that simo accidentially
[bbaumbach/samba-autobuild/.git] / source4 / lib / replace / snprintf.c
1 /*
2  * NOTE: If you change this file, please merge it into rsync, samba, etc.
3  */
4
5 /*
6  * Copyright Patrick Powell 1995
7  * This code is based on code written by Patrick Powell (papowell@astart.com)
8  * It may be used for any purpose as long as this notice remains intact
9  * on all source code distributions
10  */
11
12 /**************************************************************
13  * Original:
14  * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
15  * A bombproof version of doprnt (dopr) included.
16  * Sigh.  This sort of thing is always nasty do deal with.  Note that
17  * the version here does not include floating point...
18  *
19  * snprintf() is used instead of sprintf() as it does limit checks
20  * for string length.  This covers a nasty loophole.
21  *
22  * The other functions are there to prevent NULL pointers from
23  * causing nast effects.
24  *
25  * More Recently:
26  *  Brandon Long <blong@fiction.net> 9/15/96 for mutt 0.43
27  *  This was ugly.  It is still ugly.  I opted out of floating point
28  *  numbers, but the formatter understands just about everything
29  *  from the normal C string format, at least as far as I can tell from
30  *  the Solaris 2.5 printf(3S) man page.
31  *
32  *  Brandon Long <blong@fiction.net> 10/22/97 for mutt 0.87.1
33  *    Ok, added some minimal floating point support, which means this
34  *    probably requires libm on most operating systems.  Don't yet
35  *    support the exponent (e,E) and sigfig (g,G).  Also, fmtint()
36  *    was pretty badly broken, it just wasn't being exercised in ways
37  *    which showed it, so that's been fixed.  Also, formated the code
38  *    to mutt conventions, and removed dead code left over from the
39  *    original.  Also, there is now a builtin-test, just compile with:
40  *           gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm
41  *    and run snprintf for results.
42  * 
43  *  Thomas Roessler <roessler@guug.de> 01/27/98 for mutt 0.89i
44  *    The PGP code was using unsigned hexadecimal formats. 
45  *    Unfortunately, unsigned formats simply didn't work.
46  *
47  *  Michael Elkins <me@cs.hmc.edu> 03/05/98 for mutt 0.90.8
48  *    The original code assumed that both snprintf() and vsnprintf() were
49  *    missing.  Some systems only have snprintf() but not vsnprintf(), so
50  *    the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
51  *
52  *  Andrew Tridgell (tridge@samba.org) Oct 1998
53  *    fixed handling of %.0f
54  *    added test for HAVE_LONG_DOUBLE
55  *
56  * tridge@samba.org, idra@samba.org, April 2001
57  *    got rid of fcvt code (twas buggy and made testing harder)
58  *    added C99 semantics
59  *
60  * date: 2002/12/19 19:56:31;  author: herb;  state: Exp;  lines: +2 -0
61  * actually print args for %g and %e
62  * 
63  * date: 2002/06/03 13:37:52;  author: jmcd;  state: Exp;  lines: +8 -0
64  * Since includes.h isn't included here, VA_COPY has to be defined here.  I don't
65  * see any include file that is guaranteed to be here, so I'm defining it
66  * locally.  Fixes AIX and Solaris builds.
67  * 
68  * date: 2002/06/03 03:07:24;  author: tridge;  state: Exp;  lines: +5 -13
69  * put the ifdef for HAVE_VA_COPY in one place rather than in lots of
70  * functions
71  * 
72  * date: 2002/05/17 14:51:22;  author: jmcd;  state: Exp;  lines: +21 -4
73  * Fix usage of va_list passed as an arg.  Use __va_copy before using it
74  * when it exists.
75  * 
76  * date: 2002/04/16 22:38:04;  author: idra;  state: Exp;  lines: +20 -14
77  * Fix incorrect zpadlen handling in fmtfp.
78  * Thanks to Ollie Oldham <ollie.oldham@metro-optix.com> for spotting it.
79  * few mods to make it easier to compile the tests.
80  * addedd the "Ollie" test to the floating point ones.
81  *
82  * Martin Pool (mbp@samba.org) April 2003
83  *    Remove NO_CONFIG_H so that the test case can be built within a source
84  *    tree with less trouble.
85  *    Remove unnecessary SAFE_FREE() definition.
86  *
87  * Martin Pool (mbp@samba.org) May 2003
88  *    Put in a prototype for dummy_snprintf() to quiet compiler warnings.
89  *
90  *    Move #endif to make sure VA_COPY, LDOUBLE, etc are defined even
91  *    if the C library has some snprintf functions already.
92  *
93  * Darren Tucker (dtucker@zip.com.au) 2005
94  *    Fix bug allowing read overruns of the source string with "%.*s"
95  *    Usually harmless unless the read runs outside the process' allocation
96  *    (eg if your malloc does guard pages) in which case it will segfault.
97  *    From OpenSSH.  Also added test for same.
98  *
99  * Simo Sorce (idra@samba.org) Jan 2006
100  * 
101  *    Add support for position independent parameters 
102  *    fix fmtstr now it conforms to sprintf wrt min.max
103  *
104  **************************************************************/
105
106 #ifndef NO_CONFIG_H
107 #include "config.h"
108 #else
109 #define NULL 0
110 #endif 
111
112 #ifdef TEST_SNPRINTF /* need math library headers for testing */
113
114 /* In test mode, we pretend that this system doesn't have any snprintf
115  * functions, regardless of what config.h says. */
116 #  undef HAVE_SNPRINTF
117 #  undef HAVE_VSNPRINTF
118 #  undef HAVE_C99_VSNPRINTF
119 #  undef HAVE_ASPRINTF
120 #  undef HAVE_VASPRINTF
121 #  include <math.h>
122 #endif /* TEST_SNPRINTF */
123
124 #ifdef HAVE_STRING_H
125 #include <string.h>
126 #endif
127
128 #ifdef HAVE_STRINGS_H
129 #include <strings.h>
130 #endif
131 #ifdef HAVE_CTYPE_H
132 #include <ctype.h>
133 #endif
134 #include <sys/types.h>
135 #include <stdarg.h>
136 #ifdef HAVE_STDLIB_H
137 #include <stdlib.h>
138 #endif
139
140 #if defined(HAVE_SNPRINTF) && defined(HAVE_VSNPRINTF) && defined(HAVE_C99_VSNPRINTF)
141 /* only include stdio.h if we are not re-defining snprintf or vsnprintf */
142 #include <stdio.h>
143  /* make the compiler happy with an empty file */
144  void dummy_snprintf(void);
145  void dummy_snprintf(void) {} 
146 #endif /* HAVE_SNPRINTF, etc */
147
148 #ifdef HAVE_LONG_DOUBLE
149 #define LDOUBLE long double
150 #else
151 #define LDOUBLE double
152 #endif
153
154 #ifdef HAVE_LONG_LONG
155 #define LLONG long long
156 #else
157 #define LLONG long
158 #endif
159
160 #ifndef VA_COPY
161 #ifdef HAVE_VA_COPY
162 #define VA_COPY(dest, src) va_copy(dest, src)
163 #else
164 #ifdef HAVE___VA_COPY
165 #define VA_COPY(dest, src) __va_copy(dest, src)
166 #else
167 #define VA_COPY(dest, src) (dest) = (src)
168 #endif
169 #endif
170
171 /*
172  * dopr(): poor man's version of doprintf
173  */
174
175 /* format read states */
176 #define DP_S_DEFAULT 0
177 #define DP_S_FLAGS   1
178 #define DP_S_MIN     2
179 #define DP_S_DOT     3
180 #define DP_S_MAX     4
181 #define DP_S_MOD     5
182 #define DP_S_CONV    6
183 #define DP_S_DONE    7
184
185 /* format flags - Bits */
186 #define DP_F_MINUS      (1 << 0)
187 #define DP_F_PLUS       (1 << 1)
188 #define DP_F_SPACE      (1 << 2)
189 #define DP_F_NUM        (1 << 3)
190 #define DP_F_ZERO       (1 << 4)
191 #define DP_F_UP         (1 << 5)
192 #define DP_F_UNSIGNED   (1 << 6)
193
194 /* Conversion Flags */
195 #define DP_C_CHAR    1
196 #define DP_C_SHORT   2
197 #define DP_C_LONG    3
198 #define DP_C_LDOUBLE 4
199 #define DP_C_LLONG   5
200
201 /* Chunk types */
202 #define CNK_FMT_STR 0
203 #define CNK_INT     1
204 #define CNK_OCTAL   2
205 #define CNK_UINT    3
206 #define CNK_HEX     4
207 #define CNK_FLOAT   5
208 #define CNK_CHAR    6
209 #define CNK_STRING  7
210 #define CNK_PTR     8
211 #define CNK_NUM     9
212 #define CNK_PRCNT   10
213
214 #define char_to_int(p) ((p)- '0')
215 #ifndef MAX
216 #define MAX(p,q) (((p) >= (q)) ? (p) : (q))
217 #endif
218
219 /* yes this really must be a ||. Don't muck with this (tridge) */
220 #if !defined(HAVE_VSNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
221
222 struct pr_chunk {
223         int type; /* chunk type */
224         int num; /* parameter number */
225         int min; 
226         int max;
227         int flags;
228         int cflags;
229         int start;
230         int len;
231         LLONG value;
232         LDOUBLE fvalue;
233         char *strvalue;
234         void *pnum;
235         struct pr_chunk *min_star;
236         struct pr_chunk *max_star;
237         struct pr_chunk *next;
238 };
239
240 struct pr_chunk_x {
241         struct pr_chunk **chunks;
242         int num;
243 };
244
245 static size_t dopr(char *buffer, size_t maxlen, const char *format, 
246                    va_list args_in);
247 static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
248                     char *value, int flags, int min, int max);
249 static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
250                     long value, int base, int min, int max, int flags);
251 static void fmtfp(char *buffer, size_t *currlen, size_t maxlen,
252                    LDOUBLE fvalue, int min, int max, int flags);
253 static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c);
254 static struct pr_chunk *new_chunk(void);
255 static int add_cnk_list_entry(struct pr_chunk_x **list,
256                                 int max_num, struct pr_chunk *chunk);
257
258 static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args_in)
259 {
260         char ch;
261         int state;
262         int pflag;
263         int pnum;
264         int pfirst;
265         size_t currlen;
266         va_list args;
267         const char *base;
268         struct pr_chunk *chunks = NULL;
269         struct pr_chunk *cnk = NULL;
270         struct pr_chunk_x *clist = NULL;
271         int max_pos;
272         size_t ret = -1;
273
274         VA_COPY(args, args_in);
275
276         state = DP_S_DEFAULT;
277         pfirst = 1;
278         pflag = 0;
279         pnum = 0;
280
281         max_pos = 0;
282         base = format;
283         ch = *format++;
284         
285         /* retrieve the string structure as chunks */
286         while (state != DP_S_DONE) {
287                 if (ch == '\0') 
288                         state = DP_S_DONE;
289
290                 switch(state) {
291                 case DP_S_DEFAULT:
292                         
293                         if (cnk) {
294                                 cnk->next = new_chunk();
295                                 cnk = cnk->next;
296                         } else {
297                                 cnk = new_chunk();
298                         }
299                         if (!cnk) goto done;
300                         if (!chunks) chunks = cnk;
301                         
302                         if (ch == '%') {
303                                 state = DP_S_FLAGS;
304                                 ch = *format++;
305                         } else {
306                                 cnk->type = CNK_FMT_STR;
307                                 cnk->start = format - base -1;
308                                 while ((ch != '\0') && (ch != '%')) ch = *format++;
309                                 cnk->len = format - base - cnk->start -1;
310                         }
311                         break;
312                 case DP_S_FLAGS:
313                         switch (ch) {
314                         case '-':
315                                 cnk->flags |= DP_F_MINUS;
316                                 ch = *format++;
317                                 break;
318                         case '+':
319                                 cnk->flags |= DP_F_PLUS;
320                                 ch = *format++;
321                                 break;
322                         case ' ':
323                                 cnk->flags |= DP_F_SPACE;
324                                 ch = *format++;
325                                 break;
326                         case '#':
327                                 cnk->flags |= DP_F_NUM;
328                                 ch = *format++;
329                                 break;
330                         case '0':
331                                 cnk->flags |= DP_F_ZERO;
332                                 ch = *format++;
333                                 break;
334                         case 'I':
335                                 /* internationalization not supported yet */
336                                 ch = *format++;
337                                 break;
338                         default:
339                                 state = DP_S_MIN;
340                                 break;
341                         }
342                         break;
343                 case DP_S_MIN:
344                         if (isdigit((unsigned char)ch)) {
345                                 cnk->min = 10 * cnk->min + char_to_int (ch);
346                                 ch = *format++;
347                         } else if (ch == '$') {
348                                 if (!pfirst && !pflag) {
349                                         /* parameters must be all positioned or none */
350                                         goto done;
351                                 }
352                                 if (pfirst) {
353                                         pfirst = 0;
354                                         pflag = 1;
355                                 }
356                                 if (cnk->min == 0) /* what ?? */
357                                         goto done;
358                                 cnk->num = cnk->min;
359                                 cnk->min = 0;
360                                 ch = *format++;
361                         } else if (ch == '*') {
362                                 if (pfirst) pfirst = 0;
363                                 cnk->min_star = new_chunk();
364                                 if (!cnk->min_star) /* out of memory :-( */
365                                         goto done;
366                                 cnk->min_star->type = CNK_INT;
367                                 if (pflag) {
368                                         int num;
369                                         ch = *format++;
370                                         if (!isdigit((unsigned char)ch)) {
371                                                 /* parameters must be all positioned or none */
372                                                 goto done;
373                                         }
374                                         for (num = 0; isdigit((unsigned char)ch); ch = *format++) {
375                                                 num = 10 * num + char_to_int(ch);
376                                         }
377                                         cnk->min_star->num = num;
378                                         if (ch != '$') /* what ?? */
379                                                 goto done;
380                                 } else {
381                                         cnk->min_star->num = ++pnum;
382                                 }
383                                 max_pos = add_cnk_list_entry(&clist, max_pos, cnk->min_star);
384                                 if (max_pos == 0) /* out of memory :-( */
385                                         goto done;
386                                 ch = *format++;
387                                 state = DP_S_DOT;
388                         } else {
389                                 if (pfirst) pfirst = 0;
390                                 state = DP_S_DOT;
391                         }
392                         break;
393                 case DP_S_DOT:
394                         if (ch == '.') {
395                                 state = DP_S_MAX;
396                                 ch = *format++;
397                         } else { 
398                                 state = DP_S_MOD;
399                         }
400                         break;
401                 case DP_S_MAX:
402                         if (isdigit((unsigned char)ch)) {
403                                 if (cnk->max < 0)
404                                         cnk->max = 0;
405                                 cnk->max = 10 * cnk->max + char_to_int (ch);
406                                 ch = *format++;
407                         } else if (ch == '$') {
408                                 if (!pfirst && !pflag) {
409                                         /* parameters must be all positioned or none */
410                                         goto done;
411                                 }
412                                 if (cnk->max <= 0) /* what ?? */
413                                         goto done;
414                                 cnk->num = cnk->max;
415                                 cnk->max = -1;
416                                 ch = *format++;
417                         } else if (ch == '*') {
418                                 cnk->max_star = new_chunk();
419                                 if (!cnk->max_star) /* out of memory :-( */
420                                         goto done;
421                                 cnk->max_star->type = CNK_INT;
422                                 if (pflag) {
423                                         int num;
424                                         ch = *format++;
425                                         if (!isdigit((unsigned char)ch)) {
426                                                 /* parameters must be all positioned or none */
427                                                 goto done;
428                                         }
429                                         for (num = 0; isdigit((unsigned char)ch); ch = *format++) {
430                                                 num = 10 * num + char_to_int(ch);
431                                         }
432                                         cnk->max_star->num = num;
433                                         if (ch != '$') /* what ?? */
434                                                 goto done;
435                                 } else {
436                                         cnk->max_star->num = ++pnum;
437                                 }
438                                 max_pos = add_cnk_list_entry(&clist, max_pos, cnk->max_star);
439                                 if (max_pos == 0) /* out of memory :-( */
440                                         goto done;
441
442                                 ch = *format++;
443                                 state = DP_S_MOD;
444                         } else {
445                                 state = DP_S_MOD;
446                         }
447                         break;
448                 case DP_S_MOD:
449                         switch (ch) {
450                         case 'h':
451                                 cnk->cflags = DP_C_SHORT;
452                                 ch = *format++;
453                                 if (ch == 'h') {
454                                         cnk->cflags = DP_C_CHAR;
455                                         ch = *format++;
456                                 }
457                                 break;
458                         case 'l':
459                                 cnk->cflags = DP_C_LONG;
460                                 ch = *format++;
461                                 if (ch == 'l') {        /* It's a long long */
462                                         cnk->cflags = DP_C_LLONG;
463                                         ch = *format++;
464                                 }
465                                 break;
466                         case 'L':
467                                 cnk->cflags = DP_C_LDOUBLE;
468                                 ch = *format++;
469                                 break;
470                         default:
471                                 break;
472                         }
473                         state = DP_S_CONV;
474                         break;
475                 case DP_S_CONV:
476                         if (cnk->num == 0) cnk->num = ++pnum;
477                         max_pos = add_cnk_list_entry(&clist, max_pos, cnk);
478                         if (max_pos == 0) /* out of memory :-( */
479                                 goto done;
480                         
481                         switch (ch) {
482                         case 'd':
483                         case 'i':
484                                 cnk->type = CNK_INT;
485                                 break;
486                         case 'o':
487                                 cnk->type = CNK_OCTAL;
488                                 cnk->flags |= DP_F_UNSIGNED;
489                                 break;
490                         case 'u':
491                                 cnk->type = CNK_UINT;
492                                 cnk->flags |= DP_F_UNSIGNED;
493                                 break;
494                         case 'X':
495                                 cnk->flags |= DP_F_UP;
496                         case 'x':
497                                 cnk->type = CNK_HEX;
498                                 cnk->flags |= DP_F_UNSIGNED;
499                                 break;
500                         case 'A':
501                                 /* hex float not supported yet */
502                         case 'E':
503                         case 'G':
504                         case 'F':
505                                 cnk->flags |= DP_F_UP;
506                         case 'a':
507                                 /* hex float not supported yet */
508                         case 'e':
509                         case 'f':
510                         case 'g':
511                                 cnk->type = CNK_FLOAT;
512                                 break;
513                         case 'c':
514                                 cnk->type = CNK_CHAR;
515                                 break;
516                         case 's':
517                                 cnk->type = CNK_STRING;
518                                 break;
519                         case 'p':
520                                 cnk->type = CNK_PTR;
521                                 break;
522                         case 'n':
523                                 cnk->type = CNK_NUM;
524                                 break;
525                         case '%':
526                                 cnk->type = CNK_PRCNT;
527                                 break;
528                         default:
529                                 /* Unknown, bail out*/
530                                 goto done;
531                         }
532                         ch = *format++;
533                         state = DP_S_DEFAULT;
534                         break;
535                 case DP_S_DONE:
536                         break;
537                 default:
538                         /* hmm? */
539                         break; /* some picky compilers need this */
540                 }
541         }
542
543         /* retieve the format arguments */
544         for (pnum = 0; pnum < max_pos; pnum++) {
545                 int i;
546
547                 if (clist[pnum].num == 0) {
548                         /* ignoring a parameter should not be permitted
549                          * all parameters must be matched at least once
550                          * BUT seem some system ignore this rule ...
551                          * at least my glibc based system does --SSS
552                          */
553 #ifdef DEBUG_SNPRINTF
554                         printf("parameter at position %d not used\n", pnum+1);
555 #endif
556                         /* eat the parameter */
557                         va_arg (args, int);
558                         continue;
559                 }
560                 for (i = 1; i < clist[pnum].num; i++) {
561                         if (clist[pnum].chunks[0]->type != clist[pnum].chunks[i]->type) {
562                                 /* nooo noo no!
563                                  * all the references to a parameter
564                                  * must be of the same type
565                                  */
566                                 goto done;
567                         }
568                 }
569                 cnk = clist[pnum].chunks[0];
570                 switch (cnk->type) {
571                 case CNK_INT:
572                         if (cnk->cflags == DP_C_SHORT) 
573                                 cnk->value = va_arg (args, int);
574                         else if (cnk->cflags == DP_C_LONG)
575                                 cnk->value = va_arg (args, long int);
576                         else if (cnk->cflags == DP_C_LLONG)
577                                 cnk->value = va_arg (args, LLONG);
578                         else
579                                 cnk->value = va_arg (args, int);
580
581                         for (i = 1; i < clist[pnum].num; i++) {
582                                 clist[pnum].chunks[i]->value = cnk->value;
583                         }
584                         break;
585
586                 case CNK_OCTAL:
587                 case CNK_UINT:
588                 case CNK_HEX:
589                         if (cnk->cflags == DP_C_SHORT)
590                                 cnk->value = va_arg (args, unsigned int);
591                         else if (cnk->cflags == DP_C_LONG)
592                                 cnk->value = (long)va_arg (args, unsigned long int);
593                         else if (cnk->cflags == DP_C_LLONG)
594                                 cnk->value = (LLONG)va_arg (args, unsigned LLONG);
595                         else
596                                 cnk->value = (long)va_arg (args, unsigned int);
597
598                         for (i = 1; i < clist[pnum].num; i++) {
599                                 clist[pnum].chunks[i]->value = cnk->value;
600                         }
601                         break;
602
603                 case CNK_FLOAT:
604                         if (cnk->cflags == DP_C_LDOUBLE)
605                                 cnk->fvalue = va_arg (args, LDOUBLE);
606                         else
607                                 cnk->fvalue = va_arg (args, double);
608
609                         for (i = 1; i < clist[pnum].num; i++) {
610                                 clist[pnum].chunks[i]->fvalue = cnk->fvalue;
611                         }
612                         break;
613
614                 case CNK_CHAR:
615                         cnk->value = va_arg (args, int);
616
617                         for (i = 1; i < clist[pnum].num; i++) {
618                                 clist[pnum].chunks[i]->value = cnk->value;
619                         }
620                         break;
621
622                 case CNK_STRING:
623                         cnk->strvalue = va_arg (args, char *);
624                         if (!cnk->strvalue) cnk->strvalue = "(NULL)";
625
626                         for (i = 1; i < clist[pnum].num; i++) {
627                                 clist[pnum].chunks[i]->strvalue = cnk->strvalue;
628                         }
629                         break;
630
631                 case CNK_PTR:
632                         cnk->strvalue = va_arg (args, void *);
633                         for (i = 1; i < clist[pnum].num; i++) {
634                                 clist[pnum].chunks[i]->strvalue = cnk->strvalue;
635                         }
636                         break;
637
638                 case CNK_NUM:
639                         if (cnk->cflags == DP_C_CHAR)
640                                 cnk->pnum = va_arg (args, char *);
641                         else if (cnk->cflags == DP_C_SHORT)
642                                 cnk->pnum = va_arg (args, short int *);
643                         else if (cnk->cflags == DP_C_LONG)
644                                 cnk->pnum = va_arg (args, long int *);
645                         else if (cnk->cflags == DP_C_LLONG)
646                                 cnk->pnum = va_arg (args, LLONG *);
647                         else
648                                 cnk->pnum = va_arg (args, int *);
649
650                         for (i = 1; i < clist[pnum].num; i++) {
651                                 clist[pnum].chunks[i]->pnum = cnk->pnum;
652                         }
653                         break;
654
655                 case CNK_PRCNT:
656                         break;
657
658                 default:
659                         /* what ?? */
660                         goto done;
661                 }
662         }
663         /* print out the actual string from chunks */
664         currlen = 0;
665         cnk = chunks;
666         while (cnk) {
667                 int len, min, max;
668
669                 if (cnk->min_star) min = cnk->min_star->value;
670                 else min = cnk->min;
671                 if (cnk->max_star) max = cnk->max_star->value;
672                 else max = cnk->max;
673
674                 switch (cnk->type) {
675
676                 case CNK_FMT_STR:
677                         if (maxlen != 0 && maxlen > currlen) {
678                                 if (maxlen > (currlen + cnk->len)) len = cnk->len;
679                                 else len = maxlen - currlen;
680
681                                 memcpy(&(buffer[currlen]), &(base[cnk->start]), len);
682                         }
683                         currlen += cnk->len;
684                                 
685                         break;
686
687                 case CNK_INT:
688                 case CNK_UINT:
689                         fmtint (buffer, &currlen, maxlen, cnk->value, 10, min, max, cnk->flags);
690                         break;
691
692                 case CNK_OCTAL:
693                         fmtint (buffer, &currlen, maxlen, cnk->value, 8, min, max, cnk->flags);
694                         break;
695
696                 case CNK_HEX:
697                         fmtint (buffer, &currlen, maxlen, cnk->value, 16, min, max, cnk->flags);
698                         break;
699
700                 case CNK_FLOAT:
701                         fmtfp (buffer, &currlen, maxlen, cnk->fvalue, min, max, cnk->flags);
702                         break;
703
704                 case CNK_CHAR:
705                         dopr_outch (buffer, &currlen, maxlen, cnk->value);
706                         break;
707
708                 case CNK_STRING:
709                         if (max == -1) {
710                                 max = strlen(cnk->strvalue);
711                         }
712                         fmtstr (buffer, &currlen, maxlen, cnk->strvalue, cnk->flags, min, max);
713                         break;
714
715                 case CNK_PTR:
716                         fmtint (buffer, &currlen, maxlen, (long)(cnk->strvalue), 16, min, max, cnk->flags);
717                         break;
718
719                 case CNK_NUM:
720                         if (cnk->cflags == DP_C_CHAR)
721                                 *((char *)(cnk->pnum)) = (char)currlen;
722                         else if (cnk->cflags == DP_C_SHORT)
723                                 *((short int *)(cnk->pnum)) = (short int)currlen;
724                         else if (cnk->cflags == DP_C_LONG)
725                                 *((long int *)(cnk->pnum)) = (long int)currlen;
726                         else if (cnk->cflags == DP_C_LLONG)
727                                 *((LLONG *)(cnk->pnum)) = (LLONG)currlen;
728                         else
729                                 *((int *)(cnk->pnum)) = (int)currlen;
730                         break;
731
732                 case CNK_PRCNT:
733                         dopr_outch (buffer, &currlen, maxlen, '%');
734                         break;
735
736                 default:
737                         /* what ?? */
738                         goto done;
739                 }
740                 cnk = cnk->next;
741         }
742         if (maxlen != 0) {
743                 if (currlen < maxlen - 1) 
744                         buffer[currlen] = '\0';
745                 else if (maxlen > 0) 
746                         buffer[maxlen - 1] = '\0';
747         }
748         ret = currlen;
749
750 done:
751         while (chunks) {
752                 cnk = chunks->next;
753                 free(chunks);
754                 chunks = cnk;
755         }
756         if (clist) {
757                 for (pnum = 0; pnum < max_pos; pnum++) {
758                         if (clist[pnum].chunks) free(clist[pnum].chunks);
759                 }
760                 free(clist);
761         }
762         return ret;
763 }
764
765 static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
766                     char *value, int flags, int min, int max)
767 {
768         int padlen, strln;     /* amount to pad */
769         int cnt = 0;
770
771 #ifdef DEBUG_SNPRINTF
772         printf("fmtstr min=%d max=%d s=[%s]\n", min, max, value);
773 #endif
774         if (value == 0) {
775                 value = "<NULL>";
776         }
777
778         for (strln = 0; strln < max && value[strln]; ++strln); /* strlen */
779         padlen = min - strln;
780         if (padlen < 0) 
781                 padlen = 0;
782         if (flags & DP_F_MINUS) 
783                 padlen = -padlen; /* Left Justify */
784         
785         while (padlen > 0) {
786                 dopr_outch (buffer, currlen, maxlen, ' ');
787                 --padlen;
788         }
789         while (*value && (cnt < max)) {
790                 dopr_outch (buffer, currlen, maxlen, *value++);
791                 ++cnt;
792         }
793         while (padlen < 0) {
794                 dopr_outch (buffer, currlen, maxlen, ' ');
795                 ++padlen;
796         }
797 }
798
799 /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
800
801 static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
802                     long value, int base, int min, int max, int flags)
803 {
804         int signvalue = 0;
805         unsigned long uvalue;
806         char convert[20];
807         int place = 0;
808         int spadlen = 0; /* amount to space pad */
809         int zpadlen = 0; /* amount to zero pad */
810         int caps = 0;
811         
812         if (max < 0)
813                 max = 0;
814         
815         uvalue = value;
816         
817         if(!(flags & DP_F_UNSIGNED)) {
818                 if( value < 0 ) {
819                         signvalue = '-';
820                         uvalue = -value;
821                 } else {
822                         if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
823                                 signvalue = '+';
824                         else if (flags & DP_F_SPACE)
825                                 signvalue = ' ';
826                 }
827         }
828   
829         if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
830
831         do {
832                 convert[place++] =
833                         (caps? "0123456789ABCDEF":"0123456789abcdef")
834                         [uvalue % (unsigned)base  ];
835                 uvalue = (uvalue / (unsigned)base );
836         } while(uvalue && (place < 20));
837         if (place == 20) place--;
838         convert[place] = 0;
839
840         zpadlen = max - place;
841         spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
842         if (zpadlen < 0) zpadlen = 0;
843         if (spadlen < 0) spadlen = 0;
844         if (flags & DP_F_ZERO) {
845                 zpadlen = MAX(zpadlen, spadlen);
846                 spadlen = 0;
847         }
848         if (flags & DP_F_MINUS) 
849                 spadlen = -spadlen; /* Left Justifty */
850
851 #ifdef DEBUG_SNPRINTF
852         printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
853                zpadlen, spadlen, min, max, place);
854 #endif
855
856         /* Spaces */
857         while (spadlen > 0) {
858                 dopr_outch (buffer, currlen, maxlen, ' ');
859                 --spadlen;
860         }
861
862         /* Sign */
863         if (signvalue) 
864                 dopr_outch (buffer, currlen, maxlen, signvalue);
865
866         /* Zeros */
867         if (zpadlen > 0) {
868                 while (zpadlen > 0) {
869                         dopr_outch (buffer, currlen, maxlen, '0');
870                         --zpadlen;
871                 }
872         }
873
874         /* Digits */
875         while (place > 0) 
876                 dopr_outch (buffer, currlen, maxlen, convert[--place]);
877   
878         /* Left Justified spaces */
879         while (spadlen < 0) {
880                 dopr_outch (buffer, currlen, maxlen, ' ');
881                 ++spadlen;
882         }
883 }
884
885 static LDOUBLE abs_val(LDOUBLE value)
886 {
887         LDOUBLE result = value;
888
889         if (value < 0)
890                 result = -value;
891         
892         return result;
893 }
894
895 static LDOUBLE POW10(int exp)
896 {
897         LDOUBLE result = 1;
898         
899         while (exp) {
900                 result *= 10;
901                 exp--;
902         }
903   
904         return result;
905 }
906
907 static LLONG ROUND(LDOUBLE value)
908 {
909         LLONG intpart;
910
911         intpart = (LLONG)value;
912         value = value - intpart;
913         if (value >= 0.5) intpart++;
914         
915         return intpart;
916 }
917
918 /* a replacement for modf that doesn't need the math library. Should
919    be portable, but slow */
920 static double my_modf(double x0, double *iptr)
921 {
922         int i;
923         long l;
924         double x = x0;
925         double f = 1.0;
926
927         for (i=0;i<100;i++) {
928                 l = (long)x;
929                 if (l <= (x+1) && l >= (x-1)) break;
930                 x *= 0.1;
931                 f *= 10.0;
932         }
933
934         if (i == 100) {
935                 /* yikes! the number is beyond what we can handle. What do we do? */
936                 (*iptr) = 0;
937                 return 0;
938         }
939
940         if (i != 0) {
941                 double i2;
942                 double ret;
943
944                 ret = my_modf(x0-l*f, &i2);
945                 (*iptr) = l*f + i2;
946                 return ret;
947         } 
948
949         (*iptr) = l;
950         return x - (*iptr);
951 }
952
953
954 static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
955                    LDOUBLE fvalue, int min, int max, int flags)
956 {
957         int signvalue = 0;
958         double ufvalue;
959         char iconvert[311];
960         char fconvert[311];
961         int iplace = 0;
962         int fplace = 0;
963         int padlen = 0; /* amount to pad */
964         int zpadlen = 0; 
965         int caps = 0;
966         int idx;
967         double intpart;
968         double fracpart;
969         double temp;
970   
971         /* 
972          * AIX manpage says the default is 0, but Solaris says the default
973          * is 6, and sprintf on AIX defaults to 6
974          */
975         if (max < 0)
976                 max = 6;
977
978         ufvalue = abs_val (fvalue);
979
980         if (fvalue < 0) {
981                 signvalue = '-';
982         } else {
983                 if (flags & DP_F_PLUS) { /* Do a sign (+/i) */
984                         signvalue = '+';
985                 } else {
986                         if (flags & DP_F_SPACE)
987                                 signvalue = ' ';
988                 }
989         }
990
991 #if 0
992         if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
993 #endif
994
995 #if 0
996          if (max == 0) ufvalue += 0.5; /* if max = 0 we must round */
997 #endif
998
999         /* 
1000          * Sorry, we only support 9 digits past the decimal because of our 
1001          * conversion method
1002          */
1003         if (max > 9)
1004                 max = 9;
1005
1006         /* We "cheat" by converting the fractional part to integer by
1007          * multiplying by a factor of 10
1008          */
1009
1010         temp = ufvalue;
1011         my_modf(temp, &intpart);
1012
1013         fracpart = ROUND((POW10(max)) * (ufvalue - intpart));
1014         
1015         if (fracpart >= POW10(max)) {
1016                 intpart++;
1017                 fracpart -= POW10(max);
1018         }
1019
1020
1021         /* Convert integer part */
1022         do {
1023                 temp = intpart*0.1;
1024                 my_modf(temp, &intpart);
1025                 idx = (int) ((temp -intpart +0.05)* 10.0);
1026                 /* idx = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */
1027                 /* printf ("%llf, %f, %x\n", temp, intpart, idx); */
1028                 iconvert[iplace++] =
1029                         (caps? "0123456789ABCDEF":"0123456789abcdef")[idx];
1030         } while (intpart && (iplace < 311));
1031         if (iplace == 311) iplace--;
1032         iconvert[iplace] = 0;
1033
1034         /* Convert fractional part */
1035         if (fracpart)
1036         {
1037                 do {
1038                         temp = fracpart*0.1;
1039                         my_modf(temp, &fracpart);
1040                         idx = (int) ((temp -fracpart +0.05)* 10.0);
1041                         /* idx = (int) ((((temp/10) -fracpart) +0.05) *10); */
1042                         /* printf ("%lf, %lf, %ld\n", temp, fracpart, idx ); */
1043                         fconvert[fplace++] =
1044                         (caps? "0123456789ABCDEF":"0123456789abcdef")[idx];
1045                 } while(fracpart && (fplace < 311));
1046                 if (fplace == 311) fplace--;
1047         }
1048         fconvert[fplace] = 0;
1049   
1050         /* -1 for decimal point, another -1 if we are printing a sign */
1051         padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); 
1052         zpadlen = max - fplace;
1053         if (zpadlen < 0) zpadlen = 0;
1054         if (padlen < 0) 
1055                 padlen = 0;
1056         if (flags & DP_F_MINUS) 
1057                 padlen = -padlen; /* Left Justifty */
1058         
1059         if ((flags & DP_F_ZERO) && (padlen > 0)) {
1060                 if (signvalue) {
1061                         dopr_outch (buffer, currlen, maxlen, signvalue);
1062                         --padlen;
1063                         signvalue = 0;
1064                 }
1065                 while (padlen > 0) {
1066                         dopr_outch (buffer, currlen, maxlen, '0');
1067                         --padlen;
1068                 }
1069         }
1070         while (padlen > 0) {
1071                 dopr_outch (buffer, currlen, maxlen, ' ');
1072                 --padlen;
1073         }
1074         if (signvalue) 
1075                 dopr_outch (buffer, currlen, maxlen, signvalue);
1076         
1077         while (iplace > 0) 
1078                 dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]);
1079
1080 #ifdef DEBUG_SNPRINTF
1081         printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
1082 #endif
1083
1084         /*
1085          * Decimal point.  This should probably use locale to find the correct
1086          * char to print out.
1087          */
1088         if (max > 0) {
1089                 dopr_outch (buffer, currlen, maxlen, '.');
1090                 
1091                 while (zpadlen > 0) {
1092                         dopr_outch (buffer, currlen, maxlen, '0');
1093                         --zpadlen;
1094                 }
1095
1096                 while (fplace > 0) 
1097                         dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]);
1098         }
1099
1100         while (padlen < 0) {
1101                 dopr_outch (buffer, currlen, maxlen, ' ');
1102                 ++padlen;
1103         }
1104 }
1105
1106 static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c)
1107 {
1108         if (*currlen < maxlen) {
1109                 buffer[(*currlen)] = c;
1110         }
1111         (*currlen)++;
1112 }
1113
1114 static struct pr_chunk *new_chunk(void) {
1115         struct pr_chunk *new = (struct pr_chunk *)malloc(sizeof(struct pr_chunk));
1116
1117         if (!new) return NULL;
1118
1119         new->type = 0;
1120         new->num = 0;
1121         new->min = 0;
1122         new->min_star = NULL;
1123         new->max = -1;
1124         new->max_star = NULL;
1125         new->flags = 0;
1126         new->cflags = 0;
1127         new->start = 0;
1128         new->len = 0;
1129         new->value = 0;
1130         new->fvalue = 0;
1131         new->strvalue = NULL;
1132         new->pnum = NULL;
1133         new->next = NULL;
1134 }
1135
1136 static int add_cnk_list_entry(struct pr_chunk_x **list,
1137                                 int max_num, struct pr_chunk *chunk) {
1138         struct pr_chunk_x *l;
1139         struct pr_chunk **c;
1140         int max;
1141         int cnum;
1142         int i, pos;
1143
1144         if (chunk->num > max_num) {
1145                 max = chunk->num;
1146         
1147                 if (*list == NULL) {
1148                         l = (struct pr_chunk_x *)malloc(sizeof(struct pr_chunk_x) * max);
1149                         pos = 0;
1150                 } else {
1151                         l = (struct pr_chunk_x *)realloc(*list, sizeof(struct pr_chunk_x) * max);
1152                         pos = max_num;
1153                 }
1154                 if (l == NULL) {
1155                         for (i = 0; i < max; i++) {
1156                                 if ((*list)[i].chunks) free((*list)[i].chunks);
1157                         }
1158                         return 0;
1159                 }
1160                 for (i = pos; i < max; i++) {
1161                         l[i].chunks = NULL;
1162                         l[i].num = 0;
1163                 }
1164         } else {
1165                 l = *list;
1166                 max = max_num;
1167         }
1168
1169         i = chunk->num - 1;
1170         cnum = l[i].num + 1;
1171         if (l[i].chunks == NULL) {
1172                 c = (struct pr_chunk **)malloc(sizeof(struct pr_chunk *) * cnum); 
1173         } else {
1174                 c = (struct pr_chunk **)realloc(l[i].chunks, sizeof(struct pr_chunk *) * cnum);
1175         }
1176         if (c == NULL) {
1177                 for (i = 0; i < max; i++) {
1178                         if (l[i].chunks) free(l[i].chunks);
1179                 }
1180                 return 0;
1181         }
1182         c[l[i].num] = chunk;
1183         l[i].chunks = c;
1184         l[i].num = cnum;
1185
1186         *list = l;
1187         return max;
1188 }
1189
1190  int vsnprintf (char *str, size_t count, const char *fmt, va_list args)
1191 {
1192         return dopr(str, count, fmt, args);
1193 }
1194 #endif
1195
1196 /* yes this really must be a ||. Don't muck with this (tridge)
1197  *
1198  * The logic for these two is that we need our own definition if the
1199  * OS *either* has no definition of *sprintf, or if it does have one
1200  * that doesn't work properly according to the autoconf test.
1201  */
1202 #if !defined(HAVE_SNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
1203  int snprintf(char *str,size_t count,const char *fmt,...)
1204 {
1205         size_t ret;
1206         va_list ap;
1207     
1208         va_start(ap, fmt);
1209         ret = vsnprintf(str, count, fmt, ap);
1210         va_end(ap);
1211         return ret;
1212 }
1213 #endif
1214
1215 #endif 
1216
1217 #ifndef HAVE_VASPRINTF
1218  int vasprintf(char **ptr, const char *format, va_list ap)
1219 {
1220         int ret;
1221         va_list ap2;
1222
1223         VA_COPY(ap2, ap);
1224         
1225         ret = vsnprintf(NULL, 0, format, ap2);
1226         if (ret <= 0) return ret;
1227
1228         (*ptr) = (char *)malloc(ret+1);
1229         if (!*ptr) return -1;
1230
1231         VA_COPY(ap2, ap);
1232
1233         ret = vsnprintf(*ptr, ret+1, format, ap2);
1234
1235         return ret;
1236 }
1237 #endif
1238
1239
1240 #ifndef HAVE_ASPRINTF
1241  int asprintf(char **ptr, const char *format, ...)
1242 {
1243         va_list ap;
1244         int ret;
1245         
1246         *ptr = NULL;
1247         va_start(ap, format);
1248         ret = vasprintf(ptr, format, ap);
1249         va_end(ap);
1250
1251         return ret;
1252 }
1253 #endif
1254
1255 #ifdef TEST_SNPRINTF
1256
1257  int sprintf(char *str,const char *fmt,...);
1258
1259  int main (void)
1260 {
1261         char buf1[1024];
1262         char buf2[1024];
1263         char *buf3;
1264         char *fp_fmt[] = {
1265                 "%1.1f",
1266                 "%-1.5f",
1267                 "%1.5f",
1268                 "%123.9f",
1269                 "%10.5f",
1270                 "% 10.5f",
1271                 "%+22.9f",
1272                 "%+4.9f",
1273                 "%01.3f",
1274                 "%4f",
1275                 "%3.1f",
1276                 "%3.2f",
1277                 "%.0f",
1278                 "%f",
1279                 "%-8.8f",
1280                 "%-9.9f",
1281                 NULL
1282         };
1283         double fp_nums[] = { 6442452944.1234, -1.5, 134.21, 91340.2, 341.1234, 203.9, 0.96, 0.996, 
1284                              0.9996, 1.996, 4.136, 5.030201, 0.00205,
1285                              /* END LIST */ 0};
1286         char *int_fmt[] = {
1287                 "%-1.5d",
1288                 "%1.5d",
1289                 "%123.9d",
1290                 "%5.5d",
1291                 "%10.5d",
1292                 "% 10.5d",
1293                 "%+22.33d",
1294                 "%01.3d",
1295                 "%4d",
1296                 "%d",
1297                 NULL
1298         };
1299         long int_nums[] = { -1, 134, 91340, 341, 0203, 0, 1234567890};
1300         char *str_fmt[] = {
1301                 "%10.5s",
1302                 "%-10.5s",
1303                 "%5.10s",
1304                 "%-5.10s",
1305                 "%10.1s",
1306                 "%0.10s",
1307                 "%10.0s",
1308                 "%1.10s",
1309                 "%s",
1310                 "%.1s",
1311                 "%.10s",
1312                 "%10s",
1313                 NULL
1314         };
1315         char *str_vals[] = {"hello", "a", "", "a longer string", NULL};
1316         int x, y;
1317         int fail = 0;
1318         int num = 0;
1319         int l1, l2;
1320
1321         printf ("Testing snprintf format codes against system sprintf...\n");
1322
1323         for (x = 0; fp_fmt[x] ; x++) {
1324                 for (y = 0; fp_nums[y] != 0 ; y++) {
1325                         buf1[0] = buf2[0] = '\0';
1326                         l1 = snprintf(NULL, 0, fp_fmt[x], fp_nums[y]);
1327                         l2 = snprintf(buf1, sizeof(buf1), fp_fmt[x], fp_nums[y]);
1328                         sprintf (buf2, fp_fmt[x], fp_nums[y]);
1329                         buf1[1023] = buf1[1023] = '\0';
1330                         if (strcmp (buf1, buf2) || (l1 != l2)) {
1331                                 printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n", 
1332                                        fp_fmt[x], l1, buf1, l2, buf2);
1333                                 fail++;
1334                         }
1335                         num++;
1336                 }
1337         }
1338
1339         for (x = 0; int_fmt[x] ; x++) {
1340                 for (y = 0; int_nums[y] != 0 ; y++) {
1341                         buf1[0] = buf2[0] = '\0';
1342                         l1 = snprintf(NULL, 0, int_fmt[x], int_nums[y]);
1343                         l2 = snprintf(buf1, sizeof(buf1), int_fmt[x], int_nums[y]);
1344                         sprintf (buf2, int_fmt[x], int_nums[y]);
1345                         buf1[1023] = buf1[1023] = '\0';
1346                         if (strcmp (buf1, buf2) || (l1 != l2)) {
1347                                 printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n", 
1348                                        int_fmt[x], l1, buf1, l2, buf2);
1349                                 fail++;
1350                         }
1351                         num++;
1352                 }
1353         }
1354
1355         for (x = 0; str_fmt[x] ; x++) {
1356                 for (y = 0; str_vals[y] != 0 ; y++) {
1357                         buf1[0] = buf2[0] = '\0';
1358                         l1 = snprintf(NULL, 0, str_fmt[x], str_vals[y]);
1359                         l2 = snprintf(buf1, sizeof(buf1), str_fmt[x], str_vals[y]);
1360                         sprintf (buf2, str_fmt[x], str_vals[y]);
1361                         buf1[1023] = buf1[1023] = '\0';
1362                         if (strcmp (buf1, buf2) || (l1 != l2)) {
1363                                 printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n", 
1364                                        str_fmt[x], l1, buf1, l2, buf2);
1365                                 fail++;
1366                         }
1367                         num++;
1368                 }
1369         }
1370
1371 #define BUFSZ 2048
1372
1373         buf1[0] = buf2[0] = '\0';
1374         if ((buf3 = malloc(BUFSZ)) == NULL) {
1375                 fail++;
1376         } else {
1377                 num++;
1378                 memset(buf3, 'a', BUFSZ);
1379                 snprintf(buf1, sizeof(buf1), "%.*s", 1, buf3);
1380                 buf1[1023] = '\0';
1381                 if (strcmp(buf1, "a") != 0) {
1382                         printf("length limit buf1 '%s' expected 'a'\n", buf1);
1383                         fail++;
1384                 }
1385         }
1386
1387         buf1[0] = buf2[0] = '\0';
1388         l1 = snprintf(buf1, sizeof(buf1), "%4$*1$d %2$s %3$*1$.*1$f", 3, "pos test", 12.3456, 9);
1389         l2 = sprintf(buf2, "%4$*1$d %2$s %3$*1$.*1$f", 3, "pos test", 12.3456, 9);
1390         buf1[1023] = buf1[1023] = '\0';
1391         if (strcmp(buf1, buf2) || (l1 != l2)) {
1392                 printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n",
1393                                 "%4$*1$d %2$s %3$*1$.*1$f", l1, buf1, l2, buf2);
1394                 fail++;
1395         }
1396
1397         buf1[0] = buf2[0] = '\0';
1398         l1 = snprintf(buf1, sizeof(buf1), "%4$*4$d %2$s %3$*4$.*4$f", 3, "pos test", 12.3456, 9);
1399         l2 = sprintf(buf2, "%4$*4$d %2$s %3$*4$.*4$f", 3, "pos test", 12.3456, 9);
1400         buf1[1023] = buf1[1023] = '\0';
1401         if (strcmp(buf1, buf2)) {
1402                 printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n",
1403                                 "%4$*1$d %2$s %3$*1$.*1$f", l1, buf1, l2, buf2);
1404                 fail++;
1405         }
1406 #if 0
1407         buf1[0] = buf2[0] = '\0';
1408         l1 = snprintf(buf1, sizeof(buf1), "%lld", (LLONG)1234567890);
1409         l2 = sprintf(buf2, "%lld", (LLONG)1234567890);
1410         buf1[1023] = buf1[1023] = '\0';
1411         if (strcmp(buf1, buf2)) {
1412                 printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n",
1413                                 "%lld", l1, buf1, l2, buf2);
1414                 fail++;
1415         }
1416
1417         buf1[0] = buf2[0] = '\0';
1418         l1 = snprintf(buf1, sizeof(buf1), "%Lf", (LDOUBLE)890.1234567890123);
1419         l2 = sprintf(buf2, "%Lf", (LDOUBLE)890.1234567890123);
1420         buf1[1023] = buf1[1023] = '\0';
1421         if (strcmp(buf1, buf2)) {
1422                 printf("snprintf doesn't match Format: %s\n\tsnprintf(%d) = [%s]\n\t sprintf(%d) = [%s]\n",
1423                                 "%Lf", l1, buf1, l2, buf2);
1424                 fail++;
1425         }
1426 #endif
1427         printf ("%d tests failed out of %d.\n", fail, num);
1428
1429         printf("seeing how many digits we support\n");
1430         {
1431                 double v0 = 0.12345678901234567890123456789012345678901;
1432                 for (x=0; x<100; x++) {
1433                         double p = pow(10, x); 
1434                         double r = v0*p;
1435                         snprintf(buf1, sizeof(buf1), "%1.1f", r);
1436                         sprintf(buf2,                "%1.1f", r);
1437                         if (strcmp(buf1, buf2)) {
1438                                 printf("we seem to support %d digits\n", x-1);
1439                                 break;
1440                         }
1441                 }
1442         }
1443
1444         return 0;
1445 }
1446 #endif /* TEST_SNPRINTF */