?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* gpg.texi (GPG Esoteric Options): Tweak mention of Tempest font to
[gnupg.git] / common / estream-printf.c
blob754be260d10207e309d178e2f7fb21461f9f1b22
1 /* estream-printf.c - Versatile C-99 compliant printf formatting
2 * Copyright (C) 2007 g10 Code GmbH
3 *
4 * This file is part of Libestream.
5 *
6 * Libestream is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published
8 * by the Free Software Foundation; either version 2 of the License,
9 * or (at your option) any later version.
10 *
11 * Libestream is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with Libestream; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 /* Required autoconf tests:
21
22 AC_TYPE_LONG_LONG_INT defines HAVE_LONG_LONG_INT
23 AC_TYPE_LONG_DOUBLE defines HAVE_LONG_DOUBLE
24 AC_TYPE_INTMAX_T defines HAVE_INTMAX_T
25 AC_TYPE_UINTMAX_T defines HAVE_UINTMAX_T
26 AC_CHECK_TYPES([ptrdiff_t]) defines HAVE_PTRDIFF_T
27 AC_CHECK_SIZEOF([unsigned long]) defines SIZEOF_UNSIGNED_LONG
28 AC_CHECK_SIZEOF([void *]) defines SIZEOF_VOID_P
29 HAVE_LANGINFO_THOUSANDS_SEP
30
31 Note that the file estream.m4 provides the autoconf macro
32 ESTREAM_PRINTF_INIT which runs all required checks.
33 See estream-printf.h for ways to tune this code.
34
35 Missing stuff: wchar and wint_t
36 thousands_sep in pr_float.
37 */
38
39 #ifdef HAVE_CONFIG_H
40 # include <config.h>
41 #endif
42
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <unistd.h>
47 #include <stdarg.h>
48 #include <errno.h>
49 #include <stddef.h>
50 #include <assert.h>
51 #if defined(HAVE_INTMAX_T) || defined(HAVE_UINTMAX_T)
52 # include <stdint.h>
53 #endif
54 #ifdef HAVE_LANGINFO_THOUSANDS_SEP
55 #include <langinfo.h>
56 #endif
57 #ifdef TEST
58 # include <locale.h>
59 #else
60 # ifdef _ESTREAM_PRINTF_EXTRA_INCLUDE
61 # include _ESTREAM_PRINTF_EXTRA_INCLUDE
62 # endif
63 #endif
64 #include "estream-printf.h"
65
66 /* Allow redefinition of asprintf used malloc functions. */
67 #if defined(_ESTREAM_PRINTF_MALLOC) && !defined(TEST)
68 #define my_printf_malloc(a) _ESTREAM_PRINTF_MALLOC((a))
69 #else
70 #define my_printf_malloc(a) malloc((a))
71 #endif
72 #if defined(_ESTREAM_PRINTF_FREE) && !defined(TEST)
73 #define my_printf_free(a) _ESTREAM_PRINTF_FREE((a))
74 #else
75 #define my_printf_free(a) free((a))
76 #endif
77
78
79 /* Calculate array dimension. */
80 #ifndef DIM
81 #define DIM(array) (sizeof (array) / sizeof (*array))
82 #endif
83
84
85 /* We allow for that many args without requiring malloced memory. */
86 #define DEFAULT_MAX_ARGSPECS 5
87
88 /* We allow for that many values without requiring malloced memory. */
89 #define DEFAULT_MAX_VALUES 8
90
91 /* We allocate this many new array argspec elements each time. */
92 #define ARGSPECS_BUMP_VALUE 10
93
94 /* Special values for the field width and the precision. */
95 #define NO_FIELD_VALUE (-1)
96 #define STAR_FIELD_VALUE (-2)
97
98 /* Bit valuues used for the conversion flags. */
99 #define FLAG_GROUPING 1
100 #define FLAG_LEFT_JUST 2
101 #define FLAG_PLUS_SIGN 4
102 #define FLAG_SPACE_PLUS 8
103 #define FLAG_ALT_CONV 16
104 #define FLAG_ZERO_PAD 32
105
106 /* Constants used the length modifiers. */
107 typedef enum
108 {
109 LENMOD_NONE = 0,
110 LENMOD_CHAR, /* "hh" */
111 LENMOD_SHORT, /* "h" */
112 LENMOD_LONG, /* "l" */
113 LENMOD_LONGLONG, /* "ll" */
114 LENMOD_INTMAX, /* "j" */
115 LENMOD_SIZET, /* "z" */
116 LENMOD_PTRDIFF, /* "t" */
117 LENMOD_LONGDBL /* "L" */
118 } lenmod_t;
119
120 /* All the conversion specifiers. */
121 typedef enum
122 {
123 CONSPEC_UNKNOWN = 0,
124 CONSPEC_DECIMAL,
125 CONSPEC_OCTAL,
126 CONSPEC_UNSIGNED,
127 CONSPEC_HEX,
128 CONSPEC_HEX_UP,
129 CONSPEC_FLOAT,
130 CONSPEC_FLOAT_UP,
131 CONSPEC_EXP,
132 CONSPEC_EXP_UP,
133 CONSPEC_F_OR_G,
134 CONSPEC_F_OR_G_UP,
135 CONSPEC_HEX_EXP,
136 CONSPEC_HEX_EXP_UP,
137 CONSPEC_CHAR,
138 CONSPEC_STRING,
139 CONSPEC_POINTER,
140 CONSPEC_STRERROR,
141 CONSPEC_BYTES_SO_FAR
142 } conspec_t;
143
144
145 /* Constants describing all the suppoorted types. Note that we list
146 all the types we know about even if certain types are not available
147 on this system. */
148 typedef enum
149 {
150 VALTYPE_UNSUPPORTED = 0, /* Artificial type for error detection. */
151 VALTYPE_CHAR,
152 VALTYPE_SCHAR,
153 VALTYPE_UCHAR,
154 VALTYPE_SHORT,
155 VALTYPE_USHORT,
156 VALTYPE_INT,
157 VALTYPE_UINT,
158 VALTYPE_LONG,
159 VALTYPE_ULONG,
160 VALTYPE_LONGLONG,
161 VALTYPE_ULONGLONG,
162 VALTYPE_DOUBLE,
163 VALTYPE_LONGDOUBLE,
164 VALTYPE_STRING,
165 VALTYPE_INTMAX,
166 VALTYPE_UINTMAX,
167 VALTYPE_SIZE,
168 VALTYPE_PTRDIFF,
169 VALTYPE_POINTER,
170 VALTYPE_CHAR_PTR,
171 VALTYPE_SCHAR_PTR,
172 VALTYPE_SHORT_PTR,
173 VALTYPE_INT_PTR,
174 VALTYPE_LONG_PTR,
175 VALTYPE_LONGLONG_PTR,
176 VALTYPE_INTMAX_PTR,
177 VALTYPE_SIZE_PTR,
178 VALTYPE_PTRDIFF_PTR
179 } valtype_t;
180
181
182 /* A union used to store the actual values. */
183 typedef union
184 {
185 char a_char;
186 signed char a_schar;
187 unsigned char a_uchar;
188 short a_short;
189 unsigned short a_ushort;
190 int a_int;
191 unsigned int a_uint;
192 long int a_long;
193 unsigned long int a_ulong;
194 #ifdef HAVE_LONG_LONG_INT
195 long long int a_longlong;
196 unsigned long long int a_ulonglong;
197 #endif
198 double a_double;
199 #ifdef HAVE_LONG_DOUBLE
200 long double a_longdouble;
201 #endif
202 const char *a_string;
203 #ifdef HAVE_INTMAX_T
204 intmax_t a_intmax;
205 #endif
206 #ifdef HAVE_UINTMAX_T
207 intmax_t a_uintmax;
208 #endif
209 size_t a_size;
210 #ifdef HAVE_PTRDIFF_T
211 ptrdiff_t a_ptrdiff;
212 #endif
213 void *a_void_ptr;
214 char *a_char_ptr;
215 signed char *a_schar_ptr;
216 short *a_short_ptr;
217 int *a_int_ptr;
218 long *a_long_ptr;
219 #ifdef HAVE_LONG_LONG_INT
220 long long int *a_longlong_ptr;
221 #endif
222 #ifdef HAVE_INTMAX_T
223 intmax_t *a_intmax_ptr;
224 #endif
225 size_t *a_size_ptr;
226 #ifdef HAVE_PTRDIFF_T
227 ptrdiff_t *a_ptrdiff_ptr;
228 #endif
229 } value_t;
230
231 /* An object used to keep track of a format option and arguments. */
232 struct argspec_s
233 {
234 size_t length; /* The length of these args including the percent. */
235 unsigned int flags; /* The conversion flags (bits defined by FLAG_foo). */
236 int width; /* The field width. */
237 int precision; /* The precision. */
238 lenmod_t lenmod; /* The length modifier. */
239 conspec_t conspec; /* The conversion specifier. */
240 int arg_pos; /* The position of the argument. This one may
241 be -1 to indicate that no value is expected
242 (e.g. for "%m"). */
243 int width_pos; /* The position of the argument for a field
244 width star's value. 0 for not used. */
245 int precision_pos; /* The position of the argument for the a
246 precision star's value. 0 for not used. */
247 valtype_t vt; /* The type of the corresponding argument. */
248 };
249 typedef struct argspec_s *argspec_t;
250
251 /* An object to build up a table of values and their types. */
252 struct valueitem_s
253 {
254 valtype_t vt; /* The type of the value. */
255 value_t value; /* The value. */
256 };
257 typedef struct valueitem_s *valueitem_t;
258
259
260 #ifdef TEST
261 static int verbose;
262
263 static void
264 dump_argspecs (argspec_t arg, size_t argcount)
265 {
266 int idx;
267
268 for (idx=0; argcount; argcount--, arg++, idx++)
269 fprintf (stderr,
270 "%2d: len=%u flags=%u width=%d prec=%d mod=%d "
271 "con=%d vt=%d pos=%d-%d-%d\n",
272 idx,
273 (unsigned int)arg->length,
274 arg->flags,
275 arg->width,
276 arg->precision,
277 arg->lenmod,
278 arg->conspec,
279 arg->vt,
280 arg->arg_pos,
281 arg->width_pos,
282 arg->precision_pos);
283 }
284 #endif /*TEST*/
285
286
287 /* Set the vt field for ARG. */
288 static void
289 compute_type (argspec_t arg)
290 {
291 switch (arg->conspec)
292 {
293 case CONSPEC_UNKNOWN:
294 arg->vt = VALTYPE_UNSUPPORTED;
295 break;
296
297 case CONSPEC_DECIMAL:
298 switch (arg->lenmod)
299 {
300 case LENMOD_CHAR: arg->vt = VALTYPE_SCHAR; break;
301 case LENMOD_SHORT: arg->vt = VALTYPE_SHORT; break;
302 case LENMOD_LONG: arg->vt = VALTYPE_LONG; break;
303 case LENMOD_LONGLONG: arg->vt = VALTYPE_LONGLONG; break;
304 case LENMOD_INTMAX: arg->vt = VALTYPE_INTMAX; break;
305 case LENMOD_SIZET: arg->vt = VALTYPE_SIZE; break;
306 case LENMOD_PTRDIFF: arg->vt = VALTYPE_PTRDIFF; break;
307 default: arg->vt = VALTYPE_INT; break;
308 }
309 break;
310
311 case CONSPEC_OCTAL:
312 case CONSPEC_UNSIGNED:
313 case CONSPEC_HEX:
314 case CONSPEC_HEX_UP:
315 switch (arg->lenmod)
316 {
317 case LENMOD_CHAR: arg->vt = VALTYPE_UCHAR; break;
318 case LENMOD_SHORT: arg->vt = VALTYPE_USHORT; break;
319 case LENMOD_LONG: arg->vt = VALTYPE_ULONG; break;
320 case LENMOD_LONGLONG: arg->vt = VALTYPE_ULONGLONG; break;
321 case LENMOD_INTMAX: arg->vt = VALTYPE_UINTMAX; break;
322 case LENMOD_SIZET: arg->vt = VALTYPE_SIZE; break;
323 case LENMOD_PTRDIFF: arg->vt = VALTYPE_PTRDIFF; break;
324 default: arg->vt = VALTYPE_UINT; break;
325 }
326 break;
327
328 case CONSPEC_FLOAT:
329 case CONSPEC_FLOAT_UP:
330 case CONSPEC_EXP:
331 case CONSPEC_EXP_UP:
332 case CONSPEC_F_OR_G:
333 case CONSPEC_F_OR_G_UP:
334 case CONSPEC_HEX_EXP:
335 case CONSPEC_HEX_EXP_UP:
336 switch (arg->lenmod)
337 {
338 case LENMOD_LONGDBL: arg->vt = VALTYPE_LONGDOUBLE; break;
339 case LENMOD_LONG: arg->vt = VALTYPE_DOUBLE; break;
340 default: arg->vt = VALTYPE_DOUBLE; break;
341 }
342 break;
343
344 case CONSPEC_CHAR:
345 arg->vt = VALTYPE_INT;
346 break;
347
348 case CONSPEC_STRING:
349 arg->vt = VALTYPE_STRING;
350 break;
351
352 case CONSPEC_POINTER:
353 arg->vt = VALTYPE_POINTER;
354 break;
355
356 case CONSPEC_STRERROR:
357 arg->vt = VALTYPE_STRING;
358 break;
359
360 case CONSPEC_BYTES_SO_FAR:
361 switch (arg->lenmod)
362 {
363 case LENMOD_CHAR: arg->vt = VALTYPE_SCHAR_PTR; break;
364 case LENMOD_SHORT: arg->vt = VALTYPE_SHORT_PTR; break;
365 case LENMOD_LONG: arg->vt = VALTYPE_LONG_PTR; break;
366 case LENMOD_LONGLONG: arg->vt = VALTYPE_LONGLONG_PTR; break;
367 case LENMOD_INTMAX: arg->vt = VALTYPE_INTMAX_PTR; break;
368 case LENMOD_SIZET: arg->vt = VALTYPE_SIZE_PTR; break;
369 case LENMOD_PTRDIFF: arg->vt = VALTYPE_PTRDIFF_PTR; break;
370 default: arg->vt = VALTYPE_INT_PTR; break;
371 }
372 break;
373
374 }
375 }
376
377
378
379 /* Parse the FORMAT string and populate the specification array stored
380 at the address ARGSPECS_ADDR. The caller has provided enough space
381 to store up to MAX_ARGSPECS in that buffer. The function may
382 however ignore the provided buffer and malloc a larger one. On
383 success the addrrss of that larger buffer will be stored at
384 ARGSPECS_ADDR. The actual number of specifications will be
385 returned at R_ARGSPECS_COUNT. */
386 static int
387 parse_format (const char *format,
388 argspec_t *argspecs_addr, size_t max_argspecs,
389 size_t *r_argspecs_count)
390 {
391 const char *s;
392 argspec_t argspecs = *argspecs_addr;
393 argspec_t arg;
394 size_t argcount = 0;
395
396 if (!format)
397 goto leave_einval;
398
399 for (; *format; format++)
400 {
401 unsigned int flags;
402 int width, precision;
403 lenmod_t lenmod;
404 conspec_t conspec;
405 int arg_pos, width_pos, precision_pos;
406
407 if (*format != '%')
408 continue;
409 s = ++format;
410 if (!*s)
411 goto leave_einval;
412 if (*s == '%')
413 continue; /* Just a quoted percent. */
414
415 /* First check whether there is a positional argument. */
416 arg_pos = 0; /* No positional argument given. */
417 if (*s >= '1' && *s <= '9')
418 {
419 const char *save_s = s;
420
421 arg_pos = (*s++ - '0');
422 for (; *s >= '0' && *s <= '9'; s++)
423 arg_pos = 10*arg_pos + (*s - '0');
424 if (arg_pos < 0)
425 goto leave_einval; /* Overflow during conversion. */
426 if (*s == '$')
427 s++;
428 else
429 {
430 arg_pos = 0;
431 s = save_s;
432 }
433 }
434
435 /* Parse the flags. */
436 flags = 0;
437 for ( ; *s; s++)
438 {
439 switch (*s)
440 {
441 case '\'': flags |= FLAG_GROUPING; break;
442 case '-': flags |= FLAG_LEFT_JUST; break;
443 case '+': flags |= FLAG_PLUS_SIGN; break;
444 case ' ': flags |= FLAG_SPACE_PLUS; break;
445 case '#': flags |= FLAG_ALT_CONV; break;
446 case '0': flags |= FLAG_ZERO_PAD; break;
447 default:
448 goto flags_parsed;
449 }
450 }
451 flags_parsed:
452
453 /* Parse the field width. */
454 width_pos = 0;
455 if (*s == '*')
456 {
457 width = STAR_FIELD_VALUE;
458 s++;
459 /* If we have a positional argument, another one might also
460 be used to give the position of the star's value. */
461 if (arg_pos && *s >= '1' && *s <= '9')
462 {
463 width_pos = (*s++ - '0');
464 for (; *s >= '0' && *s <= '9'; s++)
465 width_pos = 10*width_pos + (*s - '0');
466 if (width_pos < 1)
467 goto leave_einval; /* Overflow during conversion. */
468 if (*s != '$')
469 goto leave_einval; /* Not followed by $. */
470 s++;
471 }
472 }
473 else if ( *s >= '0' && *s <= '9')
474 {
475 width = (*s++ - '0');
476 for (; *s >= '0' && *s <= '9'; s++)
477 {
478 if (!width && *s == '0')
479 goto leave_einval; /* Leading zeroes are not allowed.
480 Fixme: check what other
481 implementations do. */
482 width = 10*width + (*s - '0');
483 }
484 if (width < 0)
485 goto leave_einval; /* Overflow during conversion. */
486 }
487 else
488 width = NO_FIELD_VALUE;
489
490 /* Parse the precision. */
491 precision_pos = 0;
492 precision = NO_FIELD_VALUE;
493 if (*s == '.')
494 {
495 int ignore_value = (s[1] == '-');
496
497 s++;
498 if (*s == '*')
499 {
500 precision = STAR_FIELD_VALUE;
501 s++;
502 /* If we have a positional argument, another one might also
503 be used to give the position of the star's value. */
504 if (arg_pos && *s >= '1' && *s <= '9')
505 {
506 precision_pos = (*s++ - '0');
507 for (; *s >= '0' && *s <= '9'; s++)
508 precision_pos = 10*precision_pos + (*s - '0');
509 if (precision_pos < 1)
510 goto leave_einval; /* Overflow during conversion. */
511 if (*s != '$')
512 goto leave_einval; /* Not followed by $. */
513 s++;
514 }
515 }
516 else if ( *s >= '0' && *s <= '9')
517 {
518 precision = (*s++ - '0');
519 for (; *s >= '0' && *s <= '9'; s++)
520 {
521 if (!precision && *s == '0')
522 goto leave_einval; /* Leading zeroes are not allowed.
523 Fixme: check what other
524 implementations do. */
525 precision = 10*precision + (*s - '0');
526 }
527 if (precision < 0)
528 goto leave_einval; /* Overflow during conversion. */
529 }
530 else
531 precision = 0;
532 if (ignore_value)
533 precision = NO_FIELD_VALUE;
534 }
535
536 /* Parse the length modifiers. */
537 switch (*s)
538 {
539 case 'h':
540 if (s[1] == 'h')
541 {
542 lenmod = LENMOD_CHAR;
543 s++;
544 }
545 else
546 lenmod = LENMOD_SHORT;
547 s++;
548 break;
549 case 'l':
550 if (s[1] == 'l')
551 {
552 lenmod = LENMOD_LONGLONG;
553 s++;
554 }
555 else
556 lenmod = LENMOD_LONG;
557 s++;
558 break;
559 case 'j': lenmod = LENMOD_INTMAX; s++; break;
560 case 'z': lenmod = LENMOD_SIZET; s++; break;
561 case 't': lenmod = LENMOD_PTRDIFF; s++; break;
562 case 'L': lenmod = LENMOD_LONGDBL; s++; break;
563 default: lenmod = LENMOD_NONE; break;
564 }
565
566 /* Parse the conversion specifier. */
567 switch (*s)
568 {
569 case 'd':
570 case 'i': conspec = CONSPEC_DECIMAL; break;
571 case 'o': conspec = CONSPEC_OCTAL; break;
572 case 'u': conspec = CONSPEC_UNSIGNED; break;
573 case 'x': conspec = CONSPEC_HEX; break;
574 case 'X': conspec = CONSPEC_HEX_UP; break;
575 case 'f': conspec = CONSPEC_FLOAT; break;
576 case 'F': conspec = CONSPEC_FLOAT_UP; break;
577 case 'e': conspec = CONSPEC_EXP; break;
578 case 'E': conspec = CONSPEC_EXP_UP; break;
579 case 'g': conspec = CONSPEC_F_OR_G; break;
580 case 'G': conspec = CONSPEC_F_OR_G_UP; break;
581 case 'a': conspec = CONSPEC_HEX_EXP; break;
582 case 'A': conspec = CONSPEC_HEX_EXP_UP; break;
583 case 'c': conspec = CONSPEC_CHAR; break;
584 case 's': conspec = CONSPEC_STRING; break;
585 case 'p': conspec = CONSPEC_POINTER; break;
586 case 'n': conspec = CONSPEC_BYTES_SO_FAR; break;
587 case 'C': conspec = CONSPEC_CHAR; lenmod = LENMOD_LONG; break;
588 case 'S': conspec = CONSPEC_STRING; lenmod = LENMOD_LONG; break;
589 case 'm': conspec = CONSPEC_STRERROR; arg_pos = -1; break;
590 default: conspec = CONSPEC_UNKNOWN;
591 }
592
593 /* Save the args. */
594 if (argcount >= max_argspecs)
595 {
596 /* We either need to allocate a new array instead of the
597 caller provided one or realloc the array. Instead of
598 using realloc we allocate a new one and release the
599 original one then. */
600 size_t n, newmax;
601 argspec_t newarg;
602
603 newmax = max_argspecs + ARGSPECS_BUMP_VALUE;
604 if (newmax <= max_argspecs)
605 goto leave_einval; /* Too many arguments. */
606 newarg = calloc (newmax, sizeof *newarg);
607 if (!newarg)
608 goto leave;
609 for (n=0; n < argcount; n++)
610 newarg[n] = argspecs[n];
611 if (argspecs != *argspecs_addr)
612 free (argspecs);
613 argspecs = newarg;
614 max_argspecs = newmax;
615 }
616
617 arg = argspecs + argcount;
618 arg->length = s - format + 2;
619 arg->flags = flags;
620 arg->width = width;
621 arg->precision = precision;
622 arg->lenmod = lenmod;
623 arg->conspec = conspec;
624 arg->arg_pos = arg_pos;
625 arg->width_pos = width_pos;
626 arg->precision_pos = precision_pos;
627 compute_type (arg);
628 argcount++;
629 format = s;
630 }
631
632 *argspecs_addr = argspecs;
633 *r_argspecs_count = argcount;
634 return 0; /* Success. */
635
636 leave_einval:
637 errno = EINVAL;
638 leave:
639 if (argspecs != *argspecs_addr)
640 free (argspecs);
641 *argspecs_addr = NULL;
642 return -1;
643 }
644
645
646 /* This function reads all the values as specified by VALUETABLE into
647 VALUETABLE. The values are expected in VAARGS. The function
648 returns -1 if a specified type is not supported. */
649 static int
650 read_values (valueitem_t valuetable, size_t valuetable_len, va_list vaargs)
651 {
652 int validx;
653
654 for (validx=0; validx < valuetable_len; validx++)
655 {
656 value_t *value = &valuetable[validx].value;
657 valtype_t vt = valuetable[validx].vt;
658
659 switch (vt)
660 {
661 case VALTYPE_CHAR: value->a_char = va_arg (vaargs, int); break;
662 case VALTYPE_CHAR_PTR:
663 value->a_char_ptr = va_arg (vaargs, char *);
664 break;
665 case VALTYPE_SCHAR: value->a_schar = va_arg (vaargs, int); break;
666 case VALTYPE_SCHAR_PTR:
667 value->a_schar_ptr = va_arg (vaargs, signed char *);
668 break;
669 case VALTYPE_UCHAR: value->a_uchar = va_arg (vaargs, int); break;
670 case VALTYPE_SHORT: value->a_short = va_arg (vaargs, int); break;
671 case VALTYPE_USHORT: value->a_ushort = va_arg (vaargs, int); break;
672 case VALTYPE_SHORT_PTR:
673 value->a_short_ptr = va_arg (vaargs, short *);
674 break;
675 case VALTYPE_INT:
676 value->a_int = va_arg (vaargs, int);
677 break;
678 case VALTYPE_INT_PTR:
679 value->a_int_ptr = va_arg (vaargs, int *);
680 break;
681 case VALTYPE_UINT:
682 value->a_uint = va_arg (vaargs, unsigned int);
683 break;
684 case VALTYPE_LONG:
685 value->a_long = va_arg (vaargs, long);
686 break;
687 case VALTYPE_ULONG:
688 value->a_ulong = va_arg (vaargs, unsigned long);
689 break;
690 case VALTYPE_LONG_PTR:
691 value->a_long_ptr = va_arg (vaargs, long *);
692 break;
693 #ifdef HAVE_LONG_LONG_INT
694 case VALTYPE_LONGLONG:
695 value->a_longlong = va_arg (vaargs, long long int);
696 break;
697 case VALTYPE_ULONGLONG:
698 value->a_ulonglong = va_arg (vaargs, unsigned long long int);
699 break;
700 case VALTYPE_LONGLONG_PTR:
701 value->a_longlong_ptr = va_arg (vaargs, long long *);
702 break;
703 #endif
704 case VALTYPE_DOUBLE:
705 value->a_double = va_arg (vaargs, double);
706 break;
707 #ifdef HAVE_LONG_DOUBLE
708 case VALTYPE_LONGDOUBLE:
709 value->a_longdouble = va_arg (vaargs, long double);
710 break;
711 #endif
712 case VALTYPE_STRING:
713 value->a_string = va_arg (vaargs, const char *);
714 break;
715 case VALTYPE_POINTER:
716 value->a_void_ptr = va_arg (vaargs, void *);
717 break;
718 #ifdef HAVE_INTMAX_T
719 case VALTYPE_INTMAX:
720 value->a_intmax = va_arg (vaargs, intmax_t);
721 break;
722 case VALTYPE_INTMAX_PTR:
723 value->a_intmax_ptr = va_arg (vaargs, intmax_t *);
724 break;
725 #endif
726 #ifdef HAVE_UINTMAX_T
727 case VALTYPE_UINTMAX:
728 value->a_uintmax = va_arg (vaargs, uintmax_t);
729 break;
730 #endif
731 case VALTYPE_SIZE:
732 value->a_size = va_arg (vaargs, size_t);
733 break;
734 case VALTYPE_SIZE_PTR:
735 value->a_size_ptr = va_arg (vaargs, size_t *);
736 break;
737 #ifdef HAVE_PTRDIFF_T
738 case VALTYPE_PTRDIFF:
739 value->a_ptrdiff = va_arg (vaargs, ptrdiff_t);
740 break;
741 case VALTYPE_PTRDIFF_PTR:
742 value->a_ptrdiff_ptr = va_arg (vaargs, ptrdiff_t *);
743 break;
744 #endif
745 default: /* Unsupported type. */
746 return -1;
747 }
748 }
749 return 0;
750 }
751
752
753 \f
754 /* Output COUNT padding characters PADCHAR and update NBYTES by the
755 number of bytes actually written. */
756 static int
757 pad_out (estream_printf_out_t outfnc, void *outfncarg,
758 int padchar, int count, size_t *nbytes)
759 {
760 char buf[32];
761 size_t n;
762 int rc;
763
764 while (count > 0)
765 {
766 n = (count <= sizeof buf)? count : sizeof buf;
767 memset (buf, padchar, n);
768 rc = outfnc (outfncarg, buf, n);
769 if (rc)
770 return rc;
771 *nbytes += n;
772 count -= n;
773 }
774
775 return 0;
776 }
777
778
779 /* "d,i,o,u,x,X" formatting. OUTFNC and OUTFNCARG describes the
780 output routine, ARG gives the argument description and VALUE the
781 actual value (its type is available through arg->vt). */
782 static int
783 pr_integer (estream_printf_out_t outfnc, void *outfncarg,
784 argspec_t arg, value_t value, size_t *nbytes)
785 {
786 int rc;
787 #ifdef HAVE_LONG_LONG_INT
788 unsigned long long aulong;
789 #else
790 unsigned long aulong;
791 #endif
792 char numbuf[100];
793 char *p, *pend;
794 size_t n;
795 char signchar = 0;
796 int n_prec; /* Number of extra precision digits required. */
797 int n_extra; /* Extra number of prefix or sign characters. */
798
799 if (arg->conspec == CONSPEC_DECIMAL)
800 {
801 #ifdef HAVE_LONG_LONG_INT
802 long long along;
803 #else
804 long along;
805 #endif
806
807 switch (arg->vt)
808 {
809 case VALTYPE_SHORT: along = value.a_short; break;
810 case VALTYPE_INT: along = value.a_int; break;
811 case VALTYPE_LONG: along = value.a_long; break;
812 #ifdef HAVE_LONG_LONG_INT
813 case VALTYPE_LONGLONG: along = value.a_longlong; break;
814 case VALTYPE_SIZE: along = value.a_size; break;
815 # ifdef HAVE_INTMAX_T
816 case VALTYPE_INTMAX: along = value.a_intmax; break;
817 # endif
818 # ifdef HAVE_PTRDIFF_T
819 case VALTYPE_PTRDIFF: along = value.a_ptrdiff; break;
820 # endif
821 #endif /*HAVE_LONG_LONG_INT*/
822 default:
823 return -1;
824 }
825 if (along < 0)
826 {
827 aulong = -along;
828 signchar = '-';
829 }
830 else
831 aulong = along;
832 }
833 else
834 {
835 switch (arg->vt)
836 {
837 case VALTYPE_USHORT: aulong = value.a_ushort; break;
838 case VALTYPE_UINT: aulong = value.a_uint; break;
839 case VALTYPE_ULONG: aulong = value.a_ulong; break;
840 #ifdef HAVE_LONG_LONG_INT
841 case VALTYPE_ULONGLONG: aulong = value.a_ulonglong; break;
842 case VALTYPE_SIZE: aulong = value.a_size; break;
843 # ifdef HAVE_UINTMAX_T
844 case VALTYPE_UINTMAX: aulong = value.a_uintmax; break;
845 # endif
846 # ifdef HAVE_PTRDIFF_T
847 case VALTYPE_PTRDIFF: aulong = value.a_ptrdiff; break;
848 # endif
849 #endif /*HAVE_LONG_LONG_INT*/
850 default:
851 return -1;
852 }
853 }
854
855 if (signchar == '-')
856 ;
857 else if ((arg->flags & FLAG_PLUS_SIGN))
858 signchar = '+';
859 else if ((arg->flags & FLAG_SPACE_PLUS))
860 signchar = ' ';
861
862 n_extra = !!signchar;
863
864 /* We build the string up backwards. */
865 p = pend = numbuf + DIM(numbuf);
866 if ((!aulong && !arg->precision))
867 ;
868 else if (arg->conspec == CONSPEC_DECIMAL
869 || arg->conspec == CONSPEC_UNSIGNED)
870 {
871 int grouping = -1;
872 const char * grouping_string =
873 #ifdef HAVE_LANGINFO_THOUSANDS_SEP
874 nl_langinfo(THOUSANDS_SEP);
875 #else
876 "'";
877 #endif
878
879 do
880 {
881 if ((arg->flags & FLAG_GROUPING)
882 && (++grouping == 3) && *grouping_string)
883 {
884 *--p = *grouping_string;
885 grouping = 0;
886 }
887 *--p = '0' + (aulong % 10);
888 aulong /= 10;
889 }
890 while (aulong);
891 }
892 else if (arg->conspec == CONSPEC_OCTAL)
893 {
894 do
895 {
896 *--p = '0' + (aulong % 8);
897 aulong /= 8;
898 }
899 while (aulong);
900 if ((arg->flags & FLAG_ALT_CONV) && *p != '0')
901 *--p = '0';
902 }
903 else /* HEX or HEXUP */
904 {
905 const char *digits = ((arg->conspec == CONSPEC_HEX)
906 ? "0123456789abcdef" : "0123456789ABCDEF");
907 do
908 {
909 *--p = digits[(aulong % 16)];
910 aulong /= 16;
911 }
912 while (aulong);
913 if ((arg->flags & FLAG_ALT_CONV))
914 n_extra += 2;
915 }
916
917 n = pend - p;
918
919 if ((arg->flags & FLAG_ZERO_PAD)
920 && arg->precision == NO_FIELD_VALUE && !(arg->flags & FLAG_LEFT_JUST)
921 && n && arg->width - n_extra > n )
922 n_prec = arg->width - n_extra - n;
923 else if (arg->precision > 0 && arg->precision > n)
924 n_prec = arg->precision - n;
925 else
926 n_prec = 0;
927
928 if (!(arg->flags & FLAG_LEFT_JUST)
929 && arg->width >= 0 && arg->width - n_extra > n
930 && arg->width - n_extra - n >= n_prec )
931 {
932 rc = pad_out (outfnc, outfncarg, ' ',
933 arg->width - n_extra - n - n_prec, nbytes);
934 if (rc)
935 return rc;
936 }
937
938 if (signchar)
939 {
940 rc = outfnc (outfncarg, &signchar, 1);
941 if (rc)
942 return rc;
943 *nbytes += 1;
944 }
945
946 if ((arg->flags & FLAG_ALT_CONV)
947 && (arg->conspec == CONSPEC_HEX || arg->conspec == CONSPEC_HEX_UP))
948 {
949 rc = outfnc (outfncarg, arg->conspec == CONSPEC_HEX? "0x": "0X", 2);
950 if (rc)
951 return rc;
952 *nbytes += 2;
953 }
954
955 if (n_prec)
956 {
957 rc = pad_out (outfnc, outfncarg, '0', n_prec, nbytes);
958 if (rc)
959 return rc;
960 }
961
962 rc = outfnc (outfncarg, p, pend - p);
963 if (rc)
964 return rc;
965 *nbytes += pend - p;
966
967 if ((arg->flags & FLAG_LEFT_JUST)
968 && arg->width >= 0 && arg->width - n_extra - n_prec > n)
969 {
970 rc = pad_out (outfnc, outfncarg, ' ',
971 arg->width - n_extra - n_prec - n, nbytes);
972 if (rc)
973 return rc;
974 }
975
976 return 0;
977 }
978
979
980 /* "e,E,f,F,g,G,a,A" formatting. OUTFNC and OUTFNCARG describes the
981 output routine, ARG gives the argument description and VALUE the
982 actual value (its type is available through arg->vt). For
983 portability reasons sprintf is used for the actual formatting.
984 This is useful because sprint is the only standard function to
985 convert a floating number into its ascii representation. To avoid
986 using malloc we just pass the precision to sprintf and do the final
987 formatting with our own code. */
988 static int
989 pr_float (estream_printf_out_t outfnc, void *outfncarg,
990 argspec_t arg, value_t value, size_t *nbytes)
991 {
992 int rc;
993 #ifdef HAVE_LONG_DOUBLE
994 long double adblfloat = 0; /* Just to please gcc. */
995 int use_dbl = 0;
996 #endif
997 double afloat;
998 char numbuf[200];
999 char formatstr[20];
1000 char *p, *pend;
1001 size_t n;
1002 char signchar = 0;
1003 int n_extra; /* Extra number of prefix or sign characters. */
1004
1005 switch (arg->vt)
1006 {
1007 case VALTYPE_DOUBLE: afloat = value.a_double; break;
1008 #ifdef HAVE_LONG_DOUBLE
1009 case VALTYPE_LONGDOUBLE:
1010 afloat = 0; /* Just to please gcc. */
1011 adblfloat = value.a_longdouble;
1012 use_dbl=1; break;
1013 #endif
1014 default:
1015 return -1;
1016 }
1017
1018 /* We build the string using sprint. */
1019 p = formatstr + sizeof formatstr;
1020 *--p = 0;
1021 switch (arg->conspec)
1022 {
1023 case CONSPEC_FLOAT: *--p = 'f'; break;
1024 case CONSPEC_FLOAT_UP: *--p = 'F'; break;
1025 case CONSPEC_EXP: *--p = 'e'; break;
1026 case CONSPEC_EXP_UP: *--p = 'E'; break;
1027 case CONSPEC_F_OR_G: *--p = 'g'; break;
1028 case CONSPEC_F_OR_G_UP: *--p = 'G'; break;
1029 case CONSPEC_HEX_EXP: *--p = 'a'; break;
1030 case CONSPEC_HEX_EXP_UP: *--p = 'A'; break;
1031 default:
1032 return -1; /* Actually a bug. */
1033 }
1034 #ifdef HAVE_LONG_DOUBLE
1035 if (use_dbl)
1036 *--p = 'L';
1037 #endif
1038 if (arg->precision != NO_FIELD_VALUE)
1039 {
1040 /* Limit it to a meaningful value so that even a stupid sprintf
1041 won't overflow our buffer. */
1042 n = arg->precision <= 100? arg->precision : 100;
1043 do
1044 {
1045 *--p = '0' + (n % 10);
1046 n /= 10;
1047 }
1048 while (n);
1049 *--p = '.';
1050 }
1051 if ((arg->flags & FLAG_ALT_CONV))
1052 *--p = '#';
1053 *--p = '%';
1054 #ifdef HAVE_LONG_DOUBLE
1055 if (use_dbl)
1056 sprintf (numbuf, p, adblfloat);
1057 else
1058 #endif /*HAVE_LONG_DOUBLE*/
1059 sprintf (numbuf, p, afloat);
1060 p = numbuf;
1061 n = strlen (numbuf);
1062 pend = p + n;
1063
1064 if (*p =='-')
1065 {
1066 signchar = '-';
1067 p++;
1068 n--;
1069 }
1070 else if ((arg->flags & FLAG_PLUS_SIGN))
1071 signchar = '+';
1072 else if ((arg->flags & FLAG_SPACE_PLUS))
1073 signchar = ' ';
1074
1075 n_extra = !!signchar;
1076
1077 if (!(arg->flags & FLAG_LEFT_JUST)
1078 && arg->width >= 0 && arg->width - n_extra > n)
1079 {
1080 rc = pad_out (outfnc, outfncarg, ' ', arg->width - n_extra - n, nbytes);
1081 if (rc)
1082 return rc;
1083 }
1084
1085 if (signchar)
1086 {
1087 rc = outfnc (outfncarg, &signchar, 1);
1088 if (rc)
1089 return rc;
1090 *nbytes += 1;
1091 }
1092
1093 rc = outfnc (outfncarg, p, pend - p);
1094 if (rc)
1095 return rc;
1096 *nbytes += pend - p;
1097
1098 if ((arg->flags & FLAG_LEFT_JUST)
1099 && arg->width >= 0 && arg->width - n_extra > n)
1100 {
1101 rc = pad_out (outfnc, outfncarg, ' ', arg->width - n_extra - n, nbytes);
1102 if (rc)
1103 return rc;
1104 }
1105
1106 return 0;
1107 }
1108
1109
1110 /* "c" formatting. */
1111 static int
1112 pr_char (estream_printf_out_t outfnc, void *outfncarg,
1113 argspec_t arg, value_t value, size_t *nbytes)
1114 {
1115 int rc;
1116 char buf[1];
1117
1118 if (arg->vt != VALTYPE_INT)
1119 return -1;
1120 buf[0] = (unsigned int)value.a_int;
1121 rc = outfnc (outfncarg, buf, 1);
1122 if(rc)
1123 return rc;
1124 *nbytes += 1;
1125
1126 return 0;
1127 }
1128
1129
1130 /* "s" formatting. */
1131 static int
1132 pr_string (estream_printf_out_t outfnc, void *outfncarg,
1133 argspec_t arg, value_t value, size_t *nbytes)
1134 {
1135 int rc;
1136 size_t n;
1137 const char *string, *s;
1138
1139 if (arg->vt != VALTYPE_STRING)
1140 return -1;
1141 string = value.a_string;
1142 if (!string)
1143 string = "(null)";
1144 if (arg->precision >= 0)
1145 {
1146 for (n=0,s=string; *s && n < arg->precision; s++)
1147 n++;
1148 }
1149 else
1150 n = strlen (string);
1151
1152 if (!(arg->flags & FLAG_LEFT_JUST)
1153 && arg->width >= 0 && arg->width > n )
1154 {
1155 rc = pad_out (outfnc, outfncarg, ' ', arg->width - n, nbytes);
1156 if (rc)
1157 return rc;
1158 }
1159
1160 rc = outfnc (outfncarg, string, n);
1161 if (rc)
1162 return rc;
1163 *nbytes += n;
1164
1165 if ((arg->flags & FLAG_LEFT_JUST)
1166 && arg->width >= 0 && arg->width > n)
1167 {
1168 rc = pad_out (outfnc, outfncarg, ' ', arg->width - n, nbytes);
1169 if (rc)
1170 return rc;
1171 }
1172
1173 return 0;
1174 }
1175
1176
1177 /* "p" formatting. */
1178 static int
1179 pr_pointer (estream_printf_out_t outfnc, void *outfncarg,
1180 argspec_t arg, value_t value, size_t *nbytes)
1181 {
1182 int rc;
1183 #ifdef HAVE_LONG_LONG_INT
1184 unsigned long long aulong;
1185 #else
1186 unsigned long aulong;
1187 #endif
1188 char numbuf[100];
1189 char *p, *pend;
1190
1191 if (arg->vt != VALTYPE_POINTER)
1192 return -1;
1193 /* We assume that a pointer can be converted to an unsigned long.
1194 That is not correct for a 64 bit Windows, but then we assume that
1195 long long is supported and usable for storing a pointer. */
1196 #if defined(HAVE_LONG_LONG_INT) && (SIZEOF_UNSIGNED_LONG < SIZEOF_VOID_P)
1197 aulong = (unsigned long long)value.a_void_ptr;
1198 #else
1199 aulong = (unsigned long)value.a_void_ptr;
1200 #endif
1201
1202 p = pend = numbuf + DIM(numbuf);
1203 do
1204 {
1205 *--p = "0123456789abcdefx"[(aulong % 16)];
1206 aulong /= 16;
1207 }
1208 while (aulong);
1209 while ((pend-p) < 2*sizeof (aulong))
1210 *--p = '0';
1211 *--p = 'x';
1212 *--p = '0';
1213
1214 rc = outfnc (outfncarg, p, pend - p);
1215 if (rc)
1216 return rc;
1217 *nbytes += pend - p;
1218
1219 return 0;
1220 }
1221
1222 /* "n" pesudo format operation. */
1223 static int
1224 pr_bytes_so_far (estream_printf_out_t outfnc, void *outfncarg,
1225 argspec_t arg, value_t value, size_t *nbytes)
1226 {
1227 switch (arg->vt)
1228 {
1229 case VALTYPE_SCHAR_PTR:
1230 *value.a_schar_ptr = (signed char)(unsigned int)(*nbytes);
1231 break;
1232 case VALTYPE_SHORT_PTR:
1233 *value.a_short_ptr = (short)(unsigned int)(*nbytes);
1234 break;
1235 case VALTYPE_LONG_PTR:
1236 *value.a_long_ptr = (long)(*nbytes);
1237 break;
1238 #ifdef HAVE_LONG_LONG_INT
1239 case VALTYPE_LONGLONG_PTR:
1240 *value.a_longlong_ptr = (long long)(*nbytes);
1241 break;
1242 #endif
1243 #ifdef HAVE_INTMAX_T
1244 case VALTYPE_INTMAX_PTR:
1245 *value.a_intmax_ptr = (intmax_t)(*nbytes);
1246 break;
1247 #endif
1248 case VALTYPE_SIZE_PTR:
1249 *value.a_size_ptr = (*nbytes);
1250 break;
1251 #ifdef HAVE_PTRDIFF_T
1252 case VALTYPE_PTRDIFF_PTR:
1253 *value.a_ptrdiff_ptr = (ptrdiff_t)(*nbytes);
1254 break;
1255 #endif
1256 case VALTYPE_INT_PTR:
1257 *value.a_int_ptr = (int)(*nbytes);
1258 break;
1259 default:
1260 return -1; /* An unsupported type has been used. */
1261 }
1262
1263 return 0;
1264 }
1265
1266
1267
1268 /* Run the actual formatting. OUTFNC and OUTFNCARG are the output
1269 functions. FORMAT is format string ARGSPECS is the parsed format
1270 string, ARGSPECS_LEN the number of items in ARGSPECS. VALUETABLE
1271 holds the values and may be directly addressed using the position
1272 arguments given by ARGSPECS. MYERRNO is used for the "%m"
1273 conversion. NBYTES well be updated to reflect the number of bytes
1274 send to the output function. */
1275 static int
1276 do_format (estream_printf_out_t outfnc, void *outfncarg,
1277 const char *format, argspec_t argspecs, size_t argspecs_len,
1278 valueitem_t valuetable, int myerrno, size_t *nbytes)
1279 {
1280 int rc = 0;
1281 const char *s;
1282 argspec_t arg = argspecs;
1283 int argidx = 0; /* Only used for assertion. */
1284 size_t n;
1285 value_t value;
1286
1287 s = format;
1288 while ( *s )
1289 {
1290 if (*s != '%')
1291 {
1292 s++;
1293 continue;
1294 }
1295 if (s != format)
1296 {
1297 rc = outfnc (outfncarg, format, (n=s-format));
1298 if (rc)
1299 return rc;
1300 *nbytes += n;
1301 }
1302 if (s[1] == '%')
1303 {
1304 /* Note that this code ignores one trailing percent escape -
1305 this is however okay as the args parser must have
1306 detected this already. */
1307 rc = outfnc (outfncarg, s, 1);
1308 if (rc)
1309 return rc;
1310 *nbytes += 1;
1311 s += 2;
1312 format = s;
1313 continue;
1314 }
1315
1316 /* Save the next start. */
1317 s += arg->length;
1318 format = s;
1319
1320 assert (argidx < argspecs_len);
1321 argidx++;
1322
1323 /* Apply indirect field width and precision values. */
1324 if (arg->width == STAR_FIELD_VALUE)
1325 {
1326 assert (valuetable[arg->width_pos-1].vt == VALTYPE_INT);
1327 arg->width = valuetable[arg->width_pos-1].value.a_int;
1328 if (arg->width < 0)
1329 {
1330 arg->width = -arg->width;
1331 arg->flags |= FLAG_LEFT_JUST;
1332 }
1333 }
1334 if (arg->precision == STAR_FIELD_VALUE)
1335 {
1336 assert (valuetable[arg->precision_pos-1].vt == VALTYPE_INT);
1337 arg->precision = valuetable[arg->precision_pos-1].value.a_int;
1338 if (arg->precision < 0)
1339 arg->precision = NO_FIELD_VALUE;
1340 }
1341
1342 if (arg->arg_pos == -1 && arg->conspec == CONSPEC_STRERROR)
1343 value.a_string = strerror (myerrno);
1344 else
1345 {
1346 assert (arg->vt == valuetable[arg->arg_pos-1].vt);
1347 value = valuetable[arg->arg_pos-1].value;
1348 }
1349
1350 switch (arg->conspec)
1351 {
1352 case CONSPEC_UNKNOWN: assert (!"bug"); break;
1353
1354 case CONSPEC_DECIMAL:
1355 case CONSPEC_UNSIGNED:
1356 case CONSPEC_OCTAL:
1357 case CONSPEC_HEX:
1358 case CONSPEC_HEX_UP:
1359 rc = pr_integer (outfnc, outfncarg, arg, value, nbytes);
1360 break;
1361 case CONSPEC_FLOAT:
1362 case CONSPEC_FLOAT_UP:
1363 case CONSPEC_EXP:
1364 case CONSPEC_EXP_UP:
1365 case CONSPEC_F_OR_G:
1366 case CONSPEC_F_OR_G_UP:
1367 case CONSPEC_HEX_EXP:
1368 case CONSPEC_HEX_EXP_UP:
1369 rc = pr_float (outfnc, outfncarg, arg, value, nbytes);
1370 break;
1371 case CONSPEC_CHAR:
1372 rc = pr_char (outfnc, outfncarg, arg, value, nbytes);
1373 break;
1374 case CONSPEC_STRING:
1375 case CONSPEC_STRERROR:
1376 rc = pr_string (outfnc, outfncarg, arg, value, nbytes);
1377 break;
1378 case CONSPEC_POINTER:
1379 rc = pr_pointer (outfnc, outfncarg, arg, value, nbytes);
1380 break;
1381 case CONSPEC_BYTES_SO_FAR:
1382 rc = pr_bytes_so_far (outfnc, outfncarg, arg, value, nbytes);
1383 break;
1384 }
1385 if (rc)
1386 return rc;
1387 arg++;
1388 }
1389
1390 /* Print out any trailing stuff. */
1391 n = s - format;
1392 rc = n? outfnc (outfncarg, format, n) : 0;
1393 if (!rc)
1394 *nbytes += n;
1395
1396 return rc;
1397 }
1398
1399
1400
1401 \f
1402 /* The versatile printf formatting routine. It expects a callback
1403 function OUTFNC and an opaque argument OUTFNCARG used for actual
1404 output of the formatted stuff. FORMAT is the format specification
1405 and VAARGS a variable argumemt list matching the arguments of
1406 FORMAT. */
1407 int
1408 estream_format (estream_printf_out_t outfnc,
1409 void *outfncarg,
1410 const char *format, va_list vaargs)
1411 {
1412 /* Buffer to hold the argspecs and a pointer to it.*/
1413 struct argspec_s argspecs_buffer[DEFAULT_MAX_ARGSPECS];
1414 argspec_t argspecs = argspecs_buffer;
1415 size_t argspecs_len; /* Number of specifications in ARGSPECS. */
1416
1417 /* Buffer to hold the description for the values. */
1418 struct valueitem_s valuetable_buffer[DEFAULT_MAX_VALUES];
1419 valueitem_t valuetable = valuetable_buffer;
1420
1421 int rc; /* Return code. */
1422 size_t argidx; /* Used to index the argspecs array. */
1423 size_t validx; /* Used to index the valuetable. */
1424 int max_pos;/* Highest argument position. */
1425
1426 size_t nbytes = 0; /* Keep track of the number of bytes passed to
1427 the output function. */
1428
1429 int myerrno = errno; /* Save the errno for use with "%m". */
1430
1431
1432 /* Parse the arguments to come up with descriptive list. We can't
1433 do this on the fly because we need to support positional
1434 arguments. */
1435 rc = parse_format (format, &argspecs, DIM(argspecs_buffer), &argspecs_len);
1436 if (rc)
1437 goto leave;
1438
1439 /* Check that all ARG_POS fields are set. */
1440 for (argidx=0,max_pos=0; argidx < argspecs_len; argidx++)
1441 {
1442 if (argspecs[argidx].arg_pos != -1
1443 && argspecs[argidx].arg_pos > max_pos)
1444 max_pos = argspecs[argidx].arg_pos;
1445 if (argspecs[argidx].width_pos > max_pos)
1446 max_pos = argspecs[argidx].width_pos;
1447 if (argspecs[argidx].precision_pos > max_pos)
1448 max_pos = argspecs[argidx].precision_pos;
1449 }
1450 if (!max_pos)
1451 {
1452 /* Fill in all the positions. */
1453 for (argidx=0; argidx < argspecs_len; argidx++)
1454 {
1455 if (argspecs[argidx].width == STAR_FIELD_VALUE)
1456 argspecs[argidx].width_pos = ++max_pos;
1457 if (argspecs[argidx].precision == STAR_FIELD_VALUE)
1458 argspecs[argidx].precision_pos = ++max_pos;
1459 if (argspecs[argidx].arg_pos != -1 )
1460 argspecs[argidx].arg_pos = ++max_pos;
1461 }
1462 }
1463 else
1464 {
1465 /* Check that they are all filled. More test are done later. */
1466 for (argidx=0; argidx < argspecs_len; argidx++)
1467 {
1468 if (!argspecs[argidx].arg_pos
1469 || (argspecs[argidx].width == STAR_FIELD_VALUE
1470 && !argspecs[argidx].width_pos)
1471 || (argspecs[argidx].precision == STAR_FIELD_VALUE
1472 && !argspecs[argidx].precision_pos))
1473 goto leave_einval;
1474 }
1475 }
1476 /* Check that there is no overflow in max_pos and that it has a
1477 reasonable length. There may never be more elements than the
1478 number of characters in FORMAT. */
1479 if (max_pos < 0 || max_pos >= strlen (format))
1480 goto leave_einval;
1481
1482 #ifdef TEST
1483 if (verbose > 1)
1484 dump_argspecs (argspecs, argspecs_len);
1485 #endif
1486
1487 /* Allocate a table to hold the values. If it is small enough we
1488 use a stack allocated buffer. */
1489 if (max_pos > DIM(valuetable_buffer))
1490 {
1491 valuetable = calloc (max_pos, sizeof *valuetable);
1492 if (!valuetable)
1493 goto leave_error;
1494 }
1495 else
1496 {
1497 for (validx=0; validx < DIM(valuetable_buffer); validx++)
1498 valuetable[validx].vt = VALTYPE_UNSUPPORTED;
1499 }
1500 for (argidx=0; argidx < argspecs_len; argidx++)
1501 {
1502 if (argspecs[argidx].arg_pos != - 1)
1503 {
1504 validx = argspecs[argidx].arg_pos - 1;
1505 if (valuetable[validx].vt)
1506 goto leave_einval; /* Already defined. */
1507 valuetable[validx].vt = argspecs[argidx].vt;
1508 }
1509 if (argspecs[argidx].width == STAR_FIELD_VALUE)
1510 {
1511 validx = argspecs[argidx].width_pos - 1;
1512 if (valuetable[validx].vt)
1513 goto leave_einval; /* Already defined. */
1514 valuetable[validx].vt = VALTYPE_INT;
1515 }
1516 if (argspecs[argidx].precision == STAR_FIELD_VALUE)
1517 {
1518 validx = argspecs[argidx].precision_pos - 1;
1519 if (valuetable[validx].vt)
1520 goto leave_einval; /* Already defined. */
1521 valuetable[validx].vt = VALTYPE_INT;
1522 }
1523 }
1524
1525 /* Read all the arguments. This will error out for unsupported
1526 types and for not given positional arguments. */
1527 rc = read_values (valuetable, max_pos, vaargs);
1528 if (rc)
1529 goto leave_einval;
1530
1531 /* for (validx=0; validx < max_pos; validx++) */
1532 /* fprintf (stderr, "%2d: vt=%d\n", validx, valuetable[validx].vt); */
1533
1534 /* Everything has been collected, go ahead with the formatting. */
1535 rc = do_format (outfnc, outfncarg, format,
1536 argspecs, argspecs_len, valuetable, myerrno, &nbytes);
1537
1538 goto leave;
1539
1540 leave_einval:
1541 errno = EINVAL;
1542 leave_error:
1543 rc = -1;
1544 leave:
1545 if (valuetable != valuetable_buffer)
1546 free (valuetable);
1547 if (argspecs != argspecs_buffer)
1548 free (argspecs);
1549 return rc;
1550 }
1551
1552
1553 \f
1554
1555 /* A simple output handler utilizing stdio. */
1556 static int
1557 plain_stdio_out (void *outfncarg, const char *buf, size_t buflen)
1558 {
1559 FILE *fp = (FILE*)outfncarg;
1560
1561 if ( fwrite (buf, buflen, 1, fp) != 1 )
1562 return -1;
1563 return 0;
1564 }
1565
1566
1567 /* A replacement for printf. */
1568 int
1569 estream_printf (const char *format, ...)
1570 {
1571 int rc;
1572 va_list arg_ptr;
1573
1574 va_start (arg_ptr, format);
1575 rc = estream_format (plain_stdio_out, stderr, format, arg_ptr);
1576 va_end (arg_ptr);
1577
1578 return rc;
1579 }
1580
1581 /* A replacement for fprintf. */
1582 int
1583 estream_fprintf (FILE *fp, const char *format, ...)
1584 {
1585 int rc;
1586 va_list arg_ptr;
1587
1588 va_start (arg_ptr, format);
1589 rc = estream_format (plain_stdio_out, fp, format, arg_ptr);
1590 va_end (arg_ptr);
1591
1592 return rc;
1593 }
1594
1595 /* A replacement for vfprintf. */
1596 int
1597 estream_vfprintf (FILE *fp, const char *format, va_list arg_ptr)
1598 {
1599 return estream_format (plain_stdio_out, fp, format, arg_ptr);
1600 }
1601
1602
1603 \f
1604 /* Communication object used between estream_snprintf and
1605 fixed_buffer_out. */
1606 struct fixed_buffer_parm_s
1607 {
1608 size_t size; /* Size of the buffer. */
1609 size_t count; /* Number of bytes requested for output. */
1610 size_t used; /* Used size of the buffer. */
1611 char *buffer; /* Provided buffer. */
1612 };
1613
1614 /* A simple malloced buffer output handler. */
1615 static int
1616 fixed_buffer_out (void *outfncarg, const char *buf, size_t buflen)
1617 {
1618 struct fixed_buffer_parm_s *parm = outfncarg;
1619
1620 parm->count += buflen;
1621
1622 if (!parm->buffer)
1623 ;
1624 else if (parm->used + buflen < parm->size)
1625 {
1626 /* Handle the common case that everything fits into the buffer
1627 separately. */
1628 memcpy (parm->buffer + parm->used, buf, buflen);
1629 parm->used += buflen;
1630 }
1631 else
1632 {
1633 /* The slow version of above. */
1634 for ( ;buflen && parm->used < parm->size; buflen--)
1635 parm->buffer[parm->used++] = *buf++;
1636 }
1637
1638 return 0;
1639 }
1640
1641
1642 /* A replacement for vsnprintf. */
1643 int
1644 estream_vsnprintf (char *buf, size_t bufsize,
1645 const char *format, va_list arg_ptr)
1646 {
1647 struct fixed_buffer_parm_s parm;
1648 int rc;
1649
1650 parm.size = bufsize? bufsize-1:0;
1651 parm.count = 0;
1652 parm.used = 0;
1653 parm.buffer = bufsize?buf:NULL;
1654 rc = estream_format (fixed_buffer_out, &parm, format, arg_ptr);
1655 if (!rc)
1656 rc = fixed_buffer_out (&parm, "", 1); /* Print terminating Nul. */
1657 if (rc == -1)
1658 return -1;
1659 if (bufsize && buf && parm.count >= parm.size)
1660 buf[parm.size-1] = 0;
1661
1662 return (int)parm.count; /* Return number of bytes which would have
1663 been written. */
1664 }
1665
1666 /* A replacement for snprintf. */
1667 int
1668 estream_snprintf (char *buf, size_t bufsize, const char *format, ...)
1669 {
1670 int rc;
1671 va_list arg_ptr;
1672
1673 va_start (arg_ptr, format);
1674 rc = estream_vsnprintf (buf, bufsize, format, arg_ptr);
1675 va_end (arg_ptr);
1676
1677 return rc;
1678 }
1679
1680
1681 \f
1682 /* Communication object used between estream_asprintf and
1683 dynamic_buffer_out. */
1684 struct dynamic_buffer_parm_s
1685 {
1686 int error_flag; /* Internal helper. */
1687 size_t alloced; /* Allocated size of the buffer. */
1688 size_t used; /* Used size of the buffer. */
1689 char *buffer; /* Malloced buffer. */
1690 };
1691
1692 /* A simple malloced buffer output handler. */
1693 static int
1694 dynamic_buffer_out (void *outfncarg, const char *buf, size_t buflen)
1695 {
1696 struct dynamic_buffer_parm_s *parm = outfncarg;
1697
1698 if (parm->error_flag)
1699 {
1700 /* Just in case some formatting routine did not checked for an
1701 error. */
1702 errno = parm->error_flag;
1703 return -1;
1704 }
1705
1706 if (parm->used + buflen >= parm->alloced)
1707 {
1708 char *p;
1709
1710 parm->alloced += buflen + 512;
1711 p = realloc (parm->buffer, parm->alloced);
1712 if (!p)
1713 {
1714 parm->error_flag = errno ? errno : ENOMEM;
1715 /* Wipe out what we already accumulated. This is useful in
1716 case sensitive data is formated. */
1717 memset (parm->buffer, 0, parm->used);
1718 return -1;
1719 }
1720 parm->buffer = p;
1721 }
1722 memcpy (parm->buffer + parm->used, buf, buflen);
1723 parm->used += buflen;
1724
1725 return 0;
1726 }
1727
1728
1729 /* A replacement for vasprintf. As with the BSD of vasprintf version -1
1730 will be returned on error and NULL stored at BUFP. On success the
1731 number of bytes printed will be returned. */
1732 int
1733 estream_vasprintf (char **bufp, const char *format, va_list arg_ptr)
1734 {
1735 struct dynamic_buffer_parm_s parm;
1736 int rc;
1737
1738 parm.error_flag = 0;
1739 parm.alloced = 512;
1740 parm.used = 0;
1741 parm.buffer = my_printf_malloc (parm.alloced);
1742 if (!parm.buffer)
1743 {
1744 *bufp = NULL;
1745 return -1;
1746 }
1747
1748 rc = estream_format (dynamic_buffer_out, &parm, format, arg_ptr);
1749 if (!rc)
1750 rc = dynamic_buffer_out (&parm, "", 1); /* Print terminating Nul. */
1751 /* Fixme: Should we shrink the resulting buffer? */
1752 if (rc != -1 && parm.error_flag)
1753 {
1754 rc = -1;
1755 errno = parm.error_flag;
1756 }
1757 if (rc == -1)
1758 {
1759 memset (parm.buffer, 0, parm.used);
1760 my_printf_free (parm.buffer);
1761 *bufp = NULL;
1762 return -1;
1763 }
1764 assert (parm.used); /* We have at least the terminating Nul. */
1765 *bufp = parm.buffer;
1766 return parm.used - 1; /* Do not include that Nul. */
1767 }
1768
1769 /* A replacement for asprintf. As with the BSD of asprintf version -1
1770 will be returned on error and NULL stored at BUFP. On success the
1771 number of bytes printed will be returned. */
1772 int
1773 estream_asprintf (char **bufp, const char *format, ...)
1774 {
1775 int rc;
1776 va_list arg_ptr;
1777
1778 va_start (arg_ptr, format);
1779 rc = estream_vasprintf (bufp, format, arg_ptr);
1780 va_end (arg_ptr);
1781
1782 return rc;
1783 }
1784
1785
1786 #ifdef TEST
1787
1788 static int
1789 one_test (const char *format, ...)
1790 {
1791 int rc1, rc2;
1792 va_list arg_ptr;
1793 char *buf1, *buf2;
1794
1795 if (verbose)
1796 printf ("format: ->%s<-\n", format);
1797
1798 va_start (arg_ptr, format);
1799 rc1 = vasprintf (&buf1, format, arg_ptr);
1800 va_end (arg_ptr);
1801 if (rc1 == -1)
1802 {
1803 printf (" sys: errno=%d (%s)\n", errno, strerror (errno));
1804 buf1 = NULL;
1805 }
1806 else if (verbose)
1807 printf (" sys: ->%s<-\n", buf1);
1808
1809 va_start (arg_ptr, format);
1810 rc2 = estream_vasprintf (&buf2, format, arg_ptr);
1811 va_end (arg_ptr);
1812 if (rc2 == -1)
1813 printf (" our: errno=%d (%s)\n", errno, strerror (errno));
1814 else if (verbose)
1815 printf (" our: ->%s<-\n", buf2);
1816
1817 if (rc1 != -1 && rc2 != -1 && strcmp (buf1, buf2))
1818 printf ("error: output does not match\n"
1819 "format: ->%s<-\n sys: ->%s<-\n our: ->%s<-\n",
1820 format, buf1, buf2);
1821 else if ( rc1 != rc2 )
1822 printf ("error: return codes are different: sys_rc=%d our_rc=%d\n",
1823 rc1, rc2);
1824
1825 free (buf2);
1826 free (buf1);
1827
1828 return 0;
1829 }
1830
1831
1832 static void
1833 run_tests (void)
1834 {
1835 /*one_test ("%d %% %'d", 17, 19681977);*/
1836
1837 one_test ("%d %% %d", 17, 768114563);
1838 one_test ("%d %% %d", 17, -768114563);
1839
1840 one_test ("%d", 17);
1841 one_test ("%4d", 17);
1842 one_test ("%40d", 17);
1843 one_test ("%-d", 17);
1844 one_test ("%-4d", 17);
1845 one_test ("%-140d", 17);
1846 one_test ("%d", -17);
1847 one_test ("%4d", -17);
1848 one_test ("%40d", -17);
1849 one_test ("%-d", -17);
1850 one_test ("%-4d", -17);
1851 one_test ("%-40d", -17);
1852
1853 one_test ("%+4d", 17);
1854 one_test ("%+4d", -17);
1855 one_test ("%-+4d", 17);
1856 one_test ("%-+4d", -17);
1857 one_test ("% 4d", 17);
1858 one_test ("% 4d", -17);
1859 one_test ("%- +4d", 17);
1860 one_test ("%- +4d", -17);
1861
1862 one_test ("%.4d", 17);
1863 one_test ("%.0d", 17);
1864 one_test ("%.0d", 0);
1865 one_test ("%.4d", -17);
1866 one_test ("%.0d", -17);
1867 one_test ("%6.4d", 17);
1868 one_test ("%6.4d", -17);
1869 one_test ("%6.0d", 0);
1870 one_test ("%4.6d", 17);
1871 one_test ("%4.6d", -17);
1872
1873 one_test ("% 4.6d", 17);
1874 one_test ("% 6.0d", 0);
1875
1876 one_test ("%.4d", 17);
1877 one_test ("%04d", 17);
1878 one_test ("%.4d", -17);
1879 one_test ("%04d", -17);
1880 one_test ("%0.d", 0);
1881
1882 one_test ("%*d", 7, 42);
1883 one_test ("%*d", -7, 42);
1884 one_test ("%.*d", 7, 42);
1885 one_test ("%.*d", -7, 42);
1886 one_test ("%*.*d", 10, 7, 42);
1887 one_test ("%*.*d", 10, -7, 42);
1888 one_test ("%*.*d", -10, 7, 42);
1889 one_test ("%*.*d", -10, -7, 42);
1890
1891 one_test ("%*x", 7, 42);
1892 one_test ("%*x", -7, 42);
1893 one_test ("%.*x", 7, 42);
1894 one_test ("%.*x", -7, 42);
1895 one_test ("%*.*x", 10, 7, 42);
1896 one_test ("%*.*x", 10, -7, 42);
1897 one_test ("%*.*x", -10, 7, 42);
1898 one_test ("%*.*x", -10, -7, 42);
1899 one_test ("%#*x", 7, 42);
1900 one_test ("%#*x", -7, 42);
1901 one_test ("%#.*x", 7, 42);
1902 one_test ("%#.*x", -7, 42);
1903 one_test ("%#*.*x", 10, 7, 42);
1904 one_test ("%#*.*x", 10, -7, 42);
1905 one_test ("%#*.*x", -10, 7, 42);
1906 one_test ("%#*.*x", -10, -7, 42);
1907
1908 one_test ("%*X", 7, 42);
1909 one_test ("%*X", -7, 42);
1910 one_test ("%.*X", 7, 42);
1911 one_test ("%.*X", -7, 42);
1912 one_test ("%*.*X", 10, 7, 42);
1913 one_test ("%*.*X", 10, -7, 42);
1914 one_test ("%*.*X", -10, 7, 42);
1915 one_test ("%*.*X", -10, -7, 42);
1916 one_test ("%#*X", 7, 42);
1917 one_test ("%#*X", -7, 42);
1918 one_test ("%#.*X", 7, 42);
1919 one_test ("%#.*X", -7, 42);
1920 one_test ("%#*.*X", 10, 7, 42);
1921 one_test ("%#*.*X", 10, -7, 42);
1922 one_test ("%#*.*X", -10, 7, 42);
1923 one_test ("%#*.*X", -10, -7, 42);
1924
1925 one_test ("%*o", 7, 42);
1926 one_test ("%*o", -7, 42);
1927 one_test ("%.*o", 7, 42);
1928 one_test ("%.*o", -7, 42);
1929 one_test ("%*.*o", 10, 7, 42);
1930 one_test ("%*.*o", 10, -7, 42);
1931 one_test ("%*.*o", -10, 7, 42);
1932 one_test ("%*.*o", -10, -7, 42);
1933 one_test ("%#*o", 7, 42);
1934 one_test ("%#*o", -7, 42);
1935 one_test ("%#.*o", 7, 42);
1936 one_test ("%#.*o", -7, 42);
1937 one_test ("%#*.*o", 10, 7, 42);
1938 one_test ("%#*.*o", 10, -7, 42);
1939 one_test ("%#*.*o", -10, 7, 42);
1940 one_test ("%#*.*o", -10, -7, 42);
1941
1942 one_test ("%s", "the quick brown fox jumps over the lazy dogs back");
1943 one_test ("%.0s", "the quick brown fox jumps over the lazy dogs back");
1944 one_test ("%.10s", "the quick brown fox jumps over the lazy dogs back");
1945 one_test ("%.48s", "the quick brown fox jumps over the lazy dogs back");
1946 one_test ("%.49s", "the quick brown fox jumps over the lazy dogs back");
1947 one_test ("%.50s", "the quick brown fox jumps over the lazy dogs back");
1948 one_test ("%.51s", "the quick brown fox jumps over the lazy dogs back");
1949 one_test ("%48s", "the quick brown fox jumps over the lazy dogs back");
1950 one_test ("%49s", "the quick brown fox jumps over the lazy dogs back");
1951 one_test ("%50s", "the quick brown fox jumps over the lazy dogs back");
1952 one_test ("%51s", "the quick brown fox jumps over the lazy dogs back");
1953 one_test ("%-51s", "the quick brown fox jumps over the lazy dogs back");
1954
1955 one_test ("/%s=", "CN");
1956
1957 one_test ("%f", 3.1415926535);
1958 one_test ("%f", -3.1415926535);
1959 one_test ("%.10f", 3.1415926535);
1960 one_test ("%.2f", 3.1415926535);
1961 one_test ("%.1f", 3.1415926535);
1962 one_test ("%.0f", 3.1415926535);
1963 one_test ("%.20f", 3.1415926535);
1964 one_test ("%10.10f", 3.1415926535);
1965 one_test ("%10.2f", 3.1415926535);
1966 one_test ("%10.1f", 3.1415926535);
1967 one_test ("%10.0f", 3.1415926535);
1968 one_test ("%30.20f", 3.1415926535);
1969 one_test ("%10.10f", -3.1415926535);
1970 one_test ("%10.2f", -3.1415926535);
1971 one_test ("%10.1f", -3.1415926535);
1972 one_test ("%10.0f", -3.1415926535);
1973 one_test ("%30.20f", -3.1415926535);
1974
1975 one_test ("%-10f", 3.1415926535);
1976 one_test ("%-10.10f", 3.1415926535);
1977 one_test ("%-10.2f", 3.1415926535);
1978 one_test ("%-10.1f", 3.1415926535);
1979 one_test ("%-10.0f", 3.1415926535);
1980 one_test ("%-30.20f", 3.1415926535);
1981 one_test ("%-10f", -3.1415926535);
1982 one_test ("%-10.10f", -3.1415926535);
1983 one_test ("%-10.2f", -3.1415926535);
1984 one_test ("%-10.1f", -3.1415926535);
1985 one_test ("%-10.0f", -3.1415926535);
1986 one_test ("%-30.20f", -3.1415926535);
1987
1988 one_test ("%#.0f", 3.1415926535);
1989 one_test ("%#10.0f", 3.1415926535);
1990 one_test ("%#10.0f", -3.1415926535);
1991 one_test ("%-#10.0f", 3.1415926535);
1992 one_test ("%-#10.0f", -3.1415926535);
1993
1994 one_test ("%e", 3.1415926535);
1995 one_test ("%g", 3.1415926535);
1996
1997 one_test ("%a", 1);
1998 one_test ("%a", -1);
1999 one_test ("%a", 3.1415926535);
2000
2001 #ifdef HAVE_LONG_DOUBLE
2002 one_test ("%La", 1);
2003 one_test ("%La", -1);
2004 one_test ("%La", 3.1415926535);
2005 #endif
2006
2007 #ifdef __GLIBC__
2008 /* "%m" is a glibc extension so this _test_ will only work on such a
2009 system. */
2010 errno = ENOENT;
2011 one_test ("%m");
2012 errno = ENOENT;
2013 one_test ("%d=%m", 17);
2014 errno = ENOENT;
2015 one_test ("%2$d:%m:%1$d", 42, 17);
2016 #endif /*__GLIBC__*/
2017
2018 }
2019
2020 static void
2021 check_snprintf (void)
2022 {
2023 char buffer[20];
2024 int rc;
2025
2026 rc = estream_snprintf (buffer, 0, "%*s", 18, "");
2027 if (rc != 19)
2028 printf ("rc=%d\n", rc );
2029 rc = estream_snprintf (buffer, sizeof buffer, "%*s", 18, "");
2030 if (rc != 19)
2031 printf ("rc=%d, strlen(buffer)=%d\n", rc, (int)strlen (buffer));
2032 rc = estream_snprintf (buffer, sizeof buffer, "%*s", 19, "");
2033 if (rc != 20)
2034 printf ("rc=%d, strlen(buffer)=%d\n", rc, (int)strlen (buffer));
2035 rc = estream_snprintf (buffer, sizeof buffer, "%*s", 20, "");
2036 if (rc != 21)
2037 printf ("rc=%d, strlen(buffer)=%d\n", rc, (int)strlen (buffer));
2038 rc = estream_snprintf (buffer, sizeof buffer, "%*s", 21, "");
2039 if (rc != 22)
2040 printf ("rc=%d, strlen(buffer)=%d\n", rc, (int)strlen (buffer));
2041 }
2042
2043
2044
2045 int
2046 main (int argc, char **argv)
2047 {
2048 int rc;
2049
2050 if (argc) {argc--; argv++; }
2051
2052 setlocale (LC_NUMERIC, "");
2053
2054 while (argc && !strcmp (*argv, "--verbose"))
2055 {
2056 verbose++;
2057 argc--;
2058 argv++;
2059 }
2060
2061 if (!argc)
2062 {
2063 run_tests ();
2064 check_snprintf () ;
2065 }
2066 else
2067 {
2068 rc = estream_vfprintf (stdout, argv[0], NULL);
2069 fflush (stdout);
2070 fprintf (stderr, "[estream_vfprintf returns: %d]\n", rc);
2071 }
2072
2073 return 0;
2074 }
2075 #endif /*TEST*/
2076 /*
2077 Local Variables:
2078 compile-command: "cc -Wall -O3 -g -I.. -DHAVE_CONFIG_H -DTEST -o estream-printf estream-printf.c"
2079 End:
2080 */
gnupg svn clone