/[pearpc]/src/tools/snprintf.cc
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Contents of /src/tools/snprintf.cc

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1 - (show annotations)
Wed Sep 5 17:11:21 2007 UTC (11 years, 10 months ago) by dpavlin
File size: 23993 byte(s)
import upstream CVS
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 * HT authors
57 * * ht_snprintf/ht_vsnprintf return number of characters actually
58 * written instead of the number of characters that would
59 * have been written.
60 * * added '%y' to allow object output using Object's toString() method.
61 * * added '%q[dioux]' for formatting qwords.
62 * * added '%b' for formatting in binary notation.
63 **************************************************************/
64
65 #include <cctype>
66 #include <cstring>
67 #include <cstdlib>
68 #include <cstdio>
69 #include <cstdarg>
70 #include <sys/types.h>
71
72 #ifdef HAVE_CONFIG_H
73 #include "config.h"
74 #endif
75
76 #include "system/types.h"
77 #include "data.h"
78
79 #ifdef HAVE_CONFIG_H
80 #include "config.h"
81 #endif
82
83 #ifndef MIN
84 #define MIN(a, b) ((a) < (b) ? (a) : (b))
85 #endif
86 #ifndef MAX
87 #define MAX(a, b) ((a) > (b) ? (a) : (b))
88 #endif
89
90 #ifdef HAVE_LONG_DOUBLE
91 #define LDOUBLE long double
92 #else
93 #define LDOUBLE double
94 #endif
95
96 #ifdef HAVE_LONG_LONG
97 #define LLONG long long
98 #else
99 #define LLONG long
100 #endif
101
102 static size_t dopr(char *buffer, size_t maxlen, const char *format,
103 va_list args);
104 static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
105 char *value, int flags, int min, int max);
106 static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
107 long value, int base, int min, int max, int flags);
108 static void fmtqword(char *buffer, size_t *currlen, size_t maxlen,
109 sint64 value, int base, int min, int max, int flags);
110 static void fmtfp(char *buffer, size_t *currlen, size_t maxlen,
111 LDOUBLE fvalue, int min, int max, int flags);
112 static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c);
113
114 /*
115 * dopr(): poor man's version of doprintf
116 */
117
118 /* format read states */
119 #define DP_S_DEFAULT 0
120 #define DP_S_FLAGS 1
121 #define DP_S_MIN 2
122 #define DP_S_DOT 3
123 #define DP_S_MAX 4
124 #define DP_S_MOD 5
125 #define DP_S_CONV 6
126 #define DP_S_DONE 7
127
128 /* format flags - Bits */
129 #define DP_F_MINUS (1 << 0)
130 #define DP_F_PLUS (1 << 1)
131 #define DP_F_SPACE (1 << 2)
132 #define DP_F_NUM (1 << 3)
133 #define DP_F_ZERO (1 << 4)
134 #define DP_F_UP (1 << 5)
135 #define DP_F_UNSIGNED (1 << 6)
136
137 /* Conversion Flags */
138 #define DP_C_SHORT 1
139 #define DP_C_LONG 2
140 #define DP_C_LDOUBLE 3
141 #define DP_C_LLONG 4
142 #define DP_C_QWORD 5
143
144 #define char_to_int(p) ((p)- '0')
145 #ifndef MAX
146 #define MAX(p,q) (((p) >= (q)) ? (p) : (q))
147 #endif
148
149 static size_t dopr(char *buffer, size_t maxlen, const char *format, va_list args)
150 {
151 char ch;
152 LLONG value;
153 LDOUBLE fvalue;
154 char *strvalue;
155 int min;
156 int max;
157 int state;
158 int flags;
159 int cflags;
160 size_t currlen;
161
162 state = DP_S_DEFAULT;
163 currlen = flags = cflags = min = 0;
164 max = -1;
165 ch = *format++;
166
167 while (state != DP_S_DONE) {
168 if (ch == '\0') state = DP_S_DONE;
169
170 switch(state) {
171 case DP_S_DEFAULT:
172 if (ch == '%') {
173 state = DP_S_FLAGS;
174 } else {
175 dopr_outch(buffer, &currlen, maxlen, ch);
176 }
177 ch = *format++;
178 break;
179 case DP_S_FLAGS:
180 switch (ch) {
181 case '-':
182 flags |= DP_F_MINUS;
183 ch = *format++;
184 break;
185 case '+':
186 flags |= DP_F_PLUS;
187 ch = *format++;
188 break;
189 case ' ':
190 flags |= DP_F_SPACE;
191 ch = *format++;
192 break;
193 case '#':
194 flags |= DP_F_NUM;
195 ch = *format++;
196 break;
197 case '0':
198 flags |= DP_F_ZERO;
199 ch = *format++;
200 break;
201 default:
202 state = DP_S_MIN;
203 break;
204 }
205 break;
206 case DP_S_MIN:
207 if (isdigit((unsigned char)ch)) {
208 min = 10*min + char_to_int (ch);
209 ch = *format++;
210 } else if (ch == '*') {
211 min = va_arg (args, int);
212 ch = *format++;
213 state = DP_S_DOT;
214 } else {
215 state = DP_S_DOT;
216 }
217 break;
218 case DP_S_DOT:
219 if (ch == '.') {
220 state = DP_S_MAX;
221 ch = *format++;
222 } else {
223 state = DP_S_MOD;
224 }
225 break;
226 case DP_S_MAX:
227 if (isdigit((unsigned char)ch)) {
228 if (max < 0) max = 0;
229 max = 10*max + char_to_int (ch);
230 ch = *format++;
231 } else if (ch == '*') {
232 max = va_arg (args, int);
233 ch = *format++;
234 state = DP_S_MOD;
235 } else {
236 state = DP_S_MOD;
237 }
238 break;
239 case DP_S_MOD:
240 switch (ch) {
241 case 'h':
242 cflags = DP_C_SHORT;
243 ch = *format++;
244 break;
245 case 'l':
246 cflags = DP_C_LONG;
247 ch = *format++;
248 if (ch == 'l') { /* It's a long long */
249 cflags = DP_C_LLONG;
250 ch = *format++;
251 }
252 break;
253 case 'L':
254 cflags = DP_C_LDOUBLE;
255 ch = *format++;
256 break;
257 case 'q':
258 cflags = DP_C_QWORD;
259 ch = *format++;
260 break;
261 default:
262 break;
263 }
264 state = DP_S_CONV;
265 break;
266 case DP_S_CONV:
267 switch (ch) {
268 case 'b':
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 = (LLONG)va_arg (args, unsigned LLONG);
276 } else if (cflags == DP_C_QWORD) {
277 sint64 q = va_arg (args, sint64);
278 fmtqword(buffer, &currlen, maxlen, q, 2, min, max, flags);
279 break;
280 } else {
281 value = (long)va_arg (args, unsigned int);
282 }
283 fmtint (buffer, &currlen, maxlen, value, 2, min, max, flags);
284 break;
285 case 'd':
286 case 'i':
287 if (cflags == DP_C_SHORT) {
288 value = va_arg (args, int);
289 } else if (cflags == DP_C_LONG) {
290 value = va_arg (args, long int);
291 } else if (cflags == DP_C_LLONG) {
292 value = va_arg (args, LLONG);
293 } else if (cflags == DP_C_QWORD) {
294 sint64 q = va_arg (args, sint64);
295 fmtqword(buffer, &currlen, maxlen, q, 10, min, max, flags);
296 break;
297 } else {
298 value = va_arg (args, int);
299 }
300 fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
301 break;
302 case 'o':
303 flags |= DP_F_UNSIGNED;
304 if (cflags == DP_C_SHORT) {
305 value = va_arg (args, unsigned int);
306 } else if (cflags == DP_C_LONG) {
307 value = (long)va_arg (args, unsigned long int);
308 } else if (cflags == DP_C_LLONG) {
309 value = (long)va_arg (args, unsigned LLONG);
310 } else if (cflags == DP_C_QWORD) {
311 sint64 q = va_arg (args, sint64);
312 fmtqword(buffer, &currlen, maxlen, q, 8, min, max, flags);
313 break;
314 } else {
315 value = (long)va_arg (args, unsigned int);
316 }
317 fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
318 break;
319 case 'u':
320 flags |= DP_F_UNSIGNED;
321 if (cflags == DP_C_SHORT) {
322 value = va_arg (args, unsigned int);
323 } else if (cflags == DP_C_LONG) {
324 value = (long)va_arg (args, unsigned long int);
325 } else if (cflags == DP_C_LLONG) {
326 value = (LLONG)va_arg (args, unsigned LLONG);
327 } else if (cflags == DP_C_QWORD) {
328 sint64 q = va_arg (args, sint64);
329 fmtqword(buffer, &currlen, maxlen, q, 10, min, max, flags);
330 break;
331 } else {
332 value = (long)va_arg (args, unsigned int);
333 }
334 fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
335 break;
336 case 'X':
337 flags |= DP_F_UP;
338 case 'x':
339 flags |= DP_F_UNSIGNED;
340 if (cflags == DP_C_SHORT) {
341 value = va_arg (args, unsigned int);
342 } else if (cflags == DP_C_LONG) {
343 value = (long)va_arg (args, unsigned long int);
344 } else if (cflags == DP_C_LLONG) {
345 value = (LLONG)va_arg (args, unsigned LLONG);
346 } else if (cflags == DP_C_QWORD) {
347 sint64 q = va_arg (args, sint64);
348 fmtqword(buffer, &currlen, maxlen, q, 16, min, max, flags);
349 break;
350 } else {
351 value = (long)va_arg (args, unsigned int);
352 }
353 fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
354 break;
355 case 'f':
356 if (cflags == DP_C_LDOUBLE)
357 fvalue = va_arg (args, LDOUBLE);
358 else
359 fvalue = va_arg (args, double);
360 /* um, floating point? */
361 fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
362 break;
363 case 'E':
364 flags |= DP_F_UP;
365 case 'e':
366 if (cflags == DP_C_LDOUBLE)
367 fvalue = va_arg (args, LDOUBLE);
368 else
369 fvalue = va_arg (args, double);
370 break;
371 case 'G':
372 flags |= DP_F_UP;
373 case 'g':
374 if (cflags == DP_C_LDOUBLE)
375 fvalue = va_arg (args, LDOUBLE);
376 else
377 fvalue = va_arg (args, double);
378 break;
379 case 'c':
380 dopr_outch(buffer, &currlen, maxlen, va_arg (args, int));
381 break;
382 case 's':
383 strvalue = va_arg (args, char *);
384 if (!strvalue) strvalue = "(null)";
385 if (max == -1) {
386 max = strlen(strvalue);
387 }
388 if (min > 0 && max >= 0 && min > max) max = min;
389 fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
390 break;
391 case 'p':
392 strvalue = va_arg (args, char *);
393 fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
394 break;
395 case 'n':
396 if (cflags == DP_C_SHORT) {
397 short int *num;
398 num = va_arg (args, short int *);
399 *num = currlen;
400 } else if (cflags == DP_C_LONG) {
401 long int *num;
402 num = va_arg (args, long int *);
403 *num = (long int)currlen;
404 } else if (cflags == DP_C_LLONG) {
405 LLONG *num;
406 num = va_arg (args, LLONG *);
407 *num = (LLONG)currlen;
408 } else {
409 int *num;
410 num = va_arg (args, int *);
411 *num = currlen;
412 }
413 break;
414 case '%':
415 dopr_outch(buffer, &currlen, maxlen, ch);
416 break;
417 case 'w':
418 /* not supported yet, treat as next char */
419 ch = *format++;
420 break;
421 case 'y': {
422 /* object */
423 Object *obj = va_arg (args, Object *);
424 if (obj) {
425 currlen += obj->toString(buffer+currlen, maxlen - currlen);
426 } else {
427 strvalue = "(null)";
428 if (max == -1) {
429 max = strlen(strvalue);
430 }
431 if (min > 0 && max >= 0 && min > max) max = min;
432 fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
433 }
434 break;
435 }
436 default:
437 /* Unknown, skip */
438 break;
439 }
440 ch = *format++;
441 state = DP_S_DEFAULT;
442 flags = cflags = min = 0;
443 max = -1;
444 break;
445 case DP_S_DONE:
446 break;
447 default:
448 /* hmm? */
449 break; /* some picky compilers need this */
450 }
451 }
452 if (maxlen != 0) {
453 if (currlen < maxlen - 1)
454 buffer[currlen] = '\0';
455 else if (maxlen > 0)
456 buffer[maxlen - 1] = '\0';
457 }
458
459 return currlen;
460 }
461
462 static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
463 char *value, int flags, int min, int max)
464 {
465 int padlen, strln; /* amount to pad */
466 int cnt = 0;
467
468 #ifdef DEBUG_SNPRINTF
469 printf("fmtstr min=%d max=%d s=[%s]\n", min, max, value);
470 #endif
471
472 for (strln = 0; value[strln]; ++strln); /* strlen */
473 padlen = min - strln;
474 if (padlen < 0)
475 padlen = 0;
476 if (flags & DP_F_MINUS)
477 padlen = -padlen; /* Left Justify */
478
479 while ((padlen > 0) && (cnt < max)) {
480 dopr_outch(buffer, currlen, maxlen, ' ');
481 --padlen;
482 ++cnt;
483 }
484 while (*value && (cnt < max)) {
485 dopr_outch(buffer, currlen, maxlen, *value++);
486 ++cnt;
487 }
488 while ((padlen < 0) && (cnt < max)) {
489 dopr_outch(buffer, currlen, maxlen, ' ');
490 ++padlen;
491 ++cnt;
492 }
493 }
494
495 /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
496
497 static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
498 long value, int base, int min, int max, int flags)
499 {
500 #define MAX_CONVERT_PLACES 40
501 int signvalue = 0;
502 unsigned long uvalue;
503 char convert[MAX_CONVERT_PLACES];
504 int place = 0;
505 int spadlen = 0; /* amount to space pad */
506 int zpadlen = 0; /* amount to zero pad */
507 int caps = 0;
508
509 if (max < 0)
510 max = 0;
511
512 uvalue = value;
513
514 if (!(flags & DP_F_UNSIGNED)) {
515 if (value < 0) {
516 signvalue = '-';
517 uvalue = -value;
518 } else {
519 if (flags & DP_F_PLUS) /* Do a sign (+/i) */
520 signvalue = '+';
521 else if (flags & DP_F_SPACE)
522 signvalue = ' ';
523 }
524 }
525
526 if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
527
528 do {
529 convert[place++] =
530 (caps? "0123456789ABCDEF":"0123456789abcdef")[uvalue % (unsigned)base];
531 uvalue = (uvalue / (unsigned)base );
532 } while (uvalue && (place < MAX_CONVERT_PLACES));
533 if (place == MAX_CONVERT_PLACES) place--;
534 convert[place] = 0;
535
536 zpadlen = max - place;
537 spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
538 if (zpadlen < 0) zpadlen = 0;
539 if (spadlen < 0) spadlen = 0;
540 if (flags & DP_F_ZERO) {
541 zpadlen = MAX(zpadlen, spadlen);
542 spadlen = 0;
543 }
544 if (flags & DP_F_MINUS)
545 spadlen = -spadlen; /* Left Justifty */
546
547 #ifdef DEBUG_SNPRINTF
548 printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
549 zpadlen, spadlen, min, max, place);
550 #endif
551
552 /* Spaces */
553 while (spadlen > 0) {
554 dopr_outch(buffer, currlen, maxlen, ' ');
555 --spadlen;
556 }
557
558 /* Sign */
559 if (signvalue) dopr_outch(buffer, currlen, maxlen, signvalue);
560
561 /* Zeros */
562 if (zpadlen > 0) {
563 while (zpadlen > 0) {
564 dopr_outch(buffer, currlen, maxlen, '0');
565 --zpadlen;
566 }
567 }
568
569 /* Digits */
570 while (place > 0) dopr_outch(buffer, currlen, maxlen, convert[--place]);
571
572 /* Left Justified spaces */
573 while (spadlen < 0) {
574 dopr_outch(buffer, currlen, maxlen, ' ');
575 ++spadlen;
576 }
577 }
578
579 static void fmtqword(char *buffer, size_t *currlen, size_t maxlen,
580 sint64 value, int base, int min, int max, int flags)
581 {
582 #undef MAX_CONVERT_PLACES
583 #define MAX_CONVERT_PLACES 80
584 int signvalue = 0;
585 uint64 uvalue;
586 char convert[MAX_CONVERT_PLACES];
587 int place = 0;
588 int spadlen = 0; /* amount to space pad */
589 int zpadlen = 0; /* amount to zero pad */
590 int caps = 0;
591
592 if (max < 0) max = 0;
593
594 uvalue = value;
595
596 if (!(flags & DP_F_UNSIGNED)) {
597 if (value < 0) {
598 signvalue = '-';
599 uvalue = -uvalue;
600 } else {
601 if (flags & DP_F_PLUS) /* Do a sign (+/i) */
602 signvalue = '+';
603 else if (flags & DP_F_SPACE)
604 signvalue = ' ';
605 }
606 }
607
608 if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
609
610 do {
611 uint64 uv = uvalue % (uint64)base;
612 convert[place++] =
613 (caps? "0123456789ABCDEF":"0123456789abcdef")[uv];
614 uvalue = (uvalue / (uint64)base);
615 } while ((uvalue != 0) && (place < MAX_CONVERT_PLACES));
616 if (place == MAX_CONVERT_PLACES) place--;
617 convert[place] = 0;
618
619 zpadlen = max - place;
620 spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
621 if (zpadlen < 0) zpadlen = 0;
622 if (spadlen < 0) spadlen = 0;
623 if (flags & DP_F_ZERO) {
624 zpadlen = MAX(zpadlen, spadlen);
625 spadlen = 0;
626 }
627 if (flags & DP_F_MINUS) spadlen = -spadlen; /* Left Justifty */
628
629 #ifdef DEBUG_SNPRINTF
630 printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
631 zpadlen, spadlen, min, max, place);
632 #endif
633
634 /* Spaces */
635 while (spadlen > 0) {
636 dopr_outch(buffer, currlen, maxlen, ' ');
637 --spadlen;
638 }
639
640 /* Sign */
641 if (signvalue) dopr_outch(buffer, currlen, maxlen, signvalue);
642
643 /* Zeros */
644 if (zpadlen > 0) {
645 while (zpadlen > 0) {
646 dopr_outch(buffer, currlen, maxlen, '0');
647 --zpadlen;
648 }
649 }
650
651 /* Digits */
652 while (place > 0) dopr_outch(buffer, currlen, maxlen, convert[--place]);
653
654 /* Left Justified spaces */
655 while (spadlen < 0) {
656 dopr_outch(buffer, currlen, maxlen, ' ');
657 ++spadlen;
658 }
659 }
660
661 static LDOUBLE abs_val(LDOUBLE value)
662 {
663 return (value < 0) ? -value : value;
664 }
665
666 static LDOUBLE POW10(int exp)
667 {
668 LDOUBLE result = 1;
669
670 while (exp) {
671 result *= 10;
672 exp--;
673 }
674
675 return result;
676 }
677
678 static LLONG ROUND(LDOUBLE value)
679 {
680 LLONG intpart;
681
682 intpart = (LLONG)value;
683 value = value - intpart;
684 if (value >= 0.5) intpart++;
685
686 return intpart;
687 }
688
689 /* a replacement for modf that doesn't need the math library. Should
690 be portable, but slow */
691 static double my_modf(double x0, double *iptr)
692 {
693 int i;
694 long l;
695 double x = x0;
696 double f = 1.0;
697
698 for (i=0;i<100;i++) {
699 l = (long)x;
700 if (l <= (x+1) && l >= (x-1)) break;
701 x *= 0.1;
702 f *= 10.0;
703 }
704
705 if (i == 100) {
706 /* yikes! the number is beyond what we can handle. What do we do? */
707 (*iptr) = 0;
708 return 0;
709 }
710
711 if (i != 0) {
712 double i2;
713 double ret;
714
715 ret = my_modf(x0-l*f, &i2);
716 (*iptr) = l*f + i2;
717 return ret;
718 }
719
720 (*iptr) = l;
721 return x - (*iptr);
722 }
723
724
725 static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
726 LDOUBLE fvalue, int min, int max, int flags)
727 {
728 int signvalue = 0;
729 double ufvalue;
730 char iconvert[311];
731 char fconvert[311];
732 int iplace = 0;
733 int fplace = 0;
734 int padlen = 0; /* amount to pad */
735 int zpadlen = 0;
736 int caps = 0;
737 int index;
738 double intpart;
739 double fracpart;
740 double temp;
741
742 /*
743 * AIX manpage says the default is 0, but Solaris says the default
744 * is 6, and sprintf on AIX defaults to 6
745 */
746 if (max < 0)
747 max = 6;
748
749 ufvalue = abs_val (fvalue);
750
751 if (fvalue < 0) {
752 signvalue = '-';
753 } else {
754 if (flags & DP_F_PLUS) { /* Do a sign (+/i) */
755 signvalue = '+';
756 } else {
757 if (flags & DP_F_SPACE)
758 signvalue = ' ';
759 }
760 }
761
762 #if 0
763 if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
764 #endif
765
766 #if 0
767 if (max == 0) ufvalue += 0.5; /* if max = 0 we must round */
768 #endif
769
770 /*
771 * Sorry, we only support 16 digits past the decimal because of our
772 * conversion method
773 */
774 if (max > 16)
775 max = 16;
776
777 /* We "cheat" by converting the fractional part to integer by
778 * multiplying by a factor of 10
779 */
780
781 temp = ufvalue;
782 my_modf(temp, &intpart);
783
784 fracpart = ROUND((POW10(max)) * (ufvalue - intpart));
785
786 if (fracpart >= POW10(max)) {
787 intpart++;
788 fracpart -= POW10(max);
789 }
790
791
792 /* Convert integer part */
793 do {
794 temp = intpart;
795 my_modf(intpart*0.1, &intpart);
796 temp = temp*0.1;
797 index = (int) ((temp -intpart +0.05)* 10.0);
798 /* index = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */
799 /* printf ("%llf, %f, %x\n", temp, intpart, index); */
800 iconvert[iplace++] =
801 (caps? "0123456789ABCDEF":"0123456789abcdef")[index];
802 } while (intpart && (iplace < 311));
803 if (iplace == 311) iplace--;
804 iconvert[iplace] = 0;
805
806 /* Convert fractional part */
807 if (fracpart)
808 {
809 do {
810 temp = fracpart;
811 my_modf(fracpart*0.1, &fracpart);
812 temp = temp*0.1;
813 index = (int) ((temp -fracpart +0.05)* 10.0);
814 /* index = (int) ((((temp/10) -fracpart) +0.05) *10); */
815 /* printf ("%lf, %lf, %ld\n", temp, fracpart, index); */
816 fconvert[fplace++] =
817 (caps? "0123456789ABCDEF":"0123456789abcdef")[index];
818 } while(fracpart && (fplace < 311));
819 if (fplace == 311) fplace--;
820 }
821 fconvert[fplace] = 0;
822
823 /* -1 for decimal point, another -1 if we are printing a sign */
824 padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
825 zpadlen = max - fplace;
826 if (zpadlen < 0) zpadlen = 0;
827 if (padlen < 0)
828 padlen = 0;
829 if (flags & DP_F_MINUS)
830 padlen = -padlen; /* Left Justifty */
831
832 if ((flags & DP_F_ZERO) && (padlen > 0)) {
833 if (signvalue) {
834 dopr_outch(buffer, currlen, maxlen, signvalue);
835 --padlen;
836 signvalue = 0;
837 }
838 while (padlen > 0) {
839 dopr_outch(buffer, currlen, maxlen, '0');
840 --padlen;
841 }
842 }
843 while (padlen > 0) {
844 dopr_outch(buffer, currlen, maxlen, ' ');
845 --padlen;
846 }
847 if (signvalue)
848 dopr_outch(buffer, currlen, maxlen, signvalue);
849
850 while (iplace > 0)
851 dopr_outch(buffer, currlen, maxlen, iconvert[--iplace]);
852
853 #ifdef DEBUG_SNPRINTF
854 printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
855 #endif
856
857 /*
858 * Decimal point. This should probably use locale to find the correct
859 * char to print out.
860 */
861 if (max > 0) {
862 dopr_outch(buffer, currlen, maxlen, '.');
863
864 while (fplace > 0)
865 dopr_outch(buffer, currlen, maxlen, fconvert[--fplace]);
866 }
867
868 while (zpadlen > 0) {
869 dopr_outch(buffer, currlen, maxlen, '0');
870 --zpadlen;
871 }
872
873 while (padlen < 0) {
874 dopr_outch(buffer, currlen, maxlen, ' ');
875 ++padlen;
876 }
877 }
878
879 static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c)
880 {
881 if (*currlen < maxlen) {
882 buffer[(*currlen)] = c;
883 }
884 (*currlen)++;
885 }
886
887 int ht_vsnprintf (char *str, size_t count, const char *fmt, va_list args)
888 {
889 if ((int)count < 0) count = 0;
890 int res = dopr(str, count, fmt, args);
891 if (count) count--;
892 return str ? MIN(res, (int)count) : count;
893 }
894
895 int ht_snprintf(char *str, size_t count, const char *fmt,...)
896 {
897 size_t ret;
898 va_list ap;
899
900 va_start(ap, fmt);
901 ret = ht_vsnprintf(str, count, fmt, ap);
902 va_end(ap);
903 return ret;
904 }
905
906 int ht_vasprintf(char **ptr, const char *format, va_list ap)
907 {
908 int ret;
909
910 ret = dopr(NULL, 0, format, ap);
911 if (ret <= 0) {
912 *ptr = NULL;
913 return 0;
914 }
915
916 (*ptr) = (char *)malloc(ret+1);
917 if (!*ptr) return 0;
918 ret = ht_vsnprintf(*ptr, ret+1, format, ap);
919
920 return ret;
921 }
922
923
924 int ht_asprintf(char **ptr, const char *format, ...)
925 {
926 va_list ap;
927 int ret;
928
929 va_start(ap, format);
930 ret = ht_vasprintf(ptr, format, ap);
931 va_end(ap);
932
933 return ret;
934 }
935
936 int ht_vfprintf(FILE *file, const char *fmt, va_list args)
937 {
938 #if 0
939 char *buf;
940 int ret = ht_vasprintf(&buf, fmt, args);
941 fputs(buf, file);
942 free(buf);
943 #else
944 char buf[1024];
945 int ret = ht_vsnprintf(buf, sizeof buf, fmt, args);
946 fputs(buf, file);
947 #endif
948 return ret;
949 }
950
951 int ht_fprintf(FILE *file, const char *fmt, ...)
952 {
953 va_list ap;
954 int ret;
955
956 va_start(ap, fmt);
957 ret = ht_vfprintf(file, fmt, ap);
958 va_end(ap);
959
960 return ret;
961 }
962
963
964 int ht_vprintf(const char *fmt, va_list args)
965 {
966 return ht_vfprintf(stdout, fmt, args);
967 }
968
969 int ht_printf(const char *fmt, ...)
970 {
971 va_list ap;
972 int ret;
973
974 va_start(ap, fmt);
975 ret = ht_vprintf(fmt, ap);
976 va_end(ap);
977
978 return ret;
979 }
980
981

  ViewVC Help
Powered by ViewVC 1.1.26