2 libcore: library for basic data structures and algorithms.
3 Copyright (C) 2005 IPD Goos, Universit"at Karlsruhe, Germany
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with this library; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 * A customizable printf clone.
23 * @author Sebastian Hack
38 #include "lc_common_t.h"
40 #include "lc_printf.h"
41 #include "lc_defines.h"
45 /* printf implementation */
47 typedef struct _lc_arg_t {
48 struct _lc_arg_t *next;
52 const lc_arg_handler_t *handler;
55 struct _lc_arg_env_t {
56 set *args; /**< Map for named arguments. */
57 lc_arg_t *lower[26]; /**< Map for lower conversion specifiers. */
58 lc_arg_t *upper[26]; /**< Map for upper conversion specifiers. */
61 /** The default argument environment. */
62 static lc_arg_env_t *default_env = NULL;
64 static INLINE lc_arg_env_t *_lc_arg_get_default_env(void)
67 default_env = lc_arg_add_std(lc_arg_new_env());
72 lc_arg_env_t *lc_arg_get_default_env(void)
74 return _lc_arg_get_default_env();
77 static int lc_arg_cmp(const void *p1, const void *p2, UNUSED(size_t size))
79 const lc_arg_t *a1 = p1;
80 const lc_arg_t *a2 = p2;
81 return strcmp(a1->name, a2->name);
85 lc_arg_env_t *lc_arg_new_env(void)
87 lc_arg_env_t *env = XMALLOCZ(lc_arg_env_t);
88 env->args = new_set(lc_arg_cmp, 16);
92 void lc_arg_free_env(lc_arg_env_t *env)
98 int lc_arg_register(lc_arg_env_t *env, const char *name, char letter, const lc_arg_handler_t *handler)
103 lc_arg_t **map = NULL;
107 arg.handler = handler;
109 if(isupper(letter)) {
113 else if(islower(letter)) {
118 ent = set_insert(env->args, &arg, sizeof(arg), HASH_STR(name, strlen(name)));
121 map[letter - base] = ent;
126 void lc_arg_unregister(UNUSED(lc_arg_env_t *env), UNUSED(const char *name))
130 int lc_arg_append(lc_appendable_t *app, const lc_arg_occ_t *occ, const char *str, size_t len)
134 /* Set the padding to zero, if the zero is given and we are not left
135 * justified. (A minus overrides the zero). See printf(3). */
136 if(!occ->flag_minus && occ->flag_zero)
139 return lc_appendable_snwadd(app, str, len, LC_MAX(0, occ->width), occ->flag_minus, pad);
143 static int dispatch_snprintf(char *buf, size_t len, const char *fmt,
144 int lc_arg_type, const lc_arg_value_t *val)
148 switch(lc_arg_type) {
149 #define LC_ARG_TYPE(type,name) \
150 case lc_arg_type_ ## name: res = snprintf(buf, len, fmt, val->v_ ## name); break;
151 #include "lc_printf_arg_types.def"
158 static char *make_fmt(char *buf, size_t len, const lc_arg_occ_t *occ)
167 if(occ->precision > 0)
168 snprintf(prec, sizeof(prec), ".%d", occ->precision);
171 snprintf(width, sizeof(width), "%d", occ->width);
173 assert(occ->modifier && "modifier must not be NULL");
174 strncpy(mod, occ->modifier, sizeof(mod) - 1);
175 mod[LC_MIN(sizeof(mod) - 1, occ->modifier_length)] = '\0';
177 snprintf(buf, len, "%%%s%s%s%s%s%s%s%s%c",
178 occ->flag_space ? "#" : "",
179 occ->flag_hash ? "#" : "",
180 occ->flag_plus ? "+" : "",
181 occ->flag_minus ? "-" : "",
182 occ->flag_zero ? "0" : "",
184 mod, occ->conversion);
190 * Standard argument handler.
192 static int std_get_lc_arg_type(const lc_arg_occ_t *occ)
194 int modlen = occ->modifier_length;
196 /* check, if the type can be derived from the modifier */
198 const char *mod = occ->modifier;
201 return modlen > 1 && mod[1] == 'l' ? lc_arg_type_long_long : lc_arg_type_long;
202 #define TYPE_CASE(letter,type) case letter: return lc_arg_type_ ## type;
204 TYPE_CASE('j', intmax_t);
205 TYPE_CASE('z', size_t);
206 TYPE_CASE('t', ptrdiff_t);
208 TYPE_CASE('L', long_double);
213 /* The type is given by the conversion specifier and cannot be
214 * determined from the modifier. */
215 switch (occ->conversion) {
222 return lc_arg_type_double;
226 return lc_arg_type_ptr;
228 return lc_arg_type_int;
232 static int std_emit(lc_appendable_t *app, const lc_arg_occ_t *occ, const lc_arg_value_t *val)
237 make_fmt(fmt, sizeof(fmt), occ);
239 switch(occ->conversion) {
241 /* Store the number of written characters in the given
242 * int pointer location */
245 int *num = val->v_ptr;
250 /* strings are dumped directly, since they can get really big. A
251 * buffer of 128 letters for all other types should be enough. */
254 const char *str = val->v_ptr;
255 res = lc_arg_append(app, occ, str, strlen(str));
261 int len = LC_MAX(128, occ->width + 1);
262 char *buf = XMALLOCN(char, len);
263 res = dispatch_snprintf(buf, len, fmt, occ->lc_arg_type, val);
264 res = lc_appendable_snadd(app, buf, res);
272 static const lc_arg_handler_t std_handler = {
277 lc_arg_env_t *lc_arg_add_std(lc_arg_env_t *env)
279 lc_arg_register(env, "std:c", 'c', &std_handler);
280 lc_arg_register(env, "std:i", 'i', &std_handler);
281 lc_arg_register(env, "std:d", 'd', &std_handler);
282 lc_arg_register(env, "std:o", 'o', &std_handler);
283 lc_arg_register(env, "std:u", 'u', &std_handler);
284 lc_arg_register(env, "std:x", 'x', &std_handler);
285 lc_arg_register(env, "std:X", 'X', &std_handler);
287 lc_arg_register(env, "std:e", 'e', &std_handler);
288 lc_arg_register(env, "std:E", 'E', &std_handler);
289 lc_arg_register(env, "std:f", 'f', &std_handler);
290 lc_arg_register(env, "std:F", 'F', &std_handler);
291 lc_arg_register(env, "std:g", 'g', &std_handler);
292 lc_arg_register(env, "std:G", 'G', &std_handler);
294 lc_arg_register(env, "std:s", 's', &std_handler);
295 lc_arg_register(env, "std:p", 'p', &std_handler);
296 lc_arg_register(env, "std:n", 'n', &std_handler);
301 static char *read_int(const char *s, int *value)
304 int res = (int) strtol(s, &endptr, 10);
305 *value = endptr == s ? -1 : res;
309 /* Generic printf() function. */
311 int lc_evpprintf(const lc_arg_env_t *env, lc_appendable_t *app, const char *fmt, va_list args)
315 const char *last = fmt + strlen(fmt);
317 /* Find the first % */
318 s = strchr(fmt, '%');
320 /* Emit the text before the first % was found */
321 lc_appendable_snadd(app, fmt, (s ? s : last) - fmt);
326 const lc_arg_t *arg = NULL;
330 /* We must be at a '%' */
333 /* Reset the occurrence structure */
334 memset(&occ, 0, sizeof(occ));
336 /* Eat all flags and set the corresponding flags in the occ struct */
337 for(++s; strchr("#0-+", *s); ++s) {
357 /* Read the width if given */
358 s = read_int(s, &occ.width);
362 /* read the precision if given */
365 s = read_int(s + 1, &val);
367 /* Negative or lacking precision after a '.' is treated as
369 occ.precision = LC_MAX(0, val);
373 * Now, we can either have:
374 * - a named argument like {node}
375 * - some modifiers followed by a conversion specifier
376 * - or some other character, which ends this format invalidly
382 res += lc_appendable_chadd(app, '%');
386 const char *named = ++s;
388 /* Read until the closing brace or end of the string. */
389 for(ch = *s; ch != '}' && ch != '\0'; ch = *++s);
396 name = malloc(sizeof(char) * (n + 1));
397 memcpy(name, named, sizeof(char) * n);
401 arg = set_find(env->args, &tmp, sizeof(tmp), HASH_STR(named, n));
403 occ.modifier_length = 0;
405 /* Set the conversion specifier of the occurrence to the
406 * letter specified in the argument description. */
408 occ.conversion = arg->letter;
412 /* If we ended with a closing brace, move the current
413 * pointer after it, since it is not to be dumped. */
424 /* Read, as long there are letters */
425 while(isalpha(ch) && !arg) {
427 lc_arg_t * const *map = env->lower;
429 /* If uppercase, select the uppercase map from the environment */
435 if(map[ch - base] != NULL) {
437 occ.modifier_length = s - mod;
439 arg = map[ch - base];
447 /* Call the handler if an argument was determined */
448 if(arg != NULL && arg->handler != NULL) {
449 const lc_arg_handler_t *handler = arg->handler;
451 /* Let the handler determine the type of the argument based on the
452 * information gathered. */
453 occ.lc_arg_type = handler->get_lc_arg_type(&occ);
455 /* Store the value according to argument information */
456 switch(occ.lc_arg_type) {
457 #define LC_ARG_TYPE(type,name) case lc_arg_type_ ## name: val.v_ ## name = va_arg(args, type); break;
458 #include "lc_printf_arg_types.def"
462 /* Finally, call the handler. */
463 res += handler->emit(app, &occ, &val);
468 res += lc_appendable_snadd(app, old, (s ? s : last) - old);
474 /* Convenience implementations */
476 int lc_epprintf(const lc_arg_env_t *env, lc_appendable_t *app, const char *fmt, ...)
481 res = lc_evpprintf(env, app, fmt, args);
486 int lc_pprintf(lc_appendable_t *app, const char *fmt, ...)
491 res = lc_vpprintf(app, fmt, args);
496 int lc_vpprintf(lc_appendable_t *app, const char *fmt, va_list args)
498 return lc_evpprintf(_lc_arg_get_default_env(), app, fmt, args);
501 int lc_eprintf(const lc_arg_env_t *env, const char *fmt, ...)
506 res = lc_efprintf(env, stdout, fmt, args);
511 int lc_esnprintf(const lc_arg_env_t *env, char *buf, size_t len, const char *fmt, ...)
516 res = lc_evsnprintf(env, buf, len, fmt, args);
521 int lc_efprintf(const lc_arg_env_t *env, FILE *file, const char *fmt, ...)
526 res = lc_evfprintf(env, file, fmt, args);
531 int lc_eoprintf(const lc_arg_env_t *env, struct obstack *obst, const char *fmt, ...)
536 res = lc_evoprintf(env, obst, fmt, args);
541 int lc_evprintf(const lc_arg_env_t *env, const char *fmt, va_list args)
543 return lc_evfprintf(env, stdout, fmt, args);
546 int lc_evsnprintf(const lc_arg_env_t *env, char *buf, size_t len, const char *fmt, va_list args)
551 lc_appendable_init(&app, lc_appendable_string, buf, len);
552 res = lc_evpprintf(env, &app, fmt, args);
553 lc_appendable_finish(&app);
557 int lc_evfprintf(const lc_arg_env_t *env, FILE *f, const char *fmt, va_list args)
562 lc_appendable_init(&app, lc_appendable_file, f, 0);
563 res = lc_evpprintf(env, &app, fmt, args);
564 lc_appendable_finish(&app);
568 int lc_evoprintf(const lc_arg_env_t *env, struct obstack *obst, const char *fmt, va_list args)
573 lc_appendable_init(&app, lc_appendable_obstack, obst, 0);
574 res = lc_evpprintf(env, &app, fmt, args);
575 lc_appendable_finish(&app);
580 int lc_printf(const char *fmt, ...)
585 res = lc_vprintf(fmt, args);
590 int lc_snprintf(char *buf, size_t len, const char *fmt, ...)
595 res = lc_vsnprintf(buf, len, fmt, args);
600 int lc_fprintf(FILE *f, const char *fmt, ...)
605 res = lc_vfprintf(f, fmt, args);
610 int lc_oprintf(struct obstack *obst, const char *fmt, ...)
615 res = lc_voprintf(obst, fmt, args);
621 int lc_vprintf(const char *fmt, va_list args)
623 return lc_evprintf(_lc_arg_get_default_env(), fmt, args);
626 int lc_vsnprintf(char *buf, size_t len, const char *fmt, va_list args)
628 return lc_evsnprintf(_lc_arg_get_default_env(), buf, len, fmt, args);
631 int lc_vfprintf(FILE *f, const char *fmt, va_list args)
633 return lc_evfprintf(_lc_arg_get_default_env(), f, fmt, args);
636 int lc_voprintf(struct obstack *obst, const char *fmt, va_list args)
638 return lc_evoprintf(_lc_arg_get_default_env(), obst, fmt, args);