2 * Copyright Patrick Powell 1995
3 * This code is based on code written by Patrick Powell (papowell@astart.com)
4 * It may be used for any purpose as long as this notice remains intact
5 * on all source code distributions
8 /**************************************************************
10 * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
11 * A bombproof version of doprnt (dopr) included.
12 * Sigh. This sort of thing is always nasty do deal with. Note that
13 * the version here does not include floating point...
15 * snprintf() is used instead of sprintf() as it does limit checks
16 * for string length. This covers a nasty loophole.
18 * The other functions are there to prevent NULL pointers from
19 * causing nast effects.
22 * Brandon Long <blong@fiction.net> 9/15/96 for mutt 0.43
23 * This was ugly. It is still ugly. I opted out of floating point
24 * numbers, but the formatter understands just about everything
25 * from the normal C string format, at least as far as I can tell from
26 * the Solaris 2.5 printf(3S) man page.
28 * Brandon Long <blong@fiction.net> 10/22/97 for mutt 0.87.1
29 * Ok, added some minimal floating point support, which means this
30 * probably requires libm on most operating systems. Don't yet
31 * support the exponent (e,E) and sigfig (g,G). Also, fmtint()
32 * was pretty badly broken, it just wasn't being exercised in ways
33 * which showed it, so that's been fixed. Also, formated the code
34 * to mutt conventions, and removed dead code left over from the
35 * original. Also, there is now a builtin-test, just compile with:
36 * gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm
37 * and run snprintf for results.
39 * Thomas Roessler <roessler@guug.de> 01/27/98 for mutt 0.89i
40 * The PGP code was using unsigned hexadecimal formats.
41 * Unfortunately, unsigned formats simply didn't work.
43 * Michael Elkins <me@cs.hmc.edu> 03/05/98 for mutt 0.90.8
44 * The original code assumed that both snprintf() and vsnprintf() were
45 * missing. Some systems only have snprintf() but not vsnprintf(), so
46 * the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
48 * Andrew Tridgell (tridge@samba.org) Oct 1998
49 * fixed handling of %.0f
50 * added test for HAVE_LONG_DOUBLE
52 * tridge@samba.org, idra@samba.org, April 2001
53 * got rid of fcvt code (twas buggy and made testing harder)
56 **************************************************************/
58 #ifndef NO_CONFIG_H /* for some tests */
72 #include <sys/types.h>
79 #if defined(HAVE_SNPRINTF) && defined(HAVE_VSNPRINTF) && defined(HAVE_C99_VSNPRINTF)
80 /* only include stdio.h if we are not re-defining snprintf or vsnprintf */
82 /* make the compiler happy with an empty file */
83 void dummy_snprintf(void) {}
86 #ifdef HAVE_LONG_DOUBLE
87 #define LDOUBLE long double
89 #define LDOUBLE double
93 #define LLONG long long
98 static size_t dopr(char *buffer
, size_t maxlen
, const char *format
,
100 static void fmtstr(char *buffer
, size_t *currlen
, size_t maxlen
,
101 char *value
, int flags
, int min
, int max
);
102 static void fmtint(char *buffer
, size_t *currlen
, size_t maxlen
,
103 long value
, int base
, int min
, int max
, int flags
);
104 static void fmtfp(char *buffer
, size_t *currlen
, size_t maxlen
,
105 LDOUBLE fvalue
, int min
, int max
, int flags
);
106 static void dopr_outch(char *buffer
, size_t *currlen
, size_t maxlen
, char c
);
109 * dopr(): poor man's version of doprintf
112 /* format read states */
113 #define DP_S_DEFAULT 0
122 /* format flags - Bits */
123 #define DP_F_MINUS (1 << 0)
124 #define DP_F_PLUS (1 << 1)
125 #define DP_F_SPACE (1 << 2)
126 #define DP_F_NUM (1 << 3)
127 #define DP_F_ZERO (1 << 4)
128 #define DP_F_UP (1 << 5)
129 #define DP_F_UNSIGNED (1 << 6)
131 /* Conversion Flags */
134 #define DP_C_LDOUBLE 3
137 #define char_to_int(p) ((p)- '0')
139 #define MAX(p,q) (((p) >= (q)) ? (p) : (q))
142 static size_t dopr(char *buffer
, size_t maxlen
, const char *format
, va_list args
)
155 state
= DP_S_DEFAULT
;
156 currlen
= flags
= cflags
= min
= 0;
160 while (state
!= DP_S_DONE
) {
169 dopr_outch (buffer
, &currlen
, maxlen
, ch
);
200 if (isdigit((unsigned char)ch
)) {
201 min
= 10*min
+ char_to_int (ch
);
203 } else if (ch
== '*') {
204 min
= va_arg (args
, int);
220 if (isdigit((unsigned char)ch
)) {
223 max
= 10*max
+ char_to_int (ch
);
225 } else if (ch
== '*') {
226 max
= va_arg (args
, int);
242 if (ch
== 'l') { /* It's a long long */
248 cflags
= DP_C_LDOUBLE
;
260 if (cflags
== DP_C_SHORT
)
261 value
= va_arg (args
, int);
262 else if (cflags
== DP_C_LONG
)
263 value
= va_arg (args
, long int);
264 else if (cflags
== DP_C_LLONG
)
265 value
= va_arg (args
, LLONG
);
267 value
= va_arg (args
, int);
268 fmtint (buffer
, &currlen
, maxlen
, value
, 10, min
, max
, flags
);
271 flags
|= DP_F_UNSIGNED
;
272 if (cflags
== DP_C_SHORT
)
273 value
= va_arg (args
, unsigned int);
274 else if (cflags
== DP_C_LONG
)
275 value
= (long)va_arg (args
, unsigned long int);
276 else if (cflags
== DP_C_LLONG
)
277 value
= (long)va_arg (args
, unsigned LLONG
);
279 value
= (long)va_arg (args
, unsigned int);
280 fmtint (buffer
, &currlen
, maxlen
, value
, 8, min
, max
, flags
);
283 flags
|= DP_F_UNSIGNED
;
284 if (cflags
== DP_C_SHORT
)
285 value
= va_arg (args
, unsigned int);
286 else if (cflags
== DP_C_LONG
)
287 value
= (long)va_arg (args
, unsigned long int);
288 else if (cflags
== DP_C_LLONG
)
289 value
= (LLONG
)va_arg (args
, unsigned LLONG
);
291 value
= (long)va_arg (args
, unsigned int);
292 fmtint (buffer
, &currlen
, maxlen
, value
, 10, min
, max
, flags
);
297 flags
|= DP_F_UNSIGNED
;
298 if (cflags
== DP_C_SHORT
)
299 value
= va_arg (args
, unsigned int);
300 else if (cflags
== DP_C_LONG
)
301 value
= (long)va_arg (args
, unsigned long int);
302 else if (cflags
== DP_C_LLONG
)
303 value
= (LLONG
)va_arg (args
, unsigned LLONG
);
305 value
= (long)va_arg (args
, unsigned int);
306 fmtint (buffer
, &currlen
, maxlen
, value
, 16, min
, max
, flags
);
309 if (cflags
== DP_C_LDOUBLE
)
310 fvalue
= va_arg (args
, LDOUBLE
);
312 fvalue
= va_arg (args
, double);
313 /* um, floating point? */
314 fmtfp (buffer
, &currlen
, maxlen
, fvalue
, min
, max
, flags
);
319 if (cflags
== DP_C_LDOUBLE
)
320 fvalue
= va_arg (args
, LDOUBLE
);
322 fvalue
= va_arg (args
, double);
327 if (cflags
== DP_C_LDOUBLE
)
328 fvalue
= va_arg (args
, LDOUBLE
);
330 fvalue
= va_arg (args
, double);
333 dopr_outch (buffer
, &currlen
, maxlen
, va_arg (args
, int));
336 strvalue
= va_arg (args
, char *);
338 max
= strlen(strvalue
);
340 if (min
> 0 && max
>= 0 && min
> max
) max
= min
;
341 fmtstr (buffer
, &currlen
, maxlen
, strvalue
, flags
, min
, max
);
344 strvalue
= va_arg (args
, void *);
345 fmtint (buffer
, &currlen
, maxlen
, (long) strvalue
, 16, min
, max
, flags
);
348 if (cflags
== DP_C_SHORT
) {
350 num
= va_arg (args
, short int *);
352 } else if (cflags
== DP_C_LONG
) {
354 num
= va_arg (args
, long int *);
355 *num
= (long int)currlen
;
356 } else if (cflags
== DP_C_LLONG
) {
358 num
= va_arg (args
, LLONG
*);
359 *num
= (LLONG
)currlen
;
362 num
= va_arg (args
, int *);
367 dopr_outch (buffer
, &currlen
, maxlen
, ch
);
370 /* not supported yet, treat as next char */
378 state
= DP_S_DEFAULT
;
379 flags
= cflags
= min
= 0;
386 break; /* some picky compilers need this */
390 if (currlen
< maxlen
- 1)
391 buffer
[currlen
] = '\0';
393 buffer
[maxlen
- 1] = '\0';
399 static void fmtstr(char *buffer
, size_t *currlen
, size_t maxlen
,
400 char *value
, int flags
, int min
, int max
)
402 int padlen
, strln
; /* amount to pad */
405 #ifdef DEBUG_SNPRINTF
406 printf("fmtstr min=%d max=%d s=[%s]\n", min
, max
, value
);
412 for (strln
= 0; value
[strln
]; ++strln
); /* strlen */
413 padlen
= min
- strln
;
416 if (flags
& DP_F_MINUS
)
417 padlen
= -padlen
; /* Left Justify */
419 while ((padlen
> 0) && (cnt
< max
)) {
420 dopr_outch (buffer
, currlen
, maxlen
, ' ');
424 while (*value
&& (cnt
< max
)) {
425 dopr_outch (buffer
, currlen
, maxlen
, *value
++);
428 while ((padlen
< 0) && (cnt
< max
)) {
429 dopr_outch (buffer
, currlen
, maxlen
, ' ');
435 /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
437 static void fmtint(char *buffer
, size_t *currlen
, size_t maxlen
,
438 long value
, int base
, int min
, int max
, int flags
)
441 unsigned long uvalue
;
444 int spadlen
= 0; /* amount to space pad */
445 int zpadlen
= 0; /* amount to zero pad */
453 if(!(flags
& DP_F_UNSIGNED
)) {
458 if (flags
& DP_F_PLUS
) /* Do a sign (+/i) */
460 else if (flags
& DP_F_SPACE
)
465 if (flags
& DP_F_UP
) caps
= 1; /* Should characters be upper case? */
469 (caps
? "0123456789ABCDEF":"0123456789abcdef")
470 [uvalue
% (unsigned)base
];
471 uvalue
= (uvalue
/ (unsigned)base
);
472 } while(uvalue
&& (place
< 20));
473 if (place
== 20) place
--;
476 zpadlen
= max
- place
;
477 spadlen
= min
- MAX (max
, place
) - (signvalue
? 1 : 0);
478 if (zpadlen
< 0) zpadlen
= 0;
479 if (spadlen
< 0) spadlen
= 0;
480 if (flags
& DP_F_ZERO
) {
481 zpadlen
= MAX(zpadlen
, spadlen
);
484 if (flags
& DP_F_MINUS
)
485 spadlen
= -spadlen
; /* Left Justifty */
487 #ifdef DEBUG_SNPRINTF
488 printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
489 zpadlen
, spadlen
, min
, max
, place
);
493 while (spadlen
> 0) {
494 dopr_outch (buffer
, currlen
, maxlen
, ' ');
500 dopr_outch (buffer
, currlen
, maxlen
, signvalue
);
504 while (zpadlen
> 0) {
505 dopr_outch (buffer
, currlen
, maxlen
, '0');
512 dopr_outch (buffer
, currlen
, maxlen
, convert
[--place
]);
514 /* Left Justified spaces */
515 while (spadlen
< 0) {
516 dopr_outch (buffer
, currlen
, maxlen
, ' ');
521 static LDOUBLE
abs_val(LDOUBLE value
)
523 LDOUBLE result
= value
;
531 static LDOUBLE
POW10(int exp
)
543 static LLONG
ROUND(LDOUBLE value
)
547 intpart
= (LLONG
)value
;
548 value
= value
- intpart
;
549 if (value
>= 0.5) intpart
++;
554 static void fmtfp (char *buffer
, size_t *currlen
, size_t maxlen
,
555 LDOUBLE fvalue
, int min
, int max
, int flags
)
563 int padlen
= 0; /* amount to pad */
572 * AIX manpage says the default is 0, but Solaris says the default
573 * is 6, and sprintf on AIX defaults to 6
578 ufvalue
= abs_val (fvalue
);
583 if (flags
& DP_F_PLUS
) { /* Do a sign (+/i) */
586 if (flags
& DP_F_SPACE
)
592 if (flags
& DP_F_UP
) caps
= 1; /* Should characters be upper case? */
596 if (max
== 0) ufvalue
+= 0.5; /* if max = 0 we must round */
600 * Sorry, we only support 16 digits past the decimal because of our
606 /* We "cheat" by converting the fractional part to integer by
607 * multiplying by a factor of 10
611 modf(temp
, &intpart
);
613 fracpart
= ROUND((POW10(max
)) * (ufvalue
- intpart
));
615 if (fracpart
>= POW10(max
)) {
617 fracpart
-= POW10(max
);
621 /* Convert integer part */
624 modf (intpart
*0.1, &intpart
);
626 index
= (int) ((temp
-intpart
+0.05)* 10.0);
627 /* index = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */
628 /* printf ("%llf, %f, %x\n", temp, intpart, index); */
630 (caps
? "0123456789ABCDEF":"0123456789abcdef")[index
];
631 } while (intpart
&& (iplace
< 311));
632 if (iplace
== 311) iplace
--;
633 iconvert
[iplace
] = 0;
635 /* Convert fractional part */
640 modf (fracpart
*0.1, &fracpart
);
642 index
= (int) ((temp
-fracpart
+0.05)* 10.0);
643 /* index = (int) ((((temp/10) -fracpart) +0.05) *10); */
644 /* printf ("%lf, %lf, %ld\n", temp, fracpart, index); */
646 (caps
? "0123456789ABCDEF":"0123456789abcdef")[index
];
647 } while(fracpart
&& (fplace
< 311));
648 if (fplace
== 311) fplace
--;
650 fconvert
[fplace
] = 0;
652 /* -1 for decimal point, another -1 if we are printing a sign */
653 padlen
= min
- iplace
- max
- 1 - ((signvalue
) ? 1 : 0);
654 zpadlen
= max
- fplace
;
655 if (zpadlen
< 0) zpadlen
= 0;
658 if (flags
& DP_F_MINUS
)
659 padlen
= -padlen
; /* Left Justifty */
661 if ((flags
& DP_F_ZERO
) && (padlen
> 0)) {
663 dopr_outch (buffer
, currlen
, maxlen
, signvalue
);
668 dopr_outch (buffer
, currlen
, maxlen
, '0');
673 dopr_outch (buffer
, currlen
, maxlen
, ' ');
677 dopr_outch (buffer
, currlen
, maxlen
, signvalue
);
680 dopr_outch (buffer
, currlen
, maxlen
, iconvert
[--iplace
]);
682 #ifdef DEBUG_SNPRINTF
683 printf("fmtfp: fplace=%d zpadlen=%d\n", fplace
, zpadlen
);
687 * Decimal point. This should probably use locale to find the correct
691 dopr_outch (buffer
, currlen
, maxlen
, '.');
694 dopr_outch (buffer
, currlen
, maxlen
, fconvert
[--fplace
]);
697 while (zpadlen
> 0) {
698 dopr_outch (buffer
, currlen
, maxlen
, '0');
703 dopr_outch (buffer
, currlen
, maxlen
, ' ');
708 static void dopr_outch(char *buffer
, size_t *currlen
, size_t maxlen
, char c
)
710 if (*currlen
< maxlen
) {
711 buffer
[(*currlen
)] = c
;
716 #if !defined(HAVE_VSNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
717 int vsnprintf (char *str
, size_t count
, const char *fmt
, va_list args
)
719 return dopr(str
, count
, fmt
, args
);
723 #if !defined(HAVE_SNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
724 int snprintf(char *str
,size_t count
,const char *fmt
,...)
730 ret
= vsnprintf(str
, count
, fmt
, ap
);
738 #ifndef HAVE_VASPRINTF
739 int vasprintf(char **ptr
, const char *format
, va_list ap
)
743 ret
= vsnprintf(NULL
, 0, format
, ap
);
744 if (ret
<= 0) return ret
;
746 (*ptr
) = (char *)malloc(ret
+1);
747 if (!*ptr
) return -1;
748 ret
= vsnprintf(*ptr
, ret
+1, format
, ap
);
755 #ifndef HAVE_ASPRINTF
756 int asprintf(char **ptr
, const char *format
, ...)
761 va_start(ap
, format
);
762 ret
= vasprintf(ptr
, format
, ap
);
771 int sprintf(char *str
,const char *fmt
,...);
795 double fp_nums
[] = { 6442452944.1234, -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996,
796 0.9996, 1.996, 4.136, 0};
810 long int_nums
[] = { -1, 134, 91340, 341, 0203, 0};
824 char *str_vals
[] = {"hello", "a", "", "a longer string", NULL
};
829 printf ("Testing snprintf format codes against system sprintf...\n");
831 for (x
= 0; fp_fmt
[x
] ; x
++) {
832 for (y
= 0; fp_nums
[y
] != 0 ; y
++) {
833 int l1
= snprintf(NULL
, 0, fp_fmt
[x
], fp_nums
[y
]);
834 int l2
= snprintf(buf1
, sizeof(buf1
), fp_fmt
[x
], fp_nums
[y
]);
835 sprintf (buf2
, fp_fmt
[x
], fp_nums
[y
]);
836 if (strcmp (buf1
, buf2
)) {
837 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
838 fp_fmt
[x
], buf1
, buf2
);
842 printf("snprintf l1 != l2 (%d %d) %s\n", l1
, l2
, fp_fmt
[x
]);
849 for (x
= 0; int_fmt
[x
] ; x
++) {
850 for (y
= 0; int_nums
[y
] != 0 ; y
++) {
851 int l1
= snprintf(NULL
, 0, int_fmt
[x
], int_nums
[y
]);
852 int l2
= snprintf(buf1
, sizeof(buf1
), int_fmt
[x
], int_nums
[y
]);
853 sprintf (buf2
, int_fmt
[x
], int_nums
[y
]);
854 if (strcmp (buf1
, buf2
)) {
855 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
856 int_fmt
[x
], buf1
, buf2
);
860 printf("snprintf l1 != l2 (%d %d) %s\n", l1
, l2
, int_fmt
[x
]);
867 for (x
= 0; str_fmt
[x
] ; x
++) {
868 for (y
= 0; str_vals
[y
] != 0 ; y
++) {
869 int l1
= snprintf(NULL
, 0, str_fmt
[x
], str_vals
[y
]);
870 int l2
= snprintf(buf1
, sizeof(buf1
), str_fmt
[x
], str_vals
[y
]);
871 sprintf (buf2
, str_fmt
[x
], str_vals
[y
]);
872 if (strcmp (buf1
, buf2
)) {
873 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
874 str_fmt
[x
], buf1
, buf2
);
878 printf("snprintf l1 != l2 (%d %d) %s\n", l1
, l2
, str_fmt
[x
]);
885 printf ("%d tests failed out of %d.\n", fail
, num
);
887 printf("seeing how many digits we support\n");
889 double v0
= 0.12345678901234567890123456789012345678901;
890 for (x
=0; x
<100; x
++) {
891 snprintf(buf1
, sizeof(buf1
), "%1.1f", v0
*pow(10, x
));
892 sprintf(buf2
, "%1.1f", v0
*pow(10, x
));
893 if (strcmp(buf1
, buf2
)) {
894 printf("we seem to support %d digits\n", x
-1);
902 #endif /* SNPRINTF_TEST */