]> git.ipfire.org Git - thirdparty/bash.git/blob - lib/sh/snprintf.c
projects / thirdparty / bash.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
commit bash-20080814 snapshot
[thirdparty/bash.git] / lib / sh / snprintf.c
1 /* snprintf - formatted output to strings, with bounds checking and allocation */
2
3 /*
4 build a test version with
5 gcc -g -DDRIVER -I../.. -I../../include -o test-snprintf snprintf.c fmtu*long.o
6 */
7
8 /*
9 Unix snprintf implementation.
10 derived from inetutils/libinetutils/snprintf.c Version 1.1
11
12 Copyright (C) 2001,2006 Free Software Foundation, Inc.
13
14 This file is part of GNU Bash, the Bourne Again SHell.
15
16 Bash is free software: you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation, either version 3 of the License, or
19 (at your option) any later version.
20
21 Bash is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
25
26 You should have received a copy of the GNU General Public License
27 along with Bash. If not, see <http://www.gnu.org/licenses/>.
28
29 Revision History:
30
31 1.1:
32 * added changes from Miles Bader
33 * corrected a bug with %f
34 * added support for %#g
35 * added more comments :-)
36 1.0:
37 * supporting must ANSI syntaxic_sugars
38 0.0:
39 * support %s %c %d
40
41 THANKS(for the patches and ideas):
42 Miles Bader
43 Cyrille Rustom
44 Jacek Slabocewiz
45 Mike Parker(mouse)
46
47 */
48
49 /*
50 * Currently doesn't handle (and bash/readline doesn't use):
51 * * *M$ width, precision specifications
52 * * %N$ numbered argument conversions
53 * * inf, nan floating values imperfect (if isinf(), isnan() not in libc)
54 * * support for `F' is imperfect with ldfallback(), since underlying
55 * printf may not handle it -- should ideally have another autoconf test
56 */
57
58 #define FLOATING_POINT
59
60 #ifdef HAVE_CONFIG_H
61 # include <config.h>
62 #endif
63
64 #if defined(DEBUG)
65 # undef HAVE_SNPRINTF
66 # undef HAVE_ASPRINTF
67 #endif
68
69 #if defined(DRIVER) && !defined(HAVE_CONFIG_H)
70 #define HAVE_LONG_LONG
71 #define HAVE_LONG_DOUBLE
72 #ifdef __linux__
73 #define HAVE_PRINTF_A_FORMAT
74 #endif
75 #define HAVE_ISINF_IN_LIBC
76 #define HAVE_ISNAN_IN_LIBC
77 #define PREFER_STDARG
78 #define HAVE_STRINGIZE
79 #define HAVE_LIMITS_H
80 #define HAVE_STDDEF_H
81 #define HAVE_LOCALE_H
82 #define intmax_t long
83 #endif
84
85 #if !defined (HAVE_SNPRINTF) || !defined (HAVE_ASPRINTF)
86
87 #include <bashtypes.h>
88
89 #if defined(PREFER_STDARG)
90 # include <stdarg.h>
91 #else
92 # include <varargs.h>
93 #endif
94
95 #ifdef HAVE_LIMITS_H
96 # include <limits.h>
97 #endif
98 #include <bashansi.h>
99 #ifdef HAVE_STDDEF_H
100 # include <stddef.h>
101 #endif
102 #include <chartypes.h>
103
104 #ifdef HAVE_STDINT_H
105 # include <stdint.h>
106 #endif
107
108 #ifdef FLOATING_POINT
109 # include <float.h> /* for manifest constants */
110 # include <stdio.h> /* for sprintf */
111 #endif
112
113 #include <typemax.h>
114
115 #ifdef HAVE_LOCALE_H
116 # include <locale.h>
117 #endif
118
119 #include "stdc.h"
120 #include <shmbutil.h>
121
122 #ifndef DRIVER
123 # include "shell.h"
124 #else
125 # define FL_PREFIX 0x01 /* add 0x, 0X, or 0 prefix as appropriate */
126 # define FL_ADDBASE 0x02 /* add base# prefix to converted value */
127 # define FL_HEXUPPER 0x04 /* use uppercase when converting to hex */
128 # define FL_UNSIGNED 0x08 /* don't add any sign */
129 extern char *fmtulong __P((unsigned long int, int, char *, size_t, int));
130 extern char *fmtullong __P((unsigned long long int, int, char *, size_t, int));
131 #endif
132
133 #ifndef FREE
134 # define FREE(x) if (x) free (x)
135 #endif
136
137 /* Bound on length of the string representing an integer value of type T.
138 Subtract one for the sign bit if T is signed;
139 302 / 1000 is log10 (2) rounded up;
140 add one for integer division truncation;
141 add one more for a minus sign if t is signed. */
142 #define INT_STRLEN_BOUND(t) \
143 ((sizeof (t) * CHAR_BIT - TYPE_SIGNED (t)) * 302 / 1000 \
144 + 1 + TYPE_SIGNED (t))
145
146 /* conversion flags */
147 #define PF_ALTFORM 0x00001 /* # */
148 #define PF_HEXPREFIX 0x00002 /* 0[Xx] */
149 #define PF_LADJUST 0x00004 /* - */
150 #define PF_ZEROPAD 0x00008 /* 0 */
151 #define PF_PLUS 0x00010 /* + */
152 #define PF_SPACE 0x00020 /* ' ' */
153 #define PF_THOUSANDS 0x00040 /* ' */
154
155 #define PF_DOT 0x00080 /* `.precision' */
156 #define PF_STAR_P 0x00100 /* `*' after precision */
157 #define PF_STAR_W 0x00200 /* `*' before or without precision */
158
159 /* length modifiers */
160 #define PF_SIGNEDCHAR 0x00400 /* hh */
161 #define PF_SHORTINT 0x00800 /* h */
162 #define PF_LONGINT 0x01000 /* l */
163 #define PF_LONGLONG 0x02000 /* ll */
164 #define PF_LONGDBL 0x04000 /* L */
165 #define PF_INTMAX_T 0x08000 /* j */
166 #define PF_SIZE_T 0x10000 /* z */
167 #define PF_PTRDIFF_T 0x20000 /* t */
168
169 #define PF_ALLOCBUF 0x40000 /* for asprintf, vasprintf */
170
171 #define PFM_SN 0x01 /* snprintf, vsnprintf */
172 #define PFM_AS 0x02 /* asprintf, vasprintf */
173
174 #define ASBUFSIZE 128
175
176 #define x_digs "0123456789abcdef"
177 #define X_digs "0123456789ABCDEF"
178
179 static char intbuf[INT_STRLEN_BOUND(unsigned long) + 1];
180
181 static int decpoint;
182 static int thoussep;
183 static char *grouping;
184
185 /*
186 * For the FLOATING POINT FORMAT :
187 * the challenge was finding a way to
188 * manipulate the Real numbers without having
189 * to resort to mathematical function(it
190 * would require to link with -lm) and not
191 * going down to the bit pattern(not portable)
192 *
193 * so a number, a real is:
194
195 real = integral + fraction
196
197 integral = ... + a(2)*10^2 + a(1)*10^1 + a(0)*10^0
198 fraction = b(1)*10^-1 + b(2)*10^-2 + ...
199
200 where:
201 0 <= a(i) => 9
202 0 <= b(i) => 9
203
204 from then it was simple math
205 */
206
207 /*
208 * size of the buffer for the integral part
209 * and the fraction part
210 */
211 #define MAX_INT 99 + 1 /* 1 for the null */
212 #define MAX_FRACT 307 + 1
213
214 /*
215 * These functions use static buffers to store the results,
216 * and so are not reentrant
217 */
218 #define itoa(n) fmtulong(n, 10, intbuf, sizeof(intbuf), 0);
219 #define dtoa(n, p, f) numtoa(n, 10, p, f)
220
221 #define SWAP_INT(a,b) {int t; t = (a); (a) = (b); (b) = t;}
222
223 #define GETARG(type) (va_arg(args, type))
224
225 /* Macros that do proper sign extension and handle length modifiers. Used
226 for the integer conversion specifiers. */
227 #define GETSIGNED(p) \
228 (((p)->flags & PF_LONGINT) \
229 ? GETARG (long) \
230 : (((p)->flags & PF_SHORTINT) ? (long)(short)GETARG (int) \
231 : (long)GETARG (int)))
232
233 #define GETUNSIGNED(p) \
234 (((p)->flags & PF_LONGINT) \
235 ? GETARG (unsigned long) \
236 : (((p)->flags & PF_SHORTINT) ? (unsigned long)(unsigned short)GETARG (int) \
237 : (unsigned long)GETARG (unsigned int)))
238
239
240 #ifdef HAVE_LONG_DOUBLE
241 #define GETLDOUBLE(p) GETARG (long double)
242 #endif
243 #define GETDOUBLE(p) GETARG (double)
244
245 #define SET_SIZE_FLAGS(p, type) \
246 if (sizeof (type) > sizeof (int)) \
247 (p)->flags |= PF_LONGINT; \
248 if (sizeof (type) > sizeof (long)) \
249 (p)->flags |= PF_LONGLONG;
250
251 /* this struct holds everything we need */
252 struct DATA
253 {
254 int length;
255 char *base; /* needed for [v]asprintf */
256 char *holder;
257 int counter;
258 const char *pf;
259
260 /* FLAGS */
261 int flags;
262 int justify;
263 int width, precision;
264 char pad;
265 };
266
267 /* the floating point stuff */
268 #ifdef FLOATING_POINT
269 static double pow_10 __P((int));
270 static int log_10 __P((double));
271 static double integral __P((double, double *));
272 static char *numtoa __P((double, int, int, char **));
273 #endif
274
275 static void init_data __P((struct DATA *, char *, size_t, const char *, int));
276 static void init_conv_flag __P((struct DATA *));
277
278 /* for the format */
279 #ifdef FLOATING_POINT
280 static void floating __P((struct DATA *, double));
281 static void exponent __P((struct DATA *, double));
282 #endif
283 static void number __P((struct DATA *, unsigned long, int));
284 #ifdef HAVE_LONG_LONG
285 static void lnumber __P((struct DATA *, unsigned long long, int));
286 #endif
287 static void pointer __P((struct DATA *, unsigned long));
288 static void strings __P((struct DATA *, char *));
289
290 #ifdef FLOATING_POINT
291 # define FALLBACK_FMTSIZE 32
292 # define FALLBACK_BASE 4096
293 # define LFALLBACK_BASE 5120
294 # ifdef HAVE_LONG_DOUBLE
295 static void ldfallback __P((struct DATA *, const char *, const char *, long double));
296 # endif
297 static void dfallback __P((struct DATA *, const char *, const char *, double));
298 #endif
299
300 static char *groupnum __P((char *));
301
302 #ifdef DRIVER
303 static void memory_error_and_abort ();
304 static void *xmalloc __P((size_t));
305 static void *xrealloc __P((void *, size_t));
306 static void xfree __P((void *));
307 #else
308 # include <xmalloc.h>
309 #endif
310
311 /* those are defines specific to snprintf to hopefully
312 * make the code clearer :-)
313 */
314 #define RIGHT 1
315 #define LEFT 0
316 #define NOT_FOUND -1
317 #define FOUND 1
318 #define MAX_FIELD 15
319
320 /* round off to the precision */
321 #define ROUND(d, p) \
322 (d < 0.) ? \
323 d - pow_10(-(p)->precision) * 0.5 : \
324 d + pow_10(-(p)->precision) * 0.5
325
326 /* set default precision */
327 #define DEF_PREC(p) \
328 if ((p)->precision == NOT_FOUND) \
329 (p)->precision = 6
330
331 /* put a char. increment the number of chars written even if we've exceeded
332 the vsnprintf/snprintf buffer size (for the return value) */
333 #define PUT_CHAR(c, p) \
334 do \
335 { \
336 if (((p)->flags & PF_ALLOCBUF) && ((p)->counter >= (p)->length - 1)) \
337 { \
338 (p)->length += ASBUFSIZE; \
339 (p)->base = (char *)xrealloc((p)->base, (p)->length); \
340 (p)->holder = (p)->base + (p)->counter; /* in case reallocated */ \
341 } \
342 if ((p)->counter < (p)->length) \
343 *(p)->holder++ = (c); \
344 (p)->counter++; \
345 } \
346 while (0)
347
348 /* Output a string. P->WIDTH has already been adjusted for padding. */
349 #define PUT_STRING(string, len, p) \
350 do \
351 { \
352 PAD_RIGHT (p); \
353 while ((len)-- > 0) \
354 { \
355 PUT_CHAR (*(string), (p)); \
356 (string)++; \
357 } \
358 PAD_LEFT (p); \
359 } \
360 while (0)
361
362 #define PUT_PLUS(d, p, zero) \
363 if ((d) > zero && (p)->justify == RIGHT) \
364 PUT_CHAR('+', p)
365
366 #define PUT_SPACE(d, p, zero) \
367 if (((p)->flags & PF_SPACE) && (d) > zero) \
368 PUT_CHAR(' ', p)
369
370 /* pad right */
371 #define PAD_RIGHT(p) \
372 if ((p)->width > 0 && (p)->justify != LEFT) \
373 for (; (p)->width > 0; (p)->width--) \
374 PUT_CHAR((p)->pad, p)
375
376 /* pad left */
377 #define PAD_LEFT(p) \
378 if ((p)->width > 0 && (p)->justify == LEFT) \
379 for (; (p)->width > 0; (p)->width--) \
380 PUT_CHAR((p)->pad, p)
381
382 /* pad with zeros from decimal precision */
383 #define PAD_ZERO(p) \
384 if ((p)->precision > 0) \
385 for (; (p)->precision > 0; (p)->precision--) \
386 PUT_CHAR('0', p)
387
388 /* if width and prec. in the args */
389 #define STAR_ARGS(p) \
390 do { \
391 if ((p)->flags & PF_STAR_W) \
392 { \
393 (p)->width = GETARG (int); \
394 if ((p)->width < 0) \
395 { \
396 (p)->flags |= PF_LADJUST; \
397 (p)->justify = LEFT; \
398 (p)->width = -(p)->width; \
399 } \
400 } \
401 if ((p)->flags & PF_STAR_P) \
402 { \
403 (p)->precision = GETARG (int); \
404 if ((p)->precision < 0) \
405 { \
406 (p)->flags &= ~PF_STAR_P; \
407 (p)->precision = NOT_FOUND; \
408 } \
409 } \
410 } while (0)
411
412 #if defined (HAVE_LOCALE_H) && defined (HAVE_LOCALECONV)
413 # define GETLOCALEDATA(d, t, g) \
414 do \
415 { \
416 struct lconv *lv; \
417 if ((d) == 0) { \
418 (d) = '.'; (t) = -1; (g) = 0; /* defaults */ \
419 lv = localeconv(); \
420 if (lv) \
421 { \
422 if (lv->decimal_point && lv->decimal_point[0]) \
423 (d) = lv->decimal_point[0]; \
424 if (lv->thousands_sep && lv->thousands_sep[0]) \
425 (t) = lv->thousands_sep[0]; \
426 (g) = lv->grouping ? lv->grouping : ""; \
427 if (*(g) == '\0' || *(g) == CHAR_MAX || (t) == -1) (g) = 0; \
428 } \
429 } \
430 } \
431 while (0);
432 #else
433 # define GETLOCALEDATA(d, t, g) \
434 ( (d) = '.', (t) = ',', g = "\003" )
435 #endif
436
437 #ifdef FLOATING_POINT
438 /*
439 * Find the nth power of 10
440 */
441 static double
442 pow_10(n)
443 int n;
444 {
445 double P;
446
447 /* handle common cases with fast switch statement. */
448 switch (n)
449 {
450 case -3: return .001;
451 case -2: return .01;
452 case -1: return .1;
453 case 0: return 1.;
454 case 1: return 10.;
455 case 2: return 100.;
456 case 3: return 1000.;
457 }
458
459 if (n < 0)
460 {
461 P = .0001;
462 for (n += 4; n < 0; n++)
463 P /= 10.;
464 }
465 else
466 {
467 P = 10000.;
468 for (n -= 4; n > 0; n--)
469 P *= 10.;
470 }
471
472 return P;
473 }
474
475 /*
476 * Find the integral part of the log in base 10
477 * Note: this not a real log10()
478 I just need and approximation(integerpart) of x in:
479 10^x ~= r
480 * log_10(200) = 2;
481 * log_10(250) = 2;
482 *
483 * NOTE: do not call this with r == 0 -- an infinite loop results.
484 */
485 static int
486 log_10(r)
487 double r;
488 {
489 int i = 0;
490 double result = 1.;
491
492 if (r < 0.)
493 r = -r;
494
495 if (r < 1.)
496 {
497 while (result >= r)
498 {
499 result /= 10.;
500 i++;
501 }
502 return (-i);
503 }
504 else
505 {
506 while (result <= r)
507 {
508 result *= 10.;
509 i++;
510 }
511 return (i - 1);
512 }
513 }
514
515 /*
516 * This function return the fraction part of a double
517 * and set in ip the integral part.
518 * In many ways it resemble the modf() found on most Un*x
519 */
520 static double
521 integral(real, ip)
522 double real;
523 double *ip;
524 {
525 int j;
526 double i, s, p;
527 double real_integral = 0.;
528
529 /* take care of the obvious */
530 /* equal to zero ? */
531 if (real == 0.)
532 {
533 *ip = 0.;
534 return (0.);
535 }
536
537 /* negative number ? */
538 if (real < 0.)
539 real = -real;
540
541 /* a fraction ? */
542 if ( real < 1.)
543 {
544 *ip = 0.;
545 return real;
546 }
547
548 /* the real work :-) */
549 for (j = log_10(real); j >= 0; j--)
550 {
551 p = pow_10(j);
552 s = (real - real_integral)/p;
553 i = 0.;
554 while (i + 1. <= s)
555 i++;
556 real_integral += i*p;
557 }
558 *ip = real_integral;
559 return (real - real_integral);
560 }
561
562 #define PRECISION 1.e-6
563 /*
564 * return an ascii representation of the integral part of the number
565 * and set fract to be an ascii representation of the fraction part
566 * the container for the fraction and the integral part or staticly
567 * declare with fix size
568 */
569 static char *
570 numtoa(number, base, precision, fract)
571 double number;
572 int base, precision;
573 char **fract;
574 {
575 register int i, j;
576 double ip, fp; /* integer and fraction part */
577 double fraction;
578 int digits = MAX_INT - 1;
579 static char integral_part[MAX_INT];
580 static char fraction_part[MAX_FRACT];
581 double sign;
582 int ch;
583
584 /* taking care of the obvious case: 0.0 */
585 if (number == 0.)
586 {
587 integral_part[0] = '0';
588 integral_part[1] = '\0';
589 /* The fractional part has to take the precision into account */
590 for (ch = 0; ch < precision-1; ch++)
591 fraction_part[ch] = '0';
592 fraction_part[ch] = '0';
593 fraction_part[ch+1] = '\0';
594 if (fract)
595 *fract = fraction_part;
596 return integral_part;
597 }
598
599 /* for negative numbers */
600 if ((sign = number) < 0.)
601 {
602 number = -number;
603 digits--; /* sign consume one digit */
604 }
605
606 fraction = integral(number, &ip);
607 number = ip;
608
609 /* do the integral part */
610 if (ip == 0.)
611 {
612 integral_part[0] = '0';
613 i = 1;
614 }
615 else
616 {
617 for ( i = 0; i < digits && number != 0.; ++i)
618 {
619 number /= base;
620 fp = integral(number, &ip);
621 ch = (int)((fp + PRECISION)*base); /* force to round */
622 integral_part[i] = (ch <= 9) ? ch + '0' : ch + 'a' - 10;
623 if (! ISXDIGIT((unsigned char)integral_part[i]))
624 break; /* bail out overflow !! */
625 number = ip;
626 }
627 }
628
629 /* Oh No !! out of bound, ho well fill it up ! */
630 if (number != 0.)
631 for (i = 0; i < digits; ++i)
632 integral_part[i] = '9';
633
634 /* put the sign ? */
635 if (sign < 0.)
636 integral_part[i++] = '-';
637
638 integral_part[i] = '\0';
639
640 /* reverse every thing */
641 for ( i--, j = 0; j < i; j++, i--)
642 SWAP_INT(integral_part[i], integral_part[j]);
643
644 /* the fractional part */
645 for (i=0, fp=fraction; precision > 0 && i < MAX_FRACT ; i++, precision--)
646 {
647 fraction_part[i] = (int)((fp + PRECISION)*10. + '0');
648 if (! DIGIT(fraction_part[i])) /* underflow ? */
649 break;
650 fp = (fp*10.0) - (double)(long)((fp + PRECISION)*10.);
651 }
652 fraction_part[i] = '\0';
653
654 if (fract != (char **)0)
655 *fract = fraction_part;
656
657 return integral_part;
658 }
659 #endif
660
661 /* for %d and friends, it puts in holder
662 * the representation with the right padding
663 */
664 static void
665 number(p, d, base)
666 struct DATA *p;
667 unsigned long d;
668 int base;
669 {
670 char *tmp, *t;
671 long sd;
672 int flags;
673
674 /* An explicit precision turns off the zero-padding flag. */
675 if ((p->flags & PF_ZEROPAD) && p->precision >= 0 && (p->flags & PF_DOT))
676 p->flags &= ~PF_ZEROPAD;
677
678 sd = d; /* signed for ' ' padding in base 10 */
679 flags = 0;
680 flags = (*p->pf == 'x' || *p->pf == 'X' || *p->pf == 'o' || *p->pf == 'u' || *p->pf == 'U') ? FL_UNSIGNED : 0;
681 if (*p->pf == 'X')
682 flags |= FL_HEXUPPER;
683
684 tmp = fmtulong (d, base, intbuf, sizeof(intbuf), flags);
685 t = 0;
686 if ((p->flags & PF_THOUSANDS))
687 {
688 GETLOCALEDATA(decpoint, thoussep, grouping);
689 if (grouping && (t = groupnum (tmp)))
690 tmp = t;
691 }
692
693 p->width -= strlen(tmp);
694 PAD_RIGHT(p);
695
696 if ((p->flags & PF_DOT) && p->precision > 0)
697 {
698 p->precision -= strlen(tmp);
699 PAD_ZERO(p);
700 }
701
702 switch (base)
703 {
704 case 10:
705 PUT_PLUS(sd, p, 0);
706 PUT_SPACE(sd, p, 0);
707 break;
708 case 8:
709 if (p->flags & PF_ALTFORM)
710 PUT_CHAR('0', p);
711 break;
712 case 16:
713 if (p->flags & PF_ALTFORM)
714 {
715 PUT_CHAR('0', p);
716 PUT_CHAR(*p->pf, p);
717 }
718 break;
719 }
720
721 while (*tmp)
722 {
723 PUT_CHAR(*tmp, p);
724 tmp++;
725 }
726
727 PAD_LEFT(p);
728 FREE (t);
729 }
730
731 #ifdef HAVE_LONG_LONG
732 /*
733 * identical to number() but works for `long long'
734 */
735 static void
736 lnumber(p, d, base)
737 struct DATA *p;
738 unsigned long long d;
739 int base;
740 {
741 char *tmp, *t;
742 long long sd;
743 int flags;
744
745 /* An explicit precision turns off the zero-padding flag. */
746 if ((p->flags & PF_ZEROPAD) && p->precision >= 0 && (p->flags & PF_DOT))
747 p->flags &= ~PF_ZEROPAD;
748
749 sd = d; /* signed for ' ' padding in base 10 */
750 flags = (*p->pf == 'x' || *p->pf == 'X' || *p->pf == 'o' || *p->pf == 'u' || *p->pf == 'U') ? FL_UNSIGNED : 0;
751 if (*p->pf == 'X')
752 flags |= FL_HEXUPPER;
753
754 tmp = fmtullong (d, base, intbuf, sizeof(intbuf), flags);
755 t = 0;
756 if ((p->flags & PF_THOUSANDS))
757 {
758 GETLOCALEDATA(decpoint, thoussep, grouping);
759 if (grouping && (t = groupnum (tmp)))
760 tmp = t;
761 }
762
763 p->width -= strlen(tmp);
764 PAD_RIGHT(p);
765
766 if ((p->flags & PF_DOT) && p->precision > 0)
767 {
768 p->precision -= strlen(tmp);
769 PAD_ZERO(p);
770 }
771
772 switch (base)
773 {
774 case 10:
775 PUT_PLUS(sd, p, 0);
776 PUT_SPACE(sd, p, 0);
777 break;
778 case 8:
779 if (p->flags & PF_ALTFORM)
780 PUT_CHAR('0', p);
781 break;
782 case 16:
783 if (p->flags & PF_ALTFORM)
784 {
785 PUT_CHAR('0', p);
786 PUT_CHAR(*p->pf, p);
787 }
788 break;
789 }
790
791 while (*tmp)
792 {
793 PUT_CHAR(*tmp, p);
794 tmp++;
795 }
796
797 PAD_LEFT(p);
798 FREE (t);
799 }
800 #endif
801
802 static void
803 pointer(p, d)
804 struct DATA *p;
805 unsigned long d;
806 {
807 char *tmp;
808
809 tmp = fmtulong(d, 16, intbuf, sizeof(intbuf), 0);
810 p->width -= strlen(tmp);
811 PAD_RIGHT(p);
812
813 /* prefix '0x' for pointers */
814 PUT_CHAR('0', p);
815 PUT_CHAR('x', p);
816
817 while (*tmp)
818 {
819 PUT_CHAR(*tmp, p);
820 tmp++;
821 }
822
823 PAD_LEFT(p);
824 }
825
826 /* %s strings */
827 static void
828 strings(p, tmp)
829 struct DATA *p;
830 char *tmp;
831 {
832 size_t len;
833
834 len = strlen(tmp);
835 if (p->precision != NOT_FOUND) /* the smallest number */
836 len = (len < p->precision ? len : p->precision);
837 p->width -= len;
838
839 PUT_STRING (tmp, len, p);
840 }
841
842 #if HANDLE_MULTIBYTE
843 /* %ls wide-character strings */
844 static void
845 wstrings(p, tmp)
846 struct DATA *p;
847 wchar_t *tmp;
848 {
849 size_t len;
850 mbstate_t mbs;
851 char *os;
852 const wchar_t *ws;
853
854 memset (&mbs, '\0', sizeof (mbstate_t));
855 ws = (const wchar_t *)tmp;
856
857 os = (char *)NULL;
858 if (p->precision != NOT_FOUND)
859 {
860 os = (char *)xmalloc (p->precision + 1);
861 len = wcsrtombs (os, &ws, p->precision, &mbs);
862 }
863 else
864 {
865 len = wcsrtombs (NULL, &ws, 0, &mbs);
866 if (len != (size_t)-1)
867 {
868 memset (&mbs, '\0', sizeof (mbstate_t));
869 os = (char *)xmalloc (len + 1);
870 (void)wcsrtombs (os, &ws, len + 1, &mbs);
871 }
872 }
873 if (len == (size_t)-1)
874 {
875 /* invalid multibyte sequence; bail now. */
876 FREE (os);
877 return;
878 }
879
880 p->width -= len;
881 PUT_STRING (os, len, p);
882 free (os);
883 }
884
885 static void
886 wchars (p, wc)
887 struct DATA *p;
888 wint_t wc;
889 {
890 char *lbuf, *l;
891 mbstate_t mbs;
892 size_t len;
893
894 lbuf = (char *)malloc (MB_CUR_MAX+1);
895 if (lbuf == 0)
896 return;
897 memset (&mbs, '\0', sizeof (mbstate_t));
898 len = wcrtomb (lbuf, wc, &mbs);
899 if (len == (size_t)-1)
900 /* conversion failed; bail now. */
901 return;
902 p->width -= len;
903 l = lbuf;
904 PUT_STRING (l, len, p);
905 free (lbuf);
906 }
907 #endif /* HANDLE_MULTIBYTE */
908
909 #ifdef FLOATING_POINT
910
911 #ifndef HAVE_ISINF_IN_LIBC
912 /* Half-assed versions, since we don't want to link with libm. */
913 static int
914 isinf(d)
915 double d;
916 {
917 #ifdef DBL_MAX
918 if (d < DBL_MIN)
919 return -1;
920 else if (d > DBL_MAX)
921 return 1;
922 else
923 #endif
924 return 0;
925 }
926 #endif
927
928 #ifndef HAVE_ISNAN_IN_LIBC
929 static int
930 isnan(d)
931 double d;
932 {
933 return 0;
934 }
935 #endif
936
937 /* Check for [+-]infinity and NaN. If MODE == 1, we check for Infinity, else
938 (mode == 2) we check for NaN. This does the necessary printing. Returns
939 1 if Inf or Nan, 0 if not. */
940 static int
941 chkinfnan(p, d, mode)
942 struct DATA *p;
943 double d;
944 int mode; /* == 1 for inf, == 2 for nan */
945 {
946 int i;
947 char *tmp;
948 char *big, *small;
949
950 i = (mode == 1) ? isinf(d) : isnan(d);
951 if (i == 0)
952 return 0;
953 big = (mode == 1) ? "INF" : "NAN";
954 small = (mode == 1) ? "inf" : "nan";
955
956 tmp = (*p->pf == 'F' || *p->pf == 'G' || *p->pf == 'E') ? big : small;
957
958 if (i < 0)
959 PUT_CHAR('-', p);
960
961 while (*tmp)
962 {
963 PUT_CHAR (*tmp, p);
964 tmp++;
965 }
966
967 return 1;
968 }
969
970 /* %f %F %g %G floating point representation */
971 static void
972 floating(p, d)
973 struct DATA *p;
974 double d;
975 {
976 char *tmp, *tmp2, *t;
977 int i;
978
979 if (d != 0 && (chkinfnan(p, d, 1) || chkinfnan(p, d, 2)))
980 return; /* already printed nan or inf */
981
982 GETLOCALEDATA(decpoint, thoussep, grouping);
983 DEF_PREC(p);
984 d = ROUND(d, p);
985 tmp = dtoa(d, p->precision, &tmp2);
986 t = 0;
987 if ((p->flags & PF_THOUSANDS) && grouping && (t = groupnum (tmp)))
988 tmp = t;
989
990 if ((*p->pf == 'g' || *p->pf == 'G') && (p->flags & PF_ALTFORM) == 0)
991 {
992 /* smash the trailing zeros unless altform */
993 for (i = strlen(tmp2) - 1; i >= 0 && tmp2[i] == '0'; i--)
994 tmp2[i] = '\0';
995 if (tmp2[0] == '\0')
996 p->precision = 0;
997 }
998
999 /* calculate the padding. 1 for the dot */
1000 p->width = p->width -
1001 ((d > 0. && p->justify == RIGHT) ? 1:0) -
1002 ((p->flags & PF_SPACE) ? 1:0) -
1003 strlen(tmp) - p->precision -
1004 ((p->precision != 0 || (p->flags & PF_ALTFORM)) ? 1 : 0); /* radix char */
1005 PAD_RIGHT(p);
1006 PUT_PLUS(d, p, 0.);
1007 PUT_SPACE(d, p, 0.);
1008
1009 while (*tmp)
1010 {
1011 PUT_CHAR(*tmp, p); /* the integral */
1012 tmp++;
1013 }
1014 FREE (t);
1015
1016 if (p->precision != 0 || (p->flags & PF_ALTFORM))
1017 PUT_CHAR(decpoint, p); /* put the '.' */
1018
1019 for (; *tmp2; tmp2++)
1020 PUT_CHAR(*tmp2, p); /* the fraction */
1021
1022 PAD_LEFT(p);
1023 }
1024
1025 /* %e %E %g %G exponent representation */
1026 static void
1027 exponent(p, d)
1028 struct DATA *p;
1029 double d;
1030 {
1031 char *tmp, *tmp2;
1032 int j, i;
1033
1034 if (d != 0 && (chkinfnan(p, d, 1) || chkinfnan(p, d, 2)))
1035 return; /* already printed nan or inf */
1036
1037 GETLOCALEDATA(decpoint, thoussep, grouping);
1038 DEF_PREC(p);
1039 if (d == 0.)
1040 j = 0;
1041 else
1042 {
1043 j = log_10(d);
1044 d = d / pow_10(j); /* get the Mantissa */
1045 d = ROUND(d, p);
1046 }
1047 tmp = dtoa(d, p->precision, &tmp2);
1048
1049 /* 1 for unit, 1 for the '.', 1 for 'e|E',
1050 * 1 for '+|-', 2 for 'exp' */
1051 /* calculate how much padding need */
1052 p->width = p->width -
1053 ((d > 0. && p->justify == RIGHT) ? 1:0) -
1054 ((p->flags & PF_SPACE) ? 1:0) - p->precision - 6;
1055
1056 PAD_RIGHT(p);
1057 PUT_PLUS(d, p, 0.);
1058 PUT_SPACE(d, p, 0.);
1059
1060 while (*tmp)
1061 {
1062 PUT_CHAR(*tmp, p);
1063 tmp++;
1064 }
1065
1066 if (p->precision != 0 || (p->flags & PF_ALTFORM))
1067 PUT_CHAR(decpoint, p); /* the '.' */
1068
1069 if ((*p->pf == 'g' || *p->pf == 'G') && (p->flags & PF_ALTFORM) == 0)
1070 /* smash the trailing zeros unless altform */
1071 for (i = strlen(tmp2) - 1; i >= 0 && tmp2[i] == '0'; i--)
1072 tmp2[i] = '\0';
1073
1074 for (; *tmp2; tmp2++)
1075 PUT_CHAR(*tmp2, p); /* the fraction */
1076
1077 /* the exponent put the 'e|E' */
1078 if (*p->pf == 'g' || *p->pf == 'e')
1079 PUT_CHAR('e', p);
1080 else
1081 PUT_CHAR('E', p);
1082
1083 /* the sign of the exp */
1084 if (j >= 0)
1085 PUT_CHAR('+', p);
1086 else
1087 {
1088 PUT_CHAR('-', p);
1089 j = -j;
1090 }
1091
1092 tmp = itoa(j);
1093 /* pad out to at least two spaces. pad with `0' if the exponent is a
1094 single digit. */
1095 if (j <= 9)
1096 PUT_CHAR('0', p);
1097
1098 /* the exponent */
1099 while (*tmp)
1100 {
1101 PUT_CHAR(*tmp, p);
1102 tmp++;
1103 }
1104
1105 PAD_LEFT(p);
1106 }
1107 #endif
1108
1109 /* Return a new string with the digits in S grouped according to the locale's
1110 grouping info and thousands separator. If no grouping should be performed,
1111 this returns NULL; the caller needs to check for it. */
1112 static char *
1113 groupnum (s)
1114 char *s;
1115 {
1116 char *se, *ret, *re, *g;
1117 int len, slen;
1118
1119 if (grouping == 0 || *grouping <= 0 || *grouping == CHAR_MAX)
1120 return ((char *)NULL);
1121
1122 /* find min grouping to size returned string */
1123 for (len = *grouping, g = grouping; *g; g++)
1124 if (*g > 0 && *g < len)
1125 len = *g;
1126
1127 slen = strlen (s);
1128 len = slen / len + 1;
1129 ret = (char *)xmalloc (slen + len + 1);
1130 re = ret + slen + len;
1131 *re = '\0';
1132
1133 g = grouping;
1134 se = s + slen;
1135 len = *g;
1136
1137 while (se > s)
1138 {
1139 *--re = *--se;
1140
1141 /* handle `-' inserted by numtoa() and the fmtu* family here. */
1142 if (se > s && se[-1] == '-')
1143 continue;
1144
1145 /* begin new group. */
1146 if (--len == 0 && se > s)
1147 {
1148 *--re = thoussep;
1149 len = *++g; /* was g++, but that uses first char twice (glibc bug, too) */
1150 if (*g == '\0')
1151 len = *--g; /* use previous grouping */
1152 else if (*g == CHAR_MAX)
1153 {
1154 do
1155 *--re = *--se;
1156 while (se > s);
1157 break;
1158 }
1159 }
1160 }
1161
1162 if (re > ret)
1163 #ifdef HAVE_MEMMOVE
1164 memmove (ret, re, strlen (re) + 1);
1165 #else
1166 strcpy (ret, re);
1167 #endif
1168
1169 return ret;
1170 }
1171
1172 /* initialize the conversion specifiers */
1173 static void
1174 init_conv_flag (p)
1175 struct DATA *p;
1176 {
1177 p->flags &= PF_ALLOCBUF; /* preserve PF_ALLOCBUF flag */
1178 p->precision = p->width = NOT_FOUND;
1179 p->justify = NOT_FOUND;
1180 p->pad = ' ';
1181 }
1182
1183 static void
1184 init_data (p, string, length, format, mode)
1185 struct DATA *p;
1186 char *string;
1187 size_t length;
1188 const char *format;
1189 int mode;
1190 {
1191 p->length = length - 1; /* leave room for '\0' */
1192 p->holder = p->base = string;
1193 p->pf = format;
1194 p->counter = 0;
1195 p->flags = (mode == PFM_AS) ? PF_ALLOCBUF : 0;
1196 }
1197
1198 static int
1199 #if defined (__STDC__)
1200 vsnprintf_internal(struct DATA *data, char *string, size_t length, const char *format, va_list args)
1201 #else
1202 vsnprintf_internal(data, string, length, format, args)
1203 struct DATA *data;
1204 char *string;
1205 size_t length;
1206 const char *format;
1207 va_list args;
1208 #endif
1209 {
1210 double d; /* temporary holder */
1211 #ifdef HAVE_LONG_DOUBLE
1212 long double ld; /* for later */
1213 #endif
1214 unsigned long ul;
1215 #ifdef HAVE_LONG_LONG
1216 unsigned long long ull;
1217 #endif
1218 int state, i, c, n;
1219 char *s;
1220 #if HANDLE_MULTIBYTE
1221 wchar_t *ws;
1222 wint_t wc;
1223 #endif
1224 const char *convstart;
1225 int negprec;
1226
1227 /* Sanity check, the string length must be >= 0. C99 actually says that
1228 LENGTH can be zero here, in the case of snprintf/vsnprintf (it's never
1229 0 in the case of asprintf/vasprintf), and the return value is the number
1230 of characters that would have been written. */
1231 if (length < 0)
1232 return -1;
1233
1234 if (format == 0)
1235 return 0;
1236
1237 /* Reset these for each call because the locale might have changed. */
1238 decpoint = thoussep = 0;
1239 grouping = 0;
1240
1241 negprec = 0;
1242 for (; c = *(data->pf); data->pf++)
1243 {
1244 if (c != '%')
1245 {
1246 PUT_CHAR (c, data);
1247 continue;
1248 }
1249
1250 convstart = data->pf;
1251 init_conv_flag (data); /* initialise format flags */
1252
1253 state = 1;
1254 for (state = 1; state && *data->pf; )
1255 {
1256 c = *(++data->pf);
1257 /* fmtend = data->pf */
1258 #if defined (FLOATING_POINT) && defined (HAVE_LONG_DOUBLE)
1259 if (data->flags & PF_LONGDBL)
1260 {
1261 switch (c)
1262 {
1263 case 'f': case 'F':
1264 case 'e': case 'E':
1265 case 'g': case 'G':
1266 # ifdef HAVE_PRINTF_A_FORMAT
1267 case 'a': case 'A':
1268 # endif
1269 STAR_ARGS (data);
1270 ld = GETLDOUBLE (data);
1271 ldfallback (data, convstart, data->pf, ld);
1272 goto conv_break;
1273 }
1274 }
1275 #endif /* FLOATING_POINT && HAVE_LONG_DOUBLE */
1276
1277 switch (c)
1278 {
1279 /* Parse format flags */
1280 case '\0': /* a NULL here ? ? bail out */
1281 *data->holder = '\0';
1282 return data->counter;
1283 break;
1284 case '#':
1285 data->flags |= PF_ALTFORM;
1286 continue;
1287 case '0':
1288 data->flags |= PF_ZEROPAD;
1289 data->pad = '0';
1290 continue;
1291 case '*':
1292 if (data->flags & PF_DOT)
1293 data->flags |= PF_STAR_P;
1294 else
1295 data->flags |= PF_STAR_W;
1296 continue;
1297 case '-':
1298 if ((data->flags & PF_DOT) == 0)
1299 {
1300 data->flags |= PF_LADJUST;
1301 data->justify = LEFT;
1302 }
1303 else
1304 negprec = 1;
1305 continue;
1306 case ' ':
1307 if ((data->flags & PF_PLUS) == 0)
1308 data->flags |= PF_SPACE;
1309 continue;
1310 case '+':
1311 if ((data->flags & PF_DOT) == 0)
1312 {
1313 data->flags |= PF_PLUS;
1314 data->justify = RIGHT;
1315 }
1316 continue;
1317 case '\'':
1318 data->flags |= PF_THOUSANDS;
1319 continue;
1320
1321 case '1': case '2': case '3':
1322 case '4': case '5': case '6':
1323 case '7': case '8': case '9':
1324 n = 0;
1325 do
1326 {
1327 n = n * 10 + TODIGIT(c);
1328 c = *(++data->pf);
1329 }
1330 while (DIGIT(c));
1331 data->pf--; /* went too far */
1332 if (n < 0)
1333 n = 0;
1334 if (data->flags & PF_DOT)
1335 data->precision = negprec ? NOT_FOUND : n;
1336 else
1337 data->width = n;
1338 continue;
1339
1340 /* optional precision */
1341 case '.':
1342 data->flags |= PF_DOT;
1343 data->precision = 0;
1344 continue;
1345
1346 /* length modifiers */
1347 case 'h':
1348 data->flags |= (data->flags & PF_SHORTINT) ? PF_SIGNEDCHAR : PF_SHORTINT;
1349 continue;
1350 case 'l':
1351 data->flags |= (data->flags & PF_LONGINT) ? PF_LONGLONG : PF_LONGINT;
1352 continue;
1353 case 'L':
1354 data->flags |= PF_LONGDBL;
1355 continue;
1356 case 'q':
1357 data->flags |= PF_LONGLONG;
1358 continue;
1359 case 'j':
1360 data->flags |= PF_INTMAX_T;
1361 SET_SIZE_FLAGS(data, intmax_t);
1362 continue;
1363 case 'z':
1364 data->flags |= PF_SIZE_T;
1365 SET_SIZE_FLAGS(data, size_t);
1366 continue;
1367 case 't':
1368 data->flags |= PF_PTRDIFF_T;
1369 SET_SIZE_FLAGS(data, ptrdiff_t);
1370 continue;
1371
1372 /* Conversion specifiers */
1373 #ifdef FLOATING_POINT
1374 case 'f': /* float, double */
1375 case 'F':
1376 STAR_ARGS(data);
1377 d = GETDOUBLE(data);
1378 floating(data, d);
1379 conv_break:
1380 state = 0;
1381 break;
1382 case 'g':
1383 case 'G':
1384 STAR_ARGS(data);
1385 DEF_PREC(data);
1386 d = GETDOUBLE(data);
1387 i = (d != 0.) ? log_10(d) : -1;
1388 /*
1389 * for '%g|%G' ANSI: use f if exponent
1390 * is in the range or [-4,p] exclusively
1391 * else use %e|%E
1392 */
1393 if (-4 < i && i < data->precision)
1394 {
1395 /* reset precision */
1396 data->precision -= i + 1;
1397 floating(data, d);
1398 }
1399 else
1400 {
1401 /* reduce precision by 1 because of leading digit before
1402 decimal point in e format. */
1403 data->precision--;
1404 exponent(data, d);
1405 }
1406 state = 0;
1407 break;
1408 case 'e':
1409 case 'E': /* Exponent double */
1410 STAR_ARGS(data);
1411 d = GETDOUBLE(data);
1412 exponent(data, d);
1413 state = 0;
1414 break;
1415 # ifdef HAVE_PRINTF_A_FORMAT
1416 case 'a':
1417 case 'A':
1418 STAR_ARGS(data);
1419 d = GETDOUBLE(data);
1420 dfallback(data, convstart, data->pf, d);
1421 state = 0;
1422 break;
1423 # endif /* HAVE_PRINTF_A_FORMAT */
1424 #endif /* FLOATING_POINT */
1425 case 'U':
1426 data->flags |= PF_LONGINT;
1427 /* FALLTHROUGH */
1428 case 'u':
1429 STAR_ARGS(data);
1430 #ifdef HAVE_LONG_LONG
1431 if (data->flags & PF_LONGLONG)
1432 {
1433 ull = GETARG (unsigned long long);
1434 lnumber(data, ull, 10);
1435 }
1436 else
1437 #endif
1438 {
1439 ul = GETUNSIGNED(data);
1440 number(data, ul, 10);
1441 }
1442 state = 0;
1443 break;
1444 case 'D':
1445 data->flags |= PF_LONGINT;
1446 /* FALLTHROUGH */
1447 case 'd': /* decimal */
1448 case 'i':
1449 STAR_ARGS(data);
1450 #ifdef HAVE_LONG_LONG
1451 if (data->flags & PF_LONGLONG)
1452 {
1453 ull = GETARG (long long);
1454 lnumber(data, ull, 10);
1455 }
1456 else
1457 #endif
1458 {
1459 ul = GETSIGNED(data);
1460 number(data, ul, 10);
1461 }
1462 state = 0;
1463 break;
1464 case 'o': /* octal */
1465 STAR_ARGS(data);
1466 #ifdef HAVE_LONG_LONG
1467 if (data->flags & PF_LONGLONG)
1468 {
1469 ull = GETARG (unsigned long long);
1470 lnumber(data, ull, 8);
1471 }
1472 else
1473 #endif
1474 {
1475 ul = GETUNSIGNED(data);
1476 number(data, ul, 8);
1477 }
1478 state = 0;
1479 break;
1480 case 'x':
1481 case 'X': /* hexadecimal */
1482 STAR_ARGS(data);
1483 #ifdef HAVE_LONG_LONG
1484 if (data->flags & PF_LONGLONG)
1485 {
1486 ull = GETARG (unsigned long long);
1487 lnumber(data, ull, 16);
1488 }
1489 else
1490 #endif
1491 {
1492 ul = GETUNSIGNED(data);
1493 number(data, ul, 16);
1494 }
1495 state = 0;
1496 break;
1497 case 'p':
1498 STAR_ARGS(data);
1499 ul = (unsigned long)GETARG (void *);
1500 pointer(data, ul);
1501 state = 0;
1502 break;
1503 #if HANDLE_MULTIBYTE
1504 case 'C':
1505 data->flags |= PF_LONGINT;
1506 /* FALLTHROUGH */
1507 #endif
1508 case 'c': /* character */
1509 STAR_ARGS(data);
1510 #if HANDLE_MULTIBYTE
1511 if (data->flags & PF_LONGINT)
1512 {
1513 wc = GETARG (wint_t);
1514 wchars (data, wc);
1515 }
1516 else
1517 #endif
1518 {
1519 ul = GETARG (int);
1520 PUT_CHAR(ul, data);
1521 }
1522 state = 0;
1523 break;
1524 #if HANDLE_MULTIBYTE
1525 case 'S':
1526 data->flags |= PF_LONGINT;
1527 /* FALLTHROUGH */
1528 #endif
1529 case 's': /* string */
1530 STAR_ARGS(data);
1531 #if HANDLE_MULTIBYTE
1532 if (data->flags & PF_LONGINT)
1533 {
1534 ws = GETARG (wchar_t *);
1535 wstrings (data, ws);
1536 }
1537 else
1538 #endif
1539 {
1540 s = GETARG (char *);
1541 strings(data, s);
1542 }
1543 state = 0;
1544 break;
1545 case 'n':
1546 #ifdef HAVE_LONG_LONG
1547 if (data->flags & PF_LONGLONG)
1548 *(GETARG (long long *)) = data->counter;
1549 else
1550 #endif
1551 if (data->flags & PF_LONGINT)
1552 *(GETARG (long *)) = data->counter;
1553 else if (data->flags & PF_SHORTINT)
1554 *(GETARG (short *)) = data->counter;
1555 else
1556 *(GETARG (int *)) = data->counter;
1557 state = 0;
1558 break;
1559 case '%': /* nothing just % */
1560 PUT_CHAR('%', data);
1561 state = 0;
1562 break;
1563 default:
1564 /* is this an error ? maybe bail out */
1565 state = 0;
1566 break;
1567 } /* end switch */
1568 } /* end of `%' for loop */
1569 } /* end of format string for loop */
1570
1571 if (data->length >= 0)
1572 *data->holder = '\0'; /* the end ye ! */
1573
1574 return data->counter;
1575 }
1576
1577 #if defined (FLOATING_POINT) && defined (HAVE_LONG_DOUBLE)
1578 /*
1579 * Printing floating point numbers accurately is an art. I'm not good
1580 * at it. Fall back to sprintf for long double formats.
1581 */
1582 static void
1583 ldfallback (data, fs, fe, ld)
1584 struct DATA *data;
1585 const char *fs, *fe;
1586 long double ld;
1587 {
1588 register char *x;
1589 char fmtbuf[FALLBACK_FMTSIZE], *obuf;
1590 int fl;
1591
1592 fl = LFALLBACK_BASE + (data->precision < 6 ? 6 : data->precision) + 2;
1593 obuf = (char *)xmalloc (fl);
1594 fl = fe - fs + 1;
1595 strncpy (fmtbuf, fs, fl);
1596 fmtbuf[fl] = '\0';
1597
1598 if ((data->flags & PF_STAR_W) && (data->flags & PF_STAR_P))
1599 sprintf (obuf, fmtbuf, data->width, data->precision, ld);
1600 else if (data->flags & PF_STAR_W)
1601 sprintf (obuf, fmtbuf, data->width, ld);
1602 else if (data->flags & PF_STAR_P)
1603 sprintf (obuf, fmtbuf, data->precision, ld);
1604 else
1605 sprintf (obuf, fmtbuf, ld);
1606
1607 for (x = obuf; *x; x++)
1608 PUT_CHAR (*x, data);
1609 xfree (obuf);
1610 }
1611 #endif /* FLOATING_POINT && HAVE_LONG_DOUBLE */
1612
1613 #ifdef FLOATING_POINT
1614 /* Used for %a, %A if the libc printf supports them. */
1615 static void
1616 dfallback (data, fs, fe, d)
1617 struct DATA *data;
1618 const char *fs, *fe;
1619 double d;
1620 {
1621 register char *x;
1622 char fmtbuf[FALLBACK_FMTSIZE], obuf[FALLBACK_BASE];
1623 int fl;
1624
1625 fl = fe - fs + 1;
1626 strncpy (fmtbuf, fs, fl);
1627 fmtbuf[fl] = '\0';
1628
1629 if ((data->flags & PF_STAR_W) && (data->flags & PF_STAR_P))
1630 sprintf (obuf, fmtbuf, data->width, data->precision, d);
1631 else if (data->flags & PF_STAR_W)
1632 sprintf (obuf, fmtbuf, data->width, d);
1633 else if (data->flags & PF_STAR_P)
1634 sprintf (obuf, fmtbuf, data->precision, d);
1635 else
1636 sprintf (obuf, fmtbuf, d);
1637
1638 for (x = obuf; *x; x++)
1639 PUT_CHAR (*x, data);
1640 }
1641 #endif /* FLOATING_POINT */
1642
1643 #ifndef HAVE_SNPRINTF
1644
1645 int
1646 #if defined (__STDC__)
1647 vsnprintf(char *string, size_t length, const char *format, va_list args)
1648 #else
1649 vsnprintf(string, length, format, args)
1650 char *string;
1651 size_t length;
1652 const char *format;
1653 va_list args;
1654 #endif
1655 {
1656 struct DATA data;
1657
1658 if (string == 0 && length != 0)
1659 return 0;
1660 init_data (&data, string, length, format, PFM_SN);
1661 return (vsnprintf_internal(&data, string, length, format, args));
1662 }
1663
1664 int
1665 #if defined(PREFER_STDARG)
1666 snprintf(char *string, size_t length, const char * format, ...)
1667 #else
1668 snprintf(string, length, format, va_alist)
1669 char *string;
1670 size_t length;
1671 const char *format;
1672 va_dcl
1673 #endif
1674 {
1675 struct DATA data;
1676 int rval;
1677 va_list args;
1678
1679 SH_VA_START(args, format);
1680
1681 if (string == 0 && length != 0)
1682 return 0;
1683 init_data (&data, string, length, format, PFM_SN);
1684 rval = vsnprintf_internal (&data, string, length, format, args);
1685
1686 va_end(args);
1687
1688 return rval;
1689 }
1690
1691 #endif /* HAVE_SNPRINTF */
1692
1693 #ifndef HAVE_ASPRINTF
1694
1695 int
1696 #if defined (__STDC__)
1697 vasprintf(char **stringp, const char *format, va_list args)
1698 #else
1699 vasprintf(stringp, format, args)
1700 char **stringp;
1701 const char *format;
1702 va_list args;
1703 #endif
1704 {
1705 struct DATA data;
1706 char *string;
1707 int r;
1708
1709 string = (char *)xmalloc(ASBUFSIZE);
1710 init_data (&data, string, ASBUFSIZE, format, PFM_AS);
1711 r = vsnprintf_internal(&data, string, ASBUFSIZE, format, args);
1712 *stringp = data.base; /* not string in case reallocated */
1713 return r;
1714 }
1715
1716 int
1717 #if defined(PREFER_STDARG)
1718 asprintf(char **stringp, const char * format, ...)
1719 #else
1720 asprintf(stringp, format, va_alist)
1721 char **stringp;
1722 const char *format;
1723 va_dcl
1724 #endif
1725 {
1726 int rval;
1727 va_list args;
1728
1729 SH_VA_START(args, format);
1730
1731 rval = vasprintf (stringp, format, args);
1732
1733 va_end(args);
1734
1735 return rval;
1736 }
1737
1738 #endif
1739
1740 #endif
1741
1742 #ifdef DRIVER
1743
1744 static void
1745 memory_error_and_abort ()
1746 {
1747 write (2, "out of virtual memory\n", 22);
1748 abort ();
1749 }
1750
1751 static void *
1752 xmalloc(bytes)
1753 size_t bytes;
1754 {
1755 void *ret;
1756
1757 ret = malloc(bytes);
1758 if (ret == 0)
1759 memory_error_and_abort ();
1760 return ret;
1761 }
1762
1763 static void *
1764 xrealloc (pointer, bytes)
1765 void *pointer;
1766 size_t bytes;
1767 {
1768 void *ret;
1769
1770 ret = pointer ? realloc(pointer, bytes) : malloc(bytes);
1771 if (ret == 0)
1772 memory_error_and_abort ();
1773 return ret;
1774 }
1775
1776 static void
1777 xfree(x)
1778 void *x;
1779 {
1780 if (x)
1781 free (x);
1782 }
1783
1784 /* set of small tests for snprintf() */
1785 main()
1786 {
1787 char holder[100];
1788 char *h;
1789 int i, si, ai;
1790
1791 #ifdef HAVE_LOCALE_H
1792 setlocale(LC_ALL, "");
1793 #endif
1794
1795 #if 1
1796 si = snprintf((char *)NULL, 0, "abcde\n");
1797 printf("snprintf returns %d with NULL first argument and size of 0\n", si);
1798 si = snprintf(holder, 0, "abcde\n");
1799 printf("snprintf returns %d with non-NULL first argument and size of 0\n", si);
1800 si = snprintf((char *)NULL, 16, "abcde\n");
1801 printf("snprintf returns %d with NULL first argument and non-zero size\n", si);
1802
1803 /*
1804 printf("Suite of test for snprintf:\n");
1805 printf("a_format\n");
1806 printf("printf() format\n");
1807 printf("snprintf() format\n\n");
1808 */
1809 /* Checking the field widths */
1810
1811 printf("/%%ld %%ld/, 336, 336\n");
1812 snprintf(holder, sizeof holder, "/%ld %ld/\n", 336, 336);
1813 asprintf(&h, "/%ld %ld/\n", 336, 336);
1814 printf("/%ld %ld/\n", 336, 336);
1815 printf("%s", holder);
1816 printf("%s\n", h);
1817
1818 printf("/%%d/, 336\n");
1819 snprintf(holder, sizeof holder, "/%d/\n", 336);
1820 asprintf(&h, "/%d/\n", 336);
1821 printf("/%d/\n", 336);
1822 printf("%s", holder);
1823 printf("%s\n", h);
1824
1825 printf("/%%2d/, 336\n");
1826 snprintf(holder, sizeof holder, "/%2d/\n", 336);
1827 asprintf(&h, "/%2d/\n", 336);
1828 printf("/%2d/\n", 336);
1829 printf("%s", holder);
1830 printf("%s\n", h);
1831
1832 printf("/%%10d/, 336\n");
1833 snprintf(holder, sizeof holder, "/%10d/\n", 336);
1834 asprintf(&h, "/%10d/\n", 336);
1835 printf("/%10d/\n", 336);
1836 printf("%s", holder);
1837 printf("%s\n", h);
1838
1839 printf("/%%-10d/, 336\n");
1840 snprintf(holder, sizeof holder, "/%-10d/\n", 336);
1841 asprintf(&h, "/%-10d/\n", 336);
1842 printf("/%-10d/\n", 336);
1843 printf("%s", holder);
1844 printf("%s\n", h);
1845
1846
1847 /* floating points */
1848
1849 printf("/%%f/, 1234.56\n");
1850 snprintf(holder, sizeof holder, "/%f/\n", 1234.56);
1851 asprintf(&h, "/%f/\n", 1234.56);
1852 printf("/%f/\n", 1234.56);
1853 printf("%s", holder);
1854 printf("%s\n", h);
1855
1856 printf("/%%e/, 1234.56\n");
1857 snprintf(holder, sizeof holder, "/%e/\n", 1234.56);
1858 asprintf(&h, "/%e/\n", 1234.56);
1859 printf("/%e/\n", 1234.56);
1860 printf("%s", holder);
1861 printf("%s\n", h);
1862
1863 printf("/%%4.2f/, 1234.56\n");
1864 snprintf(holder, sizeof holder, "/%4.2f/\n", 1234.56);
1865 asprintf(&h, "/%4.2f/\n", 1234.56);
1866 printf("/%4.2f/\n", 1234.56);
1867 printf("%s", holder);
1868 printf("%s\n", h);
1869
1870 printf("/%%3.1f/, 1234.56\n");
1871 snprintf(holder, sizeof holder, "/%3.1f/\n", 1234.56);
1872 asprintf(&h, "/%3.1f/\n", 1234.56);
1873 printf("/%3.1f/\n", 1234.56);
1874 printf("%s", holder);
1875 printf("%s\n", h);
1876
1877 printf("/%%10.3f/, 1234.56\n");
1878 snprintf(holder, sizeof holder, "/%10.3f/\n", 1234.56);
1879 asprintf(&h, "/%10.3f/\n", 1234.56);
1880 printf("/%10.3f/\n", 1234.56);
1881 printf("%s", holder);
1882 printf("%s\n", h);
1883
1884 printf("/%%10.3e/, 1234.56\n");
1885 snprintf(holder, sizeof holder, "/%10.3e/\n", 1234.56);
1886 asprintf(&h, "/%10.3e/\n", 1234.56);
1887 printf("/%10.3e/\n", 1234.56);
1888 printf("%s", holder);
1889 printf("%s\n", h);
1890
1891 printf("/%%+4.2f/, 1234.56\n");
1892 snprintf(holder, sizeof holder, "/%+4.2f/\n", 1234.56);
1893 asprintf(&h, "/%+4.2f/\n", 1234.56);
1894 printf("/%+4.2f/\n", 1234.56);
1895 printf("%s", holder);
1896 printf("%s\n", h);
1897
1898 printf("/%%010.2f/, 1234.56\n");
1899 snprintf(holder, sizeof holder, "/%010.2f/\n", 1234.56);
1900 asprintf(&h, "/%010.2f/\n", 1234.56);
1901 printf("/%010.2f/\n", 1234.56);
1902 printf("%s", holder);
1903 printf("%s\n", h);
1904
1905 #define BLURB "Outstanding acting !"
1906 /* strings precisions */
1907
1908 printf("/%%2s/, \"%s\"\n", BLURB);
1909 snprintf(holder, sizeof holder, "/%2s/\n", BLURB);
1910 asprintf(&h, "/%2s/\n", BLURB);
1911 printf("/%2s/\n", BLURB);
1912 printf("%s", holder);
1913 printf("%s\n", h);
1914
1915 printf("/%%22s/ %s\n", BLURB);
1916 snprintf(holder, sizeof holder, "/%22s/\n", BLURB);
1917 asprintf(&h, "/%22s/\n", BLURB);
1918 printf("/%22s/\n", BLURB);
1919 printf("%s", holder);
1920 printf("%s\n", h);
1921
1922 printf("/%%22.5s/ %s\n", BLURB);
1923 snprintf(holder, sizeof holder, "/%22.5s/\n", BLURB);
1924 asprintf(&h, "/%22.5s/\n", BLURB);
1925 printf("/%22.5s/\n", BLURB);
1926 printf("%s", holder);
1927 printf("%s\n", h);
1928
1929 printf("/%%-22.5s/ %s\n", BLURB);
1930 snprintf(holder, sizeof holder, "/%-22.5s/\n", BLURB);
1931 asprintf(&h, "/%-22.5s/\n", BLURB);
1932 printf("/%-22.5s/\n", BLURB);
1933 printf("%s", holder);
1934 printf("%s\n", h);
1935
1936 /* see some flags */
1937
1938 printf("%%x %%X %%#x, 31, 31, 31\n");
1939 snprintf(holder, sizeof holder, "%x %X %#x\n", 31, 31, 31);
1940 asprintf(&h, "%x %X %#x\n", 31, 31, 31);
1941 printf("%x %X %#x\n", 31, 31, 31);
1942 printf("%s", holder);
1943 printf("%s\n", h);
1944
1945 printf("**%%d**%% d**%% d**, 42, 42, -42\n");
1946 snprintf(holder, sizeof holder, "**%d**% d**% d**\n", 42, 42, -42);
1947 asprintf(&h, "**%d**% d**% d**\n", 42, 42, -42);
1948 printf("**%d**% d**% d**\n", 42, 42, -42);
1949 printf("%s", holder);
1950 printf("%s\n", h);
1951
1952 /* other flags */
1953
1954 printf("/%%g/, 31.4\n");
1955 snprintf(holder, sizeof holder, "/%g/\n", 31.4);
1956 asprintf(&h, "/%g/\n", 31.4);
1957 printf("/%g/\n", 31.4);
1958 printf("%s", holder);
1959 printf("%s\n", h);
1960
1961 printf("/%%.6g/, 31.4\n");
1962 snprintf(holder, sizeof holder, "/%.6g/\n", 31.4);
1963 asprintf(&h, "/%.6g/\n", 31.4);
1964 printf("/%.6g/\n", 31.4);
1965 printf("%s", holder);
1966 printf("%s\n", h);
1967
1968 printf("/%%.1G/, 31.4\n");
1969 snprintf(holder, sizeof holder, "/%.1G/\n", 31.4);
1970 asprintf(&h, "/%.1G/\n", 31.4);
1971 printf("/%.1G/\n", 31.4);
1972 printf("%s", holder);
1973 printf("%s\n", h);
1974
1975 printf("/%%.1G/, 3100000000.4\n");
1976 snprintf(holder, sizeof holder, "/%.1G/\n", 3100000000.4);
1977 asprintf(&h, "/%.1G/\n", 3100000000.4);
1978 printf("/%.1G/\n", 3100000000.4);
1979 printf("%s", holder);
1980 printf("%s\n", h);
1981
1982 printf("abc%%n\n");
1983 printf("abc%n", &i); printf("%d\n", i);
1984 snprintf(holder, sizeof holder, "abc%n", &i);
1985 printf("%s", holder); printf("%d\n\n", i);
1986 asprintf(&h, "abc%n", &i);
1987 printf("%s", h); printf("%d\n\n", i);
1988
1989 printf("%%*.*s --> 10.10\n");
1990 snprintf(holder, sizeof holder, "%*.*s\n", 10, 10, BLURB);
1991 asprintf(&h, "%*.*s\n", 10, 10, BLURB);
1992 printf("%*.*s\n", 10, 10, BLURB);
1993 printf("%s", holder);
1994 printf("%s\n", h);
1995
1996 printf("%%%%%%%%\n");
1997 snprintf(holder, sizeof holder, "%%%%\n");
1998 asprintf(&h, "%%%%\n");
1999 printf("%%%%\n");
2000 printf("%s", holder);
2001 printf("%s\n", h);
2002
2003 #define BIG "Hello this is a too big string for the buffer"
2004 /* printf("A buffer to small of 10, trying to put this:\n");*/
2005 printf("<%%>, %s\n", BIG);
2006 i = snprintf(holder, 10, "%s\n", BIG);
2007 i = asprintf(&h, "%s", BIG);
2008 printf("<%s>\n", BIG);
2009 printf("<%s>\n", holder);
2010 printf("<%s>\n\n", h);
2011
2012 printf ("<%%p> vsnprintf\n");
2013 i = snprintf(holder, 100, "%p", vsnprintf);
2014 i = asprintf(&h, "%p", vsnprintf);
2015 printf("<%p>\n", vsnprintf);
2016 printf("<%s>\n", holder);
2017 printf("<%s>\n\n", h);
2018
2019 printf ("<%%lu> LONG_MAX+1\n");
2020 i = snprintf(holder, 100, "%lu", (unsigned long)(LONG_MAX)+1);
2021 i = asprintf(&h, "%lu", (unsigned long)(LONG_MAX)+1);
2022 printf("<%lu>\n", (unsigned long)(LONG_MAX)+1);
2023 printf("<%s>\n", holder);
2024 printf("<%s>\n\n", h);
2025
2026 #ifdef HAVE_LONG_LONG
2027 printf ("<%%llu> LLONG_MAX+1\n");
2028 i = snprintf(holder, 100, "%llu", (unsigned long long)(LLONG_MAX)+1);
2029 i = asprintf(&h, "%llu", (unsigned long long)(LLONG_MAX)+1);
2030 printf("<%llu>\n", (unsigned long long)(LLONG_MAX)+1);
2031 printf("<%s>\n", holder);
2032 printf("<%s>\n\n", h);
2033 #endif
2034
2035 #ifdef HAVE_LONG_DOUBLE
2036 printf ("<%%6.2LE> 42.42\n");
2037 i = snprintf(holder, 100, "%6.2LE", (long double)42.42);
2038 i = asprintf(&h, "%6.2LE", (long double)42.42);
2039 printf ("<%6.2LE>\n", (long double)42.42);
2040 printf ("<%s>\n", holder);
2041 printf ("<%s>\n\n", h);
2042 #endif
2043
2044 #ifdef HAVE_PRINTF_A_FORMAT
2045 printf ("<%%6.2A> 42.42\n");
2046 i = snprintf(holder, 100, "%6.2A", 42.42);
2047 i = asprintf(&h, "%6.2A", 42.42);
2048 printf ("<%6.2A>\n", 42.42);
2049 printf ("<%s>\n", holder);
2050 printf ("<%s>\n\n", h);
2051
2052 printf ("<%%6.2LA> 42.42\n");
2053 i = snprintf(holder, 100, "%6.2LA", (long double)42.42);
2054 i = asprintf(&h, "%6.2LA", (long double)42.42);
2055 printf ("<%6.2LA>\n", (long double)42.42);
2056 printf ("<%s>\n", holder);
2057 printf ("<%s>\n\n", h);
2058 #endif
2059
2060 printf ("<%%.10240f> DBL_MAX\n");
2061 si = snprintf(holder, 100, "%.10240f", DBL_MAX);
2062 ai = asprintf(&h, "%.10240f", DBL_MAX);
2063 printf ("<%.10240f>\n", DBL_MAX);
2064 printf ("<%d> <%s>\n", si, holder);
2065 printf ("<%d> <%s>\n\n", ai, h);
2066
2067 printf ("<%%.10240Lf> LDBL_MAX\n");
2068 si = snprintf(holder, 100, "%.10240Lf", (long double)LDBL_MAX);
2069 ai = asprintf(&h, "%.10240Lf", (long double)LDBL_MAX);
2070 printf ("<%.10240Lf>\n", (long double)LDBL_MAX);
2071 printf ("<%d> <%s>\n", si, holder);
2072 printf ("<%d> <%s>\n\n", ai, h);
2073
2074 /* huh? */
2075 printf("/%%g/, 421.2345\n");
2076 snprintf(holder, sizeof holder, "/%g/\n", 421.2345);
2077 asprintf(&h, "/%g/\n", 421.2345);
2078 printf("/%g/\n", 421.2345);
2079 printf("%s", holder);
2080 printf("%s\n", h);
2081
2082 printf("/%%g/, 4214.2345\n");
2083 snprintf(holder, sizeof holder, "/%g/\n", 4214.2345);
2084 asprintf(&h, "/%g/\n", 4214.2345);
2085 printf("/%g/\n", 4214.2345);
2086 printf("%s", holder);
2087 printf("%s\n", h);
2088
2089 printf("/%%.5g/, 4214.2345\n");
2090 snprintf(holder, sizeof holder, "/%.5g/\n", 4214.2345);
2091 asprintf(&h, "/%.5g/\n", 4214.2345);
2092 printf("/%.5g/\n", 4214.2345);
2093 printf("%s", holder);
2094 printf("%s\n", h);
2095
2096 printf("/%%.4g/, 4214.2345\n");
2097 snprintf(holder, sizeof holder, "/%.4g/\n", 4214.2345);
2098 asprintf(&h, "/%.4g/\n", 4214.2345);
2099 printf("/%.4g/\n", 4214.2345);
2100 printf("%s", holder);
2101 printf("%s\n", h);
2102
2103 printf("/%%'ld %%'ld/, 12345, 1234567\n");
2104 snprintf(holder, sizeof holder, "/%'ld %'ld/\n", 12345, 1234567);
2105 asprintf(&h, "/%'ld %'ld/\n", 12345, 1234567);
2106 printf("/%'ld %'ld/\n", 12345, 1234567);
2107 printf("%s", holder);
2108 printf("%s\n", h);
2109
2110 printf("/%%'ld %%'ld/, 336, 3336\n");
2111 snprintf(holder, sizeof holder, "/%'ld %'ld/\n", 336, 3336);
2112 asprintf(&h, "/%'ld %'ld/\n", 336, 3336);
2113 printf("/%'ld %'ld/\n", 336, 3336);
2114 printf("%s", holder);
2115 printf("%s\n", h);
2116
2117 printf("/%%'ld %%'ld/, -42786, -142786\n");
2118 snprintf(holder, sizeof holder, "/%'ld %'ld/\n", -42786, -142786);
2119 asprintf(&h, "/%'ld %'ld/\n", -42786, -142786);
2120 printf("/%'ld %'ld/\n", -42786, -142786);
2121 printf("%s", holder);
2122 printf("%s\n", h);
2123
2124 printf("/%%'f %%'f/, 421.2345, 421234.56789\n");
2125 snprintf(holder, sizeof holder, "/%'f %'f/\n", 421.2345, 421234.56789);
2126 asprintf(&h, "/%'f %'f/\n", 421.2345, 421234.56789);
2127 printf("/%'f %'f/\n", 421.2345, 421234.56789);
2128 printf("%s", holder);
2129 printf("%s\n", h);
2130
2131 printf("/%%'f %%'f/, -421.2345, -421234.56789\n");
2132 snprintf(holder, sizeof holder, "/%'f %'f/\n", -421.2345, -421234.56789);
2133 asprintf(&h, "/%'f %'f/\n", -421.2345, -421234.56789);
2134 printf("/%'f %'f/\n", -421.2345, -421234.56789);
2135 printf("%s", holder);
2136 printf("%s\n", h);
2137
2138 printf("/%%'g %%'g/, 421.2345, 421234.56789\n");
2139 snprintf(holder, sizeof holder, "/%'g %'g/\n", 421.2345, 421234.56789);
2140 asprintf(&h, "/%'g %'g/\n", 421.2345, 421234.56789);
2141 printf("/%'g %'g/\n", 421.2345, 421234.56789);
2142 printf("%s", holder);
2143 printf("%s\n", h);
2144
2145 printf("/%%'g %%'g/, -421.2345, -421234.56789\n");
2146 snprintf(holder, sizeof holder, "/%'g %'g/\n", -421.2345, -421234.56789);
2147 asprintf(&h, "/%'g %'g/\n", -421.2345, -421234.56789);
2148 printf("/%'g %'g/\n", -421.2345, -421234.56789);
2149 printf("%s", holder);
2150 printf("%s\n", h);
2151 #endif
2152
2153 printf("/%%'g/, 4213455.8392\n");
2154 snprintf(holder, sizeof holder, "/%'g/\n", 4213455.8392);
2155 asprintf(&h, "/%'g/\n", 4213455.8392);
2156 printf("/%'g/\n", 4213455.8392);
2157 printf("%s", holder);
2158 printf("%s\n", h);
2159
2160 exit (0);
2161 }
2162 #endif
Unnamed repository; edit this file 'description' to name the repository.