bsd-snprintf.c revision 294328 
1/*
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
6 */
7
8/**************************************************************
9 * Original:
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...
14 *
15 * snprintf() is used instead of sprintf() as it does limit checks
16 * for string length.  This covers a nasty loophole.
17 *
18 * The other functions are there to prevent NULL pointers from
19 * causing nast effects.
20 *
21 * More Recently:
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.
27 *
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.
38 *
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.
42 *
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.
47 *
48 *  Andrew Tridgell (tridge@samba.org) Oct 1998
49 *    fixed handling of %.0f
50 *    added test for HAVE_LONG_DOUBLE
51 *
52 * tridge@samba.org, idra@samba.org, April 2001
53 *    got rid of fcvt code (twas buggy and made testing harder)
54 *    added C99 semantics
55 *
56 * date: 2002/12/19 19:56:31;  author: herb;  state: Exp;  lines: +2 -0
57 * actually print args for %g and %e
58 *
59 * date: 2002/06/03 13:37:52;  author: jmcd;  state: Exp;  lines: +8 -0
60 * Since includes.h isn't included here, VA_COPY has to be defined here.  I don't
61 * see any include file that is guaranteed to be here, so I'm defining it
62 * locally.  Fixes AIX and Solaris builds.
63 *
64 * date: 2002/06/03 03:07:24;  author: tridge;  state: Exp;  lines: +5 -13
65 * put the ifdef for HAVE_VA_COPY in one place rather than in lots of
66 * functions
67 *
68 * date: 2002/05/17 14:51:22;  author: jmcd;  state: Exp;  lines: +21 -4
69 * Fix usage of va_list passed as an arg.  Use __va_copy before using it
70 * when it exists.
71 *
72 * date: 2002/04/16 22:38:04;  author: idra;  state: Exp;  lines: +20 -14
73 * Fix incorrect zpadlen handling in fmtfp.
74 * Thanks to Ollie Oldham <ollie.oldham@metro-optix.com> for spotting it.
75 * few mods to make it easier to compile the tests.
76 * addedd the "Ollie" test to the floating point ones.
77 *
78 * Martin Pool (mbp@samba.org) April 2003
79 *    Remove NO_CONFIG_H so that the test case can be built within a source
80 *    tree with less trouble.
81 *    Remove unnecessary SAFE_FREE() definition.
82 *
83 * Martin Pool (mbp@samba.org) May 2003
84 *    Put in a prototype for dummy_snprintf() to quiet compiler warnings.
85 *
86 *    Move #endif to make sure VA_COPY, LDOUBLE, etc are defined even
87 *    if the C library has some snprintf functions already.
88 *
89 * Damien Miller (djm@mindrot.org) Jan 2007
90 *    Fix integer overflows in return value.
91 *    Make formatting quite a bit faster by inlining dopr_outch()
92 *
93 **************************************************************/
94
95#include "includes.h"
96
97#if defined(BROKEN_SNPRINTF)		/* For those with broken snprintf() */
98# undef HAVE_SNPRINTF
99# undef HAVE_VSNPRINTF
100#endif
101
102#ifndef VA_COPY
103# ifdef HAVE_VA_COPY
104#  define VA_COPY(dest, src) va_copy(dest, src)
105# else
106#  ifdef HAVE___VA_COPY
107#   define VA_COPY(dest, src) __va_copy(dest, src)
108#  else
109#   define VA_COPY(dest, src) (dest) = (src)
110#  endif
111# endif
112#endif
113
114#if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF)
115
116#include <ctype.h>
117#include <stdarg.h>
118#include <stdlib.h>
119#include <string.h>
120#include <limits.h>
121#include <errno.h>
122
123#ifdef HAVE_LONG_DOUBLE
124# define LDOUBLE long double
125#else
126# define LDOUBLE double
127#endif
128
129#ifdef HAVE_LONG_LONG
130# define LLONG long long
131#else
132# define LLONG long
133#endif
134
135/*
136 * dopr(): poor man's version of doprintf
137 */
138
139/* format read states */
140#define DP_S_DEFAULT 0
141#define DP_S_FLAGS   1
142#define DP_S_MIN     2
143#define DP_S_DOT     3
144#define DP_S_MAX     4
145#define DP_S_MOD     5
146#define DP_S_CONV    6
147#define DP_S_DONE    7
148
149/* format flags - Bits */
150#define DP_F_MINUS 	(1 << 0)
151#define DP_F_PLUS  	(1 << 1)
152#define DP_F_SPACE 	(1 << 2)
153#define DP_F_NUM   	(1 << 3)
154#define DP_F_ZERO  	(1 << 4)
155#define DP_F_UP    	(1 << 5)
156#define DP_F_UNSIGNED 	(1 << 6)
157
158/* Conversion Flags */
159#define DP_C_SHORT   1
160#define DP_C_LONG    2
161#define DP_C_LDOUBLE 3
162#define DP_C_LLONG   4
163#define DP_C_SIZE    5
164#define DP_C_INTMAX  6
165
166#define char_to_int(p) ((p)- '0')
167#ifndef MAX
168# define MAX(p,q) (((p) >= (q)) ? (p) : (q))
169#endif
170
171#define DOPR_OUTCH(buf, pos, buflen, thechar) \
172	do { \
173		if (pos + 1 >= INT_MAX) { \
174			errno = ERANGE; \
175			return -1; \
176		} \
177		if (pos < buflen) \
178			buf[pos] = thechar; \
179		(pos)++; \
180	} while (0)
181
182static int dopr(char *buffer, size_t maxlen, const char *format,
183    va_list args_in);
184static int fmtstr(char *buffer, size_t *currlen, size_t maxlen,
185    char *value, int flags, int min, int max);
186static int fmtint(char *buffer, size_t *currlen, size_t maxlen,
187    intmax_t value, int base, int min, int max, int flags);
188static int fmtfp(char *buffer, size_t *currlen, size_t maxlen,
189    LDOUBLE fvalue, int min, int max, int flags);
190
191static int
192dopr(char *buffer, size_t maxlen, const char *format, va_list args_in)
193{
194	char ch;
195	intmax_t value;
196	LDOUBLE fvalue;
197	char *strvalue;
198	int min;
199	int max;
200	int state;
201	int flags;
202	int cflags;
203	size_t currlen;
204	va_list args;
205
206	VA_COPY(args, args_in);
207
208	state = DP_S_DEFAULT;
209	currlen = flags = cflags = min = 0;
210	max = -1;
211	ch = *format++;
212
213	while (state != DP_S_DONE) {
214		if (ch == '\0')
215			state = DP_S_DONE;
216
217		switch(state) {
218		case DP_S_DEFAULT:
219			if (ch == '%')
220				state = DP_S_FLAGS;
221			else
222				DOPR_OUTCH(buffer, currlen, maxlen, ch);
223			ch = *format++;
224			break;
225		case DP_S_FLAGS:
226			switch (ch) {
227			case '-':
228				flags |= DP_F_MINUS;
229				ch = *format++;
230				break;
231			case '+':
232				flags |= DP_F_PLUS;
233				ch = *format++;
234				break;
235			case ' ':
236				flags |= DP_F_SPACE;
237				ch = *format++;
238				break;
239			case '#':
240				flags |= DP_F_NUM;
241				ch = *format++;
242				break;
243			case '0':
244				flags |= DP_F_ZERO;
245				ch = *format++;
246				break;
247			default:
248				state = DP_S_MIN;
249				break;
250			}
251			break;
252		case DP_S_MIN:
253			if (isdigit((unsigned char)ch)) {
254				min = 10*min + char_to_int (ch);
255				ch = *format++;
256			} else if (ch == '*') {
257				min = va_arg (args, int);
258				ch = *format++;
259				state = DP_S_DOT;
260			} else {
261				state = DP_S_DOT;
262			}
263			break;
264		case DP_S_DOT:
265			if (ch == '.') {
266				state = DP_S_MAX;
267				ch = *format++;
268			} else {
269				state = DP_S_MOD;
270			}
271			break;
272		case DP_S_MAX:
273			if (isdigit((unsigned char)ch)) {
274				if (max < 0)
275					max = 0;
276				max = 10*max + char_to_int (ch);
277				ch = *format++;
278			} else if (ch == '*') {
279				max = va_arg (args, int);
280				ch = *format++;
281				state = DP_S_MOD;
282			} else {
283				state = DP_S_MOD;
284			}
285			break;
286		case DP_S_MOD:
287			switch (ch) {
288			case 'h':
289				cflags = DP_C_SHORT;
290				ch = *format++;
291				break;
292			case 'j':
293				cflags = DP_C_INTMAX;
294				ch = *format++;
295				break;
296			case 'l':
297				cflags = DP_C_LONG;
298				ch = *format++;
299				if (ch == 'l') {	/* It's a long long */
300					cflags = DP_C_LLONG;
301					ch = *format++;
302				}
303				break;
304			case 'L':
305				cflags = DP_C_LDOUBLE;
306				ch = *format++;
307				break;
308			case 'z':
309				cflags = DP_C_SIZE;
310				ch = *format++;
311				break;
312			default:
313				break;
314			}
315			state = DP_S_CONV;
316			break;
317		case DP_S_CONV:
318			switch (ch) {
319			case 'd':
320			case 'i':
321				if (cflags == DP_C_SHORT)
322					value = va_arg (args, int);
323				else if (cflags == DP_C_LONG)
324					value = va_arg (args, long int);
325				else if (cflags == DP_C_LLONG)
326					value = va_arg (args, LLONG);
327				else if (cflags == DP_C_SIZE)
328					value = va_arg (args, ssize_t);
329				else if (cflags == DP_C_INTMAX)
330					value = va_arg (args, intmax_t);
331				else
332					value = va_arg (args, int);
333				if (fmtint(buffer, &currlen, maxlen,
334				    value, 10, min, max, flags) == -1)
335					return -1;
336				break;
337			case 'o':
338				flags |= DP_F_UNSIGNED;
339				if (cflags == DP_C_SHORT)
340					value = va_arg (args, unsigned int);
341				else if (cflags == DP_C_LONG)
342					value = (long)va_arg (args, unsigned long int);
343				else if (cflags == DP_C_LLONG)
344					value = (long)va_arg (args, unsigned LLONG);
345				else if (cflags == DP_C_SIZE)
346					value = va_arg (args, size_t);
347#ifdef notyet
348				else if (cflags == DP_C_INTMAX)
349					value = va_arg (args, uintmax_t);
350#endif
351				else
352					value = (long)va_arg (args, unsigned int);
353				if (fmtint(buffer, &currlen, maxlen, value,
354				    8, min, max, flags) == -1)
355					return -1;
356				break;
357			case 'u':
358				flags |= DP_F_UNSIGNED;
359				if (cflags == DP_C_SHORT)
360					value = va_arg (args, unsigned int);
361				else if (cflags == DP_C_LONG)
362					value = (long)va_arg (args, unsigned long int);
363				else if (cflags == DP_C_LLONG)
364					value = (LLONG)va_arg (args, unsigned LLONG);
365				else if (cflags == DP_C_SIZE)
366					value = va_arg (args, size_t);
367#ifdef notyet
368				else if (cflags == DP_C_INTMAX)
369					value = va_arg (args, uintmax_t);
370#endif
371				else
372					value = (long)va_arg (args, unsigned int);
373				if (fmtint(buffer, &currlen, maxlen, value,
374				    10, min, max, flags) == -1)
375					return -1;
376				break;
377			case 'X':
378				flags |= DP_F_UP;
379			case 'x':
380				flags |= DP_F_UNSIGNED;
381				if (cflags == DP_C_SHORT)
382					value = va_arg (args, unsigned int);
383				else if (cflags == DP_C_LONG)
384					value = (long)va_arg (args, unsigned long int);
385				else if (cflags == DP_C_LLONG)
386					value = (LLONG)va_arg (args, unsigned LLONG);
387				else if (cflags == DP_C_SIZE)
388					value = va_arg (args, size_t);
389#ifdef notyet
390				else if (cflags == DP_C_INTMAX)
391					value = va_arg (args, uintmax_t);
392#endif
393				else
394					value = (long)va_arg (args, unsigned int);
395				if (fmtint(buffer, &currlen, maxlen, value,
396				    16, min, max, flags) == -1)
397					return -1;
398				break;
399			case 'f':
400				if (cflags == DP_C_LDOUBLE)
401					fvalue = va_arg (args, LDOUBLE);
402				else
403					fvalue = va_arg (args, double);
404				if (fmtfp(buffer, &currlen, maxlen, fvalue,
405				    min, max, flags) == -1)
406					return -1;
407				break;
408			case 'E':
409				flags |= DP_F_UP;
410			case 'e':
411				if (cflags == DP_C_LDOUBLE)
412					fvalue = va_arg (args, LDOUBLE);
413				else
414					fvalue = va_arg (args, double);
415				if (fmtfp(buffer, &currlen, maxlen, fvalue,
416				    min, max, flags) == -1)
417					return -1;
418				break;
419			case 'G':
420				flags |= DP_F_UP;
421			case 'g':
422				if (cflags == DP_C_LDOUBLE)
423					fvalue = va_arg (args, LDOUBLE);
424				else
425					fvalue = va_arg (args, double);
426				if (fmtfp(buffer, &currlen, maxlen, fvalue,
427				    min, max, flags) == -1)
428					return -1;
429				break;
430			case 'c':
431				DOPR_OUTCH(buffer, currlen, maxlen,
432				    va_arg (args, int));
433				break;
434			case 's':
435				strvalue = va_arg (args, char *);
436				if (!strvalue) strvalue = "(NULL)";
437				if (max == -1) {
438					max = strlen(strvalue);
439				}
440				if (min > 0 && max >= 0 && min > max) max = min;
441				if (fmtstr(buffer, &currlen, maxlen,
442				    strvalue, flags, min, max) == -1)
443					return -1;
444				break;
445			case 'p':
446				strvalue = va_arg (args, void *);
447				if (fmtint(buffer, &currlen, maxlen,
448				    (long) strvalue, 16, min, max, flags) == -1)
449					return -1;
450				break;
451#if we_dont_want_this_in_openssh
452			case 'n':
453				if (cflags == DP_C_SHORT) {
454					short int *num;
455					num = va_arg (args, short int *);
456					*num = currlen;
457				} else if (cflags == DP_C_LONG) {
458					long int *num;
459					num = va_arg (args, long int *);
460					*num = (long int)currlen;
461				} else if (cflags == DP_C_LLONG) {
462					LLONG *num;
463					num = va_arg (args, LLONG *);
464					*num = (LLONG)currlen;
465				} else if (cflags == DP_C_SIZE) {
466					ssize_t *num;
467					num = va_arg (args, ssize_t *);
468					*num = (ssize_t)currlen;
469				} else if (cflags == DP_C_INTMAX) {
470					intmax_t *num;
471					num = va_arg (args, intmax_t *);
472					*num = (intmax_t)currlen;
473				} else {
474					int *num;
475					num = va_arg (args, int *);
476					*num = currlen;
477				}
478				break;
479#endif
480			case '%':
481				DOPR_OUTCH(buffer, currlen, maxlen, ch);
482				break;
483			case 'w':
484				/* not supported yet, treat as next char */
485				ch = *format++;
486				break;
487			default:
488				/* Unknown, skip */
489				break;
490			}
491			ch = *format++;
492			state = DP_S_DEFAULT;
493			flags = cflags = min = 0;
494			max = -1;
495			break;
496		case DP_S_DONE:
497			break;
498		default:
499			/* hmm? */
500			break; /* some picky compilers need this */
501		}
502	}
503	if (maxlen != 0) {
504		if (currlen < maxlen - 1)
505			buffer[currlen] = '\0';
506		else if (maxlen > 0)
507			buffer[maxlen - 1] = '\0';
508	}
509
510	return currlen < INT_MAX ? (int)currlen : -1;
511}
512
513static int
514fmtstr(char *buffer, size_t *currlen, size_t maxlen,
515    char *value, int flags, int min, int max)
516{
517	int padlen, strln;     /* amount to pad */
518	int cnt = 0;
519
520#ifdef DEBUG_SNPRINTF
521	printf("fmtstr min=%d max=%d s=[%s]\n", min, max, value);
522#endif
523	if (value == 0) {
524		value = "<NULL>";
525	}
526
527	for (strln = 0; strln < max && value[strln]; ++strln); /* strlen */
528	padlen = min - strln;
529	if (padlen < 0)
530		padlen = 0;
531	if (flags & DP_F_MINUS)
532		padlen = -padlen; /* Left Justify */
533
534	while ((padlen > 0) && (cnt < max)) {
535		DOPR_OUTCH(buffer, *currlen, maxlen, ' ');
536		--padlen;
537		++cnt;
538	}
539	while (*value && (cnt < max)) {
540		DOPR_OUTCH(buffer, *currlen, maxlen, *value);
541		value++;
542		++cnt;
543	}
544	while ((padlen < 0) && (cnt < max)) {
545		DOPR_OUTCH(buffer, *currlen, maxlen, ' ');
546		++padlen;
547		++cnt;
548	}
549	return 0;
550}
551
552/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
553
554static int
555fmtint(char *buffer, size_t *currlen, size_t maxlen,
556    intmax_t value, int base, int min, int max, int flags)
557{
558	int signvalue = 0;
559	unsigned LLONG uvalue;
560	char convert[20];
561	int place = 0;
562	int spadlen = 0; /* amount to space pad */
563	int zpadlen = 0; /* amount to zero pad */
564	int caps = 0;
565
566	if (max < 0)
567		max = 0;
568
569	uvalue = value;
570
571	if(!(flags & DP_F_UNSIGNED)) {
572		if( value < 0 ) {
573			signvalue = '-';
574			uvalue = -value;
575		} else {
576			if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
577				signvalue = '+';
578			else if (flags & DP_F_SPACE)
579				signvalue = ' ';
580		}
581	}
582
583	if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
584
585	do {
586		convert[place++] =
587			(caps? "0123456789ABCDEF":"0123456789abcdef")
588			[uvalue % (unsigned)base  ];
589		uvalue = (uvalue / (unsigned)base );
590	} while(uvalue && (place < 20));
591	if (place == 20) place--;
592	convert[place] = 0;
593
594	zpadlen = max - place;
595	spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
596	if (zpadlen < 0) zpadlen = 0;
597	if (spadlen < 0) spadlen = 0;
598	if (flags & DP_F_ZERO) {
599		zpadlen = MAX(zpadlen, spadlen);
600		spadlen = 0;
601	}
602	if (flags & DP_F_MINUS)
603		spadlen = -spadlen; /* Left Justifty */
604
605#ifdef DEBUG_SNPRINTF
606	printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
607	       zpadlen, spadlen, min, max, place);
608#endif
609
610	/* Spaces */
611	while (spadlen > 0) {
612		DOPR_OUTCH(buffer, *currlen, maxlen, ' ');
613		--spadlen;
614	}
615
616	/* Sign */
617	if (signvalue)
618		DOPR_OUTCH(buffer, *currlen, maxlen, signvalue);
619
620	/* Zeros */
621	if (zpadlen > 0) {
622		while (zpadlen > 0) {
623			DOPR_OUTCH(buffer, *currlen, maxlen, '0');
624			--zpadlen;
625		}
626	}
627
628	/* Digits */
629	while (place > 0) {
630		--place;
631		DOPR_OUTCH(buffer, *currlen, maxlen, convert[place]);
632	}
633
634	/* Left Justified spaces */
635	while (spadlen < 0) {
636		DOPR_OUTCH(buffer, *currlen, maxlen, ' ');
637		++spadlen;
638	}
639	return 0;
640}
641
642static LDOUBLE abs_val(LDOUBLE value)
643{
644	LDOUBLE result = value;
645
646	if (value < 0)
647		result = -value;
648
649	return result;
650}
651
652static LDOUBLE POW10(int val)
653{
654	LDOUBLE result = 1;
655
656	while (val) {
657		result *= 10;
658		val--;
659	}
660
661	return result;
662}
663
664static LLONG ROUND(LDOUBLE value)
665{
666	LLONG intpart;
667
668	intpart = (LLONG)value;
669	value = value - intpart;
670	if (value >= 0.5) intpart++;
671
672	return intpart;
673}
674
675/* a replacement for modf that doesn't need the math library. Should
676   be portable, but slow */
677static double my_modf(double x0, double *iptr)
678{
679	int i;
680	long l;
681	double x = x0;
682	double f = 1.0;
683
684	for (i=0;i<100;i++) {
685		l = (long)x;
686		if (l <= (x+1) && l >= (x-1)) break;
687		x *= 0.1;
688		f *= 10.0;
689	}
690
691	if (i == 100) {
692		/*
693		 * yikes! the number is beyond what we can handle.
694		 * What do we do?
695		 */
696		(*iptr) = 0;
697		return 0;
698	}
699
700	if (i != 0) {
701		double i2;
702		double ret;
703
704		ret = my_modf(x0-l*f, &i2);
705		(*iptr) = l*f + i2;
706		return ret;
707	}
708
709	(*iptr) = l;
710	return x - (*iptr);
711}
712
713
714static int
715fmtfp (char *buffer, size_t *currlen, size_t maxlen,
716    LDOUBLE fvalue, int min, int max, int flags)
717{
718	int signvalue = 0;
719	double ufvalue;
720	char iconvert[311];
721	char fconvert[311];
722	int iplace = 0;
723	int fplace = 0;
724	int padlen = 0; /* amount to pad */
725	int zpadlen = 0;
726	int caps = 0;
727	int idx;
728	double intpart;
729	double fracpart;
730	double temp;
731
732	/*
733	 * AIX manpage says the default is 0, but Solaris says the default
734	 * is 6, and sprintf on AIX defaults to 6
735	 */
736	if (max < 0)
737		max = 6;
738
739	ufvalue = abs_val (fvalue);
740
741	if (fvalue < 0) {
742		signvalue = '-';
743	} else {
744		if (flags & DP_F_PLUS) { /* Do a sign (+/i) */
745			signvalue = '+';
746		} else {
747			if (flags & DP_F_SPACE)
748				signvalue = ' ';
749		}
750	}
751
752#if 0
753	if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
754#endif
755
756#if 0
757	 if (max == 0) ufvalue += 0.5; /* if max = 0 we must round */
758#endif
759
760	/*
761	 * Sorry, we only support 16 digits past the decimal because of our
762	 * conversion method
763	 */
764	if (max > 16)
765		max = 16;
766
767	/* We "cheat" by converting the fractional part to integer by
768	 * multiplying by a factor of 10
769	 */
770
771	temp = ufvalue;
772	my_modf(temp, &intpart);
773
774	fracpart = ROUND((POW10(max)) * (ufvalue - intpart));
775
776	if (fracpart >= POW10(max)) {
777		intpart++;
778		fracpart -= POW10(max);
779	}
780
781	/* Convert integer part */
782	do {
783		temp = intpart*0.1;
784		my_modf(temp, &intpart);
785		idx = (int) ((temp -intpart +0.05)* 10.0);
786		/* idx = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */
787		/* printf ("%llf, %f, %x\n", temp, intpart, idx); */
788		iconvert[iplace++] =
789			(caps? "0123456789ABCDEF":"0123456789abcdef")[idx];
790	} while (intpart && (iplace < 311));
791	if (iplace == 311) iplace--;
792	iconvert[iplace] = 0;
793
794	/* Convert fractional part */
795	if (fracpart)
796	{
797		do {
798			temp = fracpart*0.1;
799			my_modf(temp, &fracpart);
800			idx = (int) ((temp -fracpart +0.05)* 10.0);
801			/* idx = (int) ((((temp/10) -fracpart) +0.05) *10); */
802			/* printf ("%lf, %lf, %ld\n", temp, fracpart, idx ); */
803			fconvert[fplace++] =
804			(caps? "0123456789ABCDEF":"0123456789abcdef")[idx];
805		} while(fracpart && (fplace < 311));
806		if (fplace == 311) fplace--;
807	}
808	fconvert[fplace] = 0;
809
810	/* -1 for decimal point, another -1 if we are printing a sign */
811	padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
812	zpadlen = max - fplace;
813	if (zpadlen < 0) zpadlen = 0;
814	if (padlen < 0)
815		padlen = 0;
816	if (flags & DP_F_MINUS)
817		padlen = -padlen; /* Left Justifty */
818
819	if ((flags & DP_F_ZERO) && (padlen > 0)) {
820		if (signvalue) {
821			DOPR_OUTCH(buffer, *currlen, maxlen, signvalue);
822			--padlen;
823			signvalue = 0;
824		}
825		while (padlen > 0) {
826			DOPR_OUTCH(buffer, *currlen, maxlen, '0');
827			--padlen;
828		}
829	}
830	while (padlen > 0) {
831		DOPR_OUTCH(buffer, *currlen, maxlen, ' ');
832		--padlen;
833	}
834	if (signvalue)
835		DOPR_OUTCH(buffer, *currlen, maxlen, signvalue);
836
837	while (iplace > 0) {
838		--iplace;
839		DOPR_OUTCH(buffer, *currlen, maxlen, iconvert[iplace]);
840	}
841
842#ifdef DEBUG_SNPRINTF
843	printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
844#endif
845
846	/*
847	 * Decimal point.  This should probably use locale to find the correct
848	 * char to print out.
849	 */
850	if (max > 0) {
851		DOPR_OUTCH(buffer, *currlen, maxlen, '.');
852
853		while (zpadlen > 0) {
854			DOPR_OUTCH(buffer, *currlen, maxlen, '0');
855			--zpadlen;
856		}
857
858		while (fplace > 0) {
859			--fplace;
860			DOPR_OUTCH(buffer, *currlen, maxlen, fconvert[fplace]);
861		}
862	}
863
864	while (padlen < 0) {
865		DOPR_OUTCH(buffer, *currlen, maxlen, ' ');
866		++padlen;
867	}
868	return 0;
869}
870#endif /* !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) */
871
872#if !defined(HAVE_VSNPRINTF)
873int
874vsnprintf (char *str, size_t count, const char *fmt, va_list args)
875{
876	return dopr(str, count, fmt, args);
877}
878#endif
879
880#if !defined(HAVE_SNPRINTF)
881int
882snprintf(char *str, size_t count, SNPRINTF_CONST char *fmt, ...)
883{
884	size_t ret;
885	va_list ap;
886
887	va_start(ap, fmt);
888	ret = vsnprintf(str, count, fmt, ap);
889	va_end(ap);
890	return ret;
891}
892#endif
893