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
36 #include "lc_common_t.h"
38 #include "lc_printf.h"
39 #include "lc_defines.h"
43 /* printf implementation */
45 typedef struct _lc_arg_t {
46 struct _lc_arg_t *next;
50 const lc_arg_handler_t *handler;
53 struct _lc_arg_env_t {
54 set *args; /**< Map for named arguments. */
55 lc_arg_t *lower[26]; /**< Map for lower conversion specifiers. */
56 lc_arg_t *upper[26]; /**< Map for upper conversion specifiers. */
59 /** The default argument environment. */
60 static lc_arg_env_t *default_env = NULL;
62 static inline lc_arg_env_t *_lc_arg_get_default_env(void)
65 default_env = lc_arg_add_std(lc_arg_new_env());
70 lc_arg_env_t *lc_arg_get_default_env(void)
72 return _lc_arg_get_default_env();
75 static int lc_arg_cmp(const void *p1, const void *p2, UNUSED(size_t size))
77 const lc_arg_t *a1 = p1;
78 const lc_arg_t *a2 = p2;
79 return strcmp(a1->name, a2->name);
83 lc_arg_env_t *lc_arg_new_env(void)
85 lc_arg_env_t *env = XMALLOCZ(lc_arg_env_t);
86 env->args = new_set(lc_arg_cmp, 16);
90 void lc_arg_free_env(lc_arg_env_t *env)
96 int lc_arg_register(lc_arg_env_t *env, const char *name, char letter, const lc_arg_handler_t *handler)
101 lc_arg_t **map = NULL;
105 arg.handler = handler;
107 if(isupper(letter)) {
111 else if(islower(letter)) {
116 ent = set_insert(env->args, &arg, sizeof(arg), HASH_STR(name, strlen(name)));
119 map[letter - base] = ent;
124 void lc_arg_unregister(UNUSED(lc_arg_env_t *env), UNUSED(const char *name))
128 int lc_arg_append(lc_appendable_t *app, const lc_arg_occ_t *occ, const char *str, size_t len)
132 /* Set the padding to zero, if the zero is given and we are not left
133 * justified. (A minus overrides the zero). See printf(3). */
134 if(!occ->flag_minus && occ->flag_zero)
137 return lc_appendable_snwadd(app, str, len, LC_MAX(0, occ->width), occ->flag_minus, pad);
141 static int dispatch_snprintf(char *buf, size_t len, const char *fmt,
142 int lc_arg_type, const lc_arg_value_t *val)
146 switch(lc_arg_type) {
147 #define LC_ARG_TYPE(type,name) \
148 case lc_arg_type_ ## name: res = snprintf(buf, len, fmt, val->v_ ## name); break;
149 #include "lc_printf_arg_types.def"
156 static char *make_fmt(char *buf, size_t len, const lc_arg_occ_t *occ)
165 if(occ->precision > 0)
166 snprintf(prec, sizeof(prec), ".%d", occ->precision);
169 snprintf(width, sizeof(width), "%d", occ->width);
171 assert(occ->modifier && "modifier must not be NULL");
172 strncpy(mod, occ->modifier, sizeof(mod) - 1);
173 mod[LC_MIN(sizeof(mod) - 1, occ->modifier_length)] = '\0';
175 snprintf(buf, len, "%%%s%s%s%s%s%s%s%s%c",
176 occ->flag_space ? "#" : "",
177 occ->flag_hash ? "#" : "",
178 occ->flag_plus ? "+" : "",
179 occ->flag_minus ? "-" : "",
180 occ->flag_zero ? "0" : "",
182 mod, occ->conversion);
188 * Standard argument handler.
190 static int std_get_lc_arg_type(const lc_arg_occ_t *occ)
192 int modlen = occ->modifier_length;
194 /* check, if the type can be derived from the modifier */
196 const char *mod = occ->modifier;
199 return modlen > 1 && mod[1] == 'l' ? lc_arg_type_long_long : lc_arg_type_long;
200 #define TYPE_CASE(letter,type) case letter: return lc_arg_type_ ## type;
202 TYPE_CASE('j', intmax_t);
203 TYPE_CASE('z', size_t);
204 TYPE_CASE('t', ptrdiff_t);
206 TYPE_CASE('L', long_double);
211 /* The type is given by the conversion specifier and cannot be
212 * determined from the modifier. */
213 switch (occ->conversion) {
220 return lc_arg_type_double;
224 return lc_arg_type_ptr;
226 return lc_arg_type_int;
230 static int std_emit(lc_appendable_t *app, const lc_arg_occ_t *occ, const lc_arg_value_t *val)
235 make_fmt(fmt, sizeof(fmt), occ);
237 switch(occ->conversion) {
239 /* Store the number of written characters in the given
240 * int pointer location */
243 int *num = val->v_ptr;
248 /* strings are dumped directly, since they can get really big. A
249 * buffer of 128 letters for all other types should be enough. */
252 const char *str = val->v_ptr;
253 res = lc_arg_append(app, occ, str, strlen(str));
259 int len = LC_MAX(128, occ->width + 1);
260 char *buf = XMALLOCN(char, len);
261 res = dispatch_snprintf(buf, len, fmt, occ->lc_arg_type, val);
262 res = lc_appendable_snadd(app, buf, res);
270 static const lc_arg_handler_t std_handler = {
275 lc_arg_env_t *lc_arg_add_std(lc_arg_env_t *env)
277 lc_arg_register(env, "std:c", 'c', &std_handler);
278 lc_arg_register(env, "std:i", 'i', &std_handler);
279 lc_arg_register(env, "std:d", 'd', &std_handler);
280 lc_arg_register(env, "std:o", 'o', &std_handler);
281 lc_arg_register(env, "std:u", 'u', &std_handler);
282 lc_arg_register(env, "std:x", 'x', &std_handler);
283 lc_arg_register(env, "std:X", 'X', &std_handler);
285 lc_arg_register(env, "std:e", 'e', &std_handler);
286 lc_arg_register(env, "std:E", 'E', &std_handler);
287 lc_arg_register(env, "std:f", 'f', &std_handler);
288 lc_arg_register(env, "std:F", 'F', &std_handler);
289 lc_arg_register(env, "std:g", 'g', &std_handler);
290 lc_arg_register(env, "std:G", 'G', &std_handler);
292 lc_arg_register(env, "std:s", 's', &std_handler);
293 lc_arg_register(env, "std:p", 'p', &std_handler);
294 lc_arg_register(env, "std:n", 'n', &std_handler);
299 static char *read_int(const char *s, int *value)
302 int res = (int) strtol(s, &endptr, 10);
303 *value = endptr == s ? -1 : res;
307 /* Generic printf() function. */
309 int lc_evpprintf(const lc_arg_env_t *env, lc_appendable_t *app, const char *fmt, va_list args)
313 const char *last = fmt + strlen(fmt);
315 /* Find the first % */
316 s = strchr(fmt, '%');
318 /* Emit the text before the first % was found */
319 lc_appendable_snadd(app, fmt, (s ? s : last) - fmt);
324 const lc_arg_t *arg = NULL;
328 /* We must be at a '%' */
331 /* Reset the occurrence structure */
332 memset(&occ, 0, sizeof(occ));
334 /* Eat all flags and set the corresponding flags in the occ struct */
335 for(++s; strchr("#0-+", *s); ++s) {
355 /* Read the width if given */
356 s = read_int(s, &occ.width);
360 /* read the precision if given */
363 s = read_int(s + 1, &val);
365 /* Negative or lacking precision after a '.' is treated as
367 occ.precision = LC_MAX(0, val);
371 * Now, we can either have:
372 * - a named argument like {node}
373 * - some modifiers followed by a conversion specifier
374 * - or some other character, which ends this format invalidly
380 res += lc_appendable_chadd(app, '%');
384 const char *named = ++s;
386 /* Read until the closing brace or end of the string. */
387 for(ch = *s; ch != '}' && ch != '\0'; ch = *++s);
394 name = malloc(sizeof(char) * (n + 1));
395 memcpy(name, named, sizeof(char) * n);
399 arg = set_find(env->args, &tmp, sizeof(tmp), HASH_STR(named, n));
401 occ.modifier_length = 0;
403 /* Set the conversion specifier of the occurrence to the
404 * letter specified in the argument description. */
406 occ.conversion = arg->letter;
410 /* If we ended with a closing brace, move the current
411 * pointer after it, since it is not to be dumped. */
422 /* Read, as long there are letters */
423 while(isalpha(ch) && !arg) {
425 lc_arg_t * const *map = env->lower;
427 /* If uppercase, select the uppercase map from the environment */
433 if(map[ch - base] != NULL) {
435 occ.modifier_length = s - mod;
437 arg = map[ch - base];
445 /* Call the handler if an argument was determined */
446 if(arg != NULL && arg->handler != NULL) {
447 const lc_arg_handler_t *handler = arg->handler;
449 /* Let the handler determine the type of the argument based on the
450 * information gathered. */
451 occ.lc_arg_type = handler->get_lc_arg_type(&occ);
453 /* Store the value according to argument information */
454 switch(occ.lc_arg_type) {
455 #define LC_ARG_TYPE(type,name) case lc_arg_type_ ## name: val.v_ ## name = va_arg(args, type); break;
456 #include "lc_printf_arg_types.def"
460 /* Finally, call the handler. */
461 res += handler->emit(app, &occ, &val);
466 res += lc_appendable_snadd(app, old, (s ? s : last) - old);
472 /* Convenience implementations */
474 int lc_epprintf(const lc_arg_env_t *env, lc_appendable_t *app, const char *fmt, ...)
479 res = lc_evpprintf(env, app, fmt, args);
484 int lc_pprintf(lc_appendable_t *app, const char *fmt, ...)
489 res = lc_vpprintf(app, fmt, args);
494 int lc_vpprintf(lc_appendable_t *app, const char *fmt, va_list args)
496 return lc_evpprintf(_lc_arg_get_default_env(), app, fmt, args);
499 int lc_eprintf(const lc_arg_env_t *env, const char *fmt, ...)
504 res = lc_efprintf(env, stdout, fmt, args);
509 int lc_esnprintf(const lc_arg_env_t *env, char *buf, size_t len, const char *fmt, ...)
514 res = lc_evsnprintf(env, buf, len, fmt, args);
519 int lc_efprintf(const lc_arg_env_t *env, FILE *file, const char *fmt, ...)
524 res = lc_evfprintf(env, file, fmt, args);
529 int lc_eoprintf(const lc_arg_env_t *env, struct obstack *obst, const char *fmt, ...)
534 res = lc_evoprintf(env, obst, fmt, args);
539 int lc_evprintf(const lc_arg_env_t *env, const char *fmt, va_list args)
541 return lc_evfprintf(env, stdout, fmt, args);
544 int lc_evsnprintf(const lc_arg_env_t *env, char *buf, size_t len, const char *fmt, va_list args)
549 lc_appendable_init(&app, lc_appendable_string, buf, len);
550 res = lc_evpprintf(env, &app, fmt, args);
551 lc_appendable_finish(&app);
555 int lc_evfprintf(const lc_arg_env_t *env, FILE *f, const char *fmt, va_list args)
560 lc_appendable_init(&app, lc_appendable_file, f, 0);
561 res = lc_evpprintf(env, &app, fmt, args);
562 lc_appendable_finish(&app);
566 int lc_evoprintf(const lc_arg_env_t *env, struct obstack *obst, const char *fmt, va_list args)
571 lc_appendable_init(&app, lc_appendable_obstack, obst, 0);
572 res = lc_evpprintf(env, &app, fmt, args);
573 lc_appendable_finish(&app);
578 int lc_printf(const char *fmt, ...)
583 res = lc_vprintf(fmt, args);
588 int lc_snprintf(char *buf, size_t len, const char *fmt, ...)
593 res = lc_vsnprintf(buf, len, fmt, args);
598 int lc_fprintf(FILE *f, const char *fmt, ...)
603 res = lc_vfprintf(f, fmt, args);
608 int lc_oprintf(struct obstack *obst, const char *fmt, ...)
613 res = lc_voprintf(obst, fmt, args);
619 int lc_vprintf(const char *fmt, va_list args)
621 return lc_evprintf(_lc_arg_get_default_env(), fmt, args);
624 int lc_vsnprintf(char *buf, size_t len, const char *fmt, va_list args)
626 return lc_evsnprintf(_lc_arg_get_default_env(), buf, len, fmt, args);
629 int lc_vfprintf(FILE *f, const char *fmt, va_list args)
631 return lc_evfprintf(_lc_arg_get_default_env(), f, fmt, args);
634 int lc_voprintf(struct obstack *obst, const char *fmt, va_list args)
636 return lc_evoprintf(_lc_arg_get_default_env(), obst, fmt, args);