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>
78 #if defined(HAVE_SNPRINTF) && defined(HAVE_VSNPRINTF) && defined(HAVE_C99_VSNPRINTF)
79 /* only include stdio.h if we are not re-defining snprintf or vsnprintf */
81 /* make the compiler happy with an empty file */
82 void dummy_snprintf(void)
87 #ifdef HAVE_LONG_DOUBLE
88 #define LDOUBLE long double
90 #define LDOUBLE double
94 #define LLONG long long
99 static size_t dopr(char *buffer
, size_t maxlen
, const char *format
, va_list args
);
100 static void fmtstr(char *buffer
, size_t * currlen
, size_t maxlen
, char *value
, int flags
, int min
, int max
);
101 static void fmtint(char *buffer
, size_t * currlen
, size_t maxlen
,
102 long value
, int base
, int min
, int max
, int flags
);
103 static void fmtfp(char *buffer
, size_t * currlen
, size_t maxlen
, LDOUBLE fvalue
, int min
, int max
, int flags
);
104 static void dopr_outch(char *buffer
, size_t * currlen
, size_t maxlen
, char c
);
107 * dopr(): poor man's version of doprintf
110 /* format read states */
111 #define DP_S_DEFAULT 0
120 /* format flags - Bits */
121 #define DP_F_MINUS (1 << 0)
122 #define DP_F_PLUS (1 << 1)
123 #define DP_F_SPACE (1 << 2)
124 #define DP_F_NUM (1 << 3)
125 #define DP_F_ZERO (1 << 4)
126 #define DP_F_UP (1 << 5)
127 #define DP_F_UNSIGNED (1 << 6)
129 /* Conversion Flags */
132 #define DP_C_LDOUBLE 3
135 #define char_to_int(p) ((p)- '0')
137 #define MAX(p,q) (((p) >= (q)) ? (p) : (q))
140 static size_t dopr(char *buffer
, size_t maxlen
, const char *format
, va_list args
)
153 state
= DP_S_DEFAULT
;
154 currlen
= flags
= cflags
= min
= 0;
158 while (state
!= DP_S_DONE
) {
167 dopr_outch(buffer
, &currlen
, maxlen
, ch
);
198 if (isdigit((unsigned char)ch
)) {
199 min
= 10 * min
+ char_to_int(ch
);
201 } else if (ch
== '*') {
202 min
= va_arg(args
, int);
218 if (isdigit((unsigned char)ch
)) {
221 max
= 10 * max
+ char_to_int(ch
);
223 } else if (ch
== '*') {
224 max
= va_arg(args
, int);
240 if (ch
== 'l') { /* It's a long long */
246 cflags
= DP_C_LDOUBLE
;
258 if (cflags
== DP_C_SHORT
)
259 value
= va_arg(args
, int);
260 else if (cflags
== DP_C_LONG
)
261 value
= va_arg(args
, long int);
262 else if (cflags
== DP_C_LLONG
)
263 value
= va_arg(args
, LLONG
);
265 value
= va_arg(args
, int);
266 fmtint(buffer
, &currlen
, maxlen
, value
, 10, min
, max
, flags
);
269 flags
|= DP_F_UNSIGNED
;
270 if (cflags
== DP_C_SHORT
)
271 value
= va_arg(args
, unsigned int);
272 else if (cflags
== DP_C_LONG
)
273 value
= (long)va_arg(args
, unsigned long int);
274 else if (cflags
== DP_C_LLONG
)
275 value
= (long)va_arg(args
, unsigned LLONG
);
277 value
= (long)va_arg(args
, unsigned int);
278 fmtint(buffer
, &currlen
, maxlen
, value
, 8, min
, max
, flags
);
281 flags
|= DP_F_UNSIGNED
;
282 if (cflags
== DP_C_SHORT
)
283 value
= va_arg(args
, unsigned int);
284 else if (cflags
== DP_C_LONG
)
285 value
= (long)va_arg(args
, unsigned long int);
286 else if (cflags
== DP_C_LLONG
)
287 value
= (LLONG
) va_arg(args
, unsigned LLONG
);
289 value
= (long)va_arg(args
, unsigned int);
290 fmtint(buffer
, &currlen
, maxlen
, value
, 10, min
, max
, flags
);
295 flags
|= DP_F_UNSIGNED
;
296 if (cflags
== DP_C_SHORT
)
297 value
= va_arg(args
, unsigned int);
298 else if (cflags
== DP_C_LONG
)
299 value
= (long)va_arg(args
, unsigned long int);
300 else if (cflags
== DP_C_LLONG
)
301 value
= (LLONG
) va_arg(args
, unsigned LLONG
);
303 value
= (long)va_arg(args
, unsigned int);
304 fmtint(buffer
, &currlen
, maxlen
, value
, 16, min
, max
, flags
);
307 if (cflags
== DP_C_LDOUBLE
)
308 fvalue
= va_arg(args
, LDOUBLE
);
310 fvalue
= va_arg(args
, double);
311 /* um, floating point? */
312 fmtfp(buffer
, &currlen
, maxlen
, fvalue
, min
, max
, flags
);
317 if (cflags
== DP_C_LDOUBLE
)
318 fvalue
= va_arg(args
, LDOUBLE
);
320 fvalue
= va_arg(args
, double);
325 if (cflags
== DP_C_LDOUBLE
)
326 fvalue
= va_arg(args
, LDOUBLE
);
328 fvalue
= va_arg(args
, double);
331 dopr_outch(buffer
, &currlen
, maxlen
, va_arg(args
, int));
334 strvalue
= va_arg(args
, char *);
336 max
= strlen(strvalue
);
338 if (min
> 0 && max
>= 0 && min
> max
)
340 fmtstr(buffer
, &currlen
, maxlen
, strvalue
, flags
, min
, max
);
343 strvalue
= va_arg(args
, void *);
344 fmtint(buffer
, &currlen
, maxlen
, (long)strvalue
, 16, min
, max
, flags
);
347 if (cflags
== DP_C_SHORT
) {
349 num
= va_arg(args
, short int *);
351 } else if (cflags
== DP_C_LONG
) {
353 num
= va_arg(args
, long int *);
354 *num
= (long int)currlen
;
355 } else if (cflags
== DP_C_LLONG
) {
357 num
= va_arg(args
, LLONG
*);
358 *num
= (LLONG
) currlen
;
361 num
= va_arg(args
, int *);
366 dopr_outch(buffer
, &currlen
, maxlen
, ch
);
369 /* not supported yet, treat as next char */
377 state
= DP_S_DEFAULT
;
378 flags
= cflags
= min
= 0;
385 break; /* some picky compilers need this */
389 if (currlen
< maxlen
- 1)
390 buffer
[currlen
] = '\0';
392 buffer
[maxlen
- 1] = '\0';
398 static void fmtstr(char *buffer
, size_t * currlen
, size_t maxlen
, char *value
, int flags
, int min
, int max
)
400 int padlen
, strln
; /* amount to pad */
403 #ifdef DEBUG_SNPRINTF
404 printf("fmtstr min=%d max=%d s=[%s]\n", min
, max
, value
);
410 for (strln
= 0; value
[strln
]; ++strln
) ; /* strlen */
411 padlen
= min
- strln
;
414 if (flags
& DP_F_MINUS
)
415 padlen
= -padlen
; /* Left Justify */
417 while ((padlen
> 0) && (cnt
< max
)) {
418 dopr_outch(buffer
, currlen
, maxlen
, ' ');
422 while (*value
&& (cnt
< max
)) {
423 dopr_outch(buffer
, currlen
, maxlen
, *value
++);
426 while ((padlen
< 0) && (cnt
< max
)) {
427 dopr_outch(buffer
, currlen
, maxlen
, ' ');
433 /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
435 static void fmtint(char *buffer
, size_t * currlen
, size_t maxlen
,
436 long value
, int base
, int min
, int max
, int flags
)
439 unsigned long uvalue
;
442 int spadlen
= 0; /* amount to space pad */
443 int zpadlen
= 0; /* amount to zero pad */
451 if (!(flags
& DP_F_UNSIGNED
)) {
456 if (flags
& DP_F_PLUS
) /* Do a sign (+/i) */
458 else if (flags
& DP_F_SPACE
)
464 caps
= 1; /* Should characters be upper case? */
467 convert
[place
++] = (caps
? "0123456789ABCDEF" : "0123456789abcdef")
468 [uvalue
% (unsigned)base
];
469 uvalue
= (uvalue
/ (unsigned)base
);
470 } while (uvalue
&& (place
< 20));
475 zpadlen
= max
- place
;
476 spadlen
= min
- MAX(max
, place
) - (signvalue
? 1 : 0);
481 if (flags
& DP_F_ZERO
) {
482 zpadlen
= MAX(zpadlen
, spadlen
);
485 if (flags
& DP_F_MINUS
)
486 spadlen
= -spadlen
; /* Left Justifty */
488 #ifdef DEBUG_SNPRINTF
489 printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n", 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
;
555 /* a replacement for modf that doesn't need the math library. Should
556 be portable, but slow */
557 static double my_modf(double x0
, double *iptr
)
564 for (i
= 0; i
< 100; i
++) {
566 if (l
<= (x
+ 1) && l
>= (x
- 1))
573 /* yikes! the number is beyond what we can handle. What do we do? */
582 ret
= my_modf(x0
- l
* f
, &i2
);
583 (*iptr
) = l
* f
+ i2
;
591 static void fmtfp(char *buffer
, size_t * currlen
, size_t maxlen
, LDOUBLE fvalue
, int min
, int max
, int flags
)
599 int padlen
= 0; /* amount to pad */
608 * AIX manpage says the default is 0, but Solaris says the default
609 * is 6, and sprintf on AIX defaults to 6
614 ufvalue
= abs_val(fvalue
);
619 if (flags
& DP_F_PLUS
) { /* Do a sign (+/i) */
622 if (flags
& DP_F_SPACE
)
629 caps
= 1; /* Should characters be upper case? */
634 ufvalue
+= 0.5; /* if max = 0 we must round */
638 * Sorry, we only support 16 digits past the decimal because of our
644 /* We "cheat" by converting the fractional part to integer by
645 * multiplying by a factor of 10
649 my_modf(temp
, &intpart
);
651 fracpart
= ROUND((POW10(max
)) * (ufvalue
- intpart
));
653 if (fracpart
>= POW10(max
)) {
655 fracpart
-= POW10(max
);
658 /* Convert integer part */
661 my_modf(intpart
* 0.1, &intpart
);
663 index
= (int)((temp
- intpart
+ 0.05) * 10.0);
664 /* index = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */
665 /* printf ("%llf, %f, %x\n", temp, intpart, index); */
666 iconvert
[iplace
++] = (caps
? "0123456789ABCDEF" : "0123456789abcdef")[index
];
667 } while (intpart
&& (iplace
< 311));
670 iconvert
[iplace
] = 0;
672 /* Convert fractional part */
676 my_modf(fracpart
* 0.1, &fracpart
);
678 index
= (int)((temp
- fracpart
+ 0.05) * 10.0);
679 /* index = (int) ((((temp/10) -fracpart) +0.05) *10); */
680 /* printf ("%lf, %lf, %ld\n", temp, fracpart, index); */
681 fconvert
[fplace
++] = (caps
? "0123456789ABCDEF" : "0123456789abcdef")[index
];
682 } while (fracpart
&& (fplace
< 311));
686 fconvert
[fplace
] = 0;
688 /* -1 for decimal point, another -1 if we are printing a sign */
689 padlen
= min
- iplace
- max
- 1 - ((signvalue
) ? 1 : 0);
690 zpadlen
= max
- fplace
;
695 if (flags
& DP_F_MINUS
)
696 padlen
= -padlen
; /* Left Justifty */
698 if ((flags
& DP_F_ZERO
) && (padlen
> 0)) {
700 dopr_outch(buffer
, currlen
, maxlen
, signvalue
);
705 dopr_outch(buffer
, currlen
, maxlen
, '0');
710 dopr_outch(buffer
, currlen
, maxlen
, ' ');
714 dopr_outch(buffer
, currlen
, maxlen
, signvalue
);
717 dopr_outch(buffer
, currlen
, maxlen
, iconvert
[--iplace
]);
719 #ifdef DEBUG_SNPRINTF
720 printf("fmtfp: fplace=%d zpadlen=%d\n", fplace
, zpadlen
);
724 * Decimal point. This should probably use locale to find the correct
728 dopr_outch(buffer
, currlen
, maxlen
, '.');
731 dopr_outch(buffer
, currlen
, maxlen
, fconvert
[--fplace
]);
734 while (zpadlen
> 0) {
735 dopr_outch(buffer
, currlen
, maxlen
, '0');
740 dopr_outch(buffer
, currlen
, maxlen
, ' ');
745 static void dopr_outch(char *buffer
, size_t * currlen
, size_t maxlen
, char c
)
747 if (*currlen
< maxlen
) {
748 buffer
[(*currlen
)] = c
;
753 #if !defined(HAVE_VSNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
754 int vsnprintf(char *str
, size_t count
, const char *fmt
, va_list args
)
756 return dopr(str
, count
, fmt
, args
);
760 #if !defined(HAVE_SNPRINTF) || !defined(HAVE_C99_VSNPRINTF)
761 int snprintf(char *str
, size_t count
, const char *fmt
, ...)
767 ret
= vsnprintf(str
, count
, fmt
, ap
);
775 #ifndef HAVE_VASPRINTF
776 int vasprintf(char **ptr
, const char *format
, va_list ap
)
780 ret
= vsnprintf(NULL
, 0, format
, ap
);
784 (*ptr
) = (char *)malloc(ret
+ 1);
787 ret
= vsnprintf(*ptr
, ret
+ 1, format
, ap
);
793 #ifndef HAVE_ASPRINTF
794 int asprintf(char **ptr
, const char *format
, ...)
799 va_start(ap
, format
);
800 ret
= vasprintf(ptr
, format
, ap
);
809 int sprintf(char *str
, const char *fmt
, ...);
833 double fp_nums
[] = { 6442452944.1234, -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996,
834 0.9996, 1.996, 4.136, 0
849 long int_nums
[] = { -1, 134, 91340, 341, 0203, 0 };
863 char *str_vals
[] = { "hello", "a", "", "a longer string", NULL
};
868 printf("Testing snprintf format codes against system sprintf...\n");
870 for (x
= 0; fp_fmt
[x
]; x
++) {
871 for (y
= 0; fp_nums
[y
] != 0; y
++) {
872 int l1
= snprintf(NULL
, 0, fp_fmt
[x
], fp_nums
[y
]);
873 int l2
= snprintf(buf1
, sizeof(buf1
), fp_fmt
[x
], fp_nums
[y
]);
874 sprintf(buf2
, fp_fmt
[x
], fp_nums
[y
]);
875 if (strcmp(buf1
, buf2
)) {
876 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
877 fp_fmt
[x
], buf1
, buf2
);
881 printf("snprintf l1 != l2 (%d %d) %s\n", l1
, l2
, fp_fmt
[x
]);
888 for (x
= 0; int_fmt
[x
]; x
++) {
889 for (y
= 0; int_nums
[y
] != 0; y
++) {
890 int l1
= snprintf(NULL
, 0, int_fmt
[x
], int_nums
[y
]);
891 int l2
= snprintf(buf1
, sizeof(buf1
), int_fmt
[x
], int_nums
[y
]);
892 sprintf(buf2
, int_fmt
[x
], int_nums
[y
]);
893 if (strcmp(buf1
, buf2
)) {
894 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
895 int_fmt
[x
], buf1
, buf2
);
899 printf("snprintf l1 != l2 (%d %d) %s\n", l1
, l2
, int_fmt
[x
]);
906 for (x
= 0; str_fmt
[x
]; x
++) {
907 for (y
= 0; str_vals
[y
] != 0; y
++) {
908 int l1
= snprintf(NULL
, 0, str_fmt
[x
], str_vals
[y
]);
909 int l2
= snprintf(buf1
, sizeof(buf1
), str_fmt
[x
], str_vals
[y
]);
910 sprintf(buf2
, str_fmt
[x
], str_vals
[y
]);
911 if (strcmp(buf1
, buf2
)) {
912 printf("snprintf doesn't match Format: %s\n\tsnprintf = [%s]\n\t sprintf = [%s]\n",
913 str_fmt
[x
], buf1
, buf2
);
917 printf("snprintf l1 != l2 (%d %d) %s\n", l1
, l2
, str_fmt
[x
]);
924 printf("%d tests failed out of %d.\n", fail
, num
);
926 printf("seeing how many digits we support\n");
928 double v0
= 0.12345678901234567890123456789012345678901;
929 for (x
= 0; x
< 100; x
++) {
930 snprintf(buf1
, sizeof(buf1
), "%1.1f", v0
* pow(10, x
));
931 sprintf(buf2
, "%1.1f", v0
* pow(10, x
));
932 if (strcmp(buf1
, buf2
)) {
933 printf("we seem to support %d digits\n", x
- 1);
941 #endif /* SNPRINTF_TEST */