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
35 #include "lc_common_t.h"
37 #include "lc_printf.h"
38 #include "lc_defines.h"
42 /* printf implementation */
44 typedef struct _lc_arg_t {
45 struct _lc_arg_t *next;
49 const lc_arg_handler_t *handler;
52 struct _lc_arg_env_t {
53 set *args; /**< Map for named arguments. */
54 lc_arg_t *lower[26]; /**< Map for lower conversion specifiers. */
55 lc_arg_t *upper[26]; /**< Map for upper conversion specifiers. */
58 /** The default argument environment. */
59 static lc_arg_env_t *default_env = NULL;
61 static INLINE lc_arg_env_t *_lc_arg_get_default_env(void)
64 default_env = lc_arg_add_std(lc_arg_new_env());
69 lc_arg_env_t *lc_arg_get_default_env(void)
71 return _lc_arg_get_default_env();
74 static int lc_arg_cmp(const void *p1, const void *p2, UNUSED(size_t size))
76 const lc_arg_t *a1 = p1;
77 const lc_arg_t *a2 = p2;
78 return strcmp(a1->name, a2->name);
82 lc_arg_env_t *lc_arg_new_env(void)
84 lc_arg_env_t *env = xmalloc(sizeof(*env));
85 memset(env, 0, sizeof(*env));
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 ovverides 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;
193 const char *mod = occ->modifier;
197 /* check, if the type can be derived from the modifier */
201 res = modlen > 1 && mod[1] == 'l' ? lc_arg_type_long_long : lc_arg_type_long;
203 #define TYPE_CASE(letter,type) case letter: res = lc_arg_type_ ## type; break
205 TYPE_CASE('j', intmax_t);
206 TYPE_CASE('z', size_t);
207 TYPE_CASE('t', ptrdiff_t);
209 TYPE_CASE('L', long_double);
214 /* The type is given by the conversion specifier and cannot be
215 * determined from the modifier. */
217 switch(occ->conversion) {
224 res = lc_arg_type_double;
229 res = lc_arg_type_ptr;
232 res = lc_arg_type_int;
239 static int std_emit(lc_appendable_t *app, const lc_arg_occ_t *occ, const lc_arg_value_t *val)
244 make_fmt(fmt, sizeof(fmt), occ);
246 switch(occ->conversion) {
248 /* Store the number of written characters in the given
249 * int pointer location */
252 int *num = val->v_ptr;
257 /* strings are dumped directly, since they can get really big. A
258 * buffer of 128 letters for all other types should be enough. */
261 const char *str = val->v_ptr;
262 res = lc_arg_append(app, occ, str, strlen(str));
268 int len = LC_MAX(128, occ->width + 1);
269 char *buf = malloc(len * sizeof(char));
270 res = dispatch_snprintf(buf, len, fmt, occ->lc_arg_type, val);
271 res = lc_appendable_snadd(app, buf, res);
279 static const lc_arg_handler_t std_handler = {
284 lc_arg_env_t *lc_arg_add_std(lc_arg_env_t *env)
286 lc_arg_register(env, "std:c", 'c', &std_handler);
287 lc_arg_register(env, "std:i", 'i', &std_handler);
288 lc_arg_register(env, "std:d", 'd', &std_handler);
289 lc_arg_register(env, "std:o", 'o', &std_handler);
290 lc_arg_register(env, "std:u", 'u', &std_handler);
291 lc_arg_register(env, "std:x", 'x', &std_handler);
292 lc_arg_register(env, "std:X", 'X', &std_handler);
294 lc_arg_register(env, "std:e", 'e', &std_handler);
295 lc_arg_register(env, "std:E", 'E', &std_handler);
296 lc_arg_register(env, "std:f", 'f', &std_handler);
297 lc_arg_register(env, "std:F", 'F', &std_handler);
298 lc_arg_register(env, "std:g", 'g', &std_handler);
299 lc_arg_register(env, "std:G", 'G', &std_handler);
301 lc_arg_register(env, "std:s", 's', &std_handler);
302 lc_arg_register(env, "std:p", 'p', &std_handler);
303 lc_arg_register(env, "std:n", 'n', &std_handler);
308 static char *read_int(const char *s, int *value)
311 int res = (int) strtol(s, &endptr, 10);
312 *value = endptr == s ? -1 : res;
316 /* Generic printf() function. */
318 int lc_evpprintf(const lc_arg_env_t *env, lc_appendable_t *app, const char *fmt, va_list args)
322 const char *last = fmt + strlen(fmt);
324 /* Find the fisrt % */
325 s = strchr(fmt, '%');
327 /* Emit the text before the first % was found */
328 lc_appendable_snadd(app, fmt, (s ? s : last) - fmt);
333 const lc_arg_t *arg = NULL;
337 /* We must be at a '%' */
340 /* Reset the occurrence structure */
341 memset(&occ, 0, sizeof(occ));
343 /* Eat all flags and set the corresponding flags in the occ struct */
344 for(++s; strchr("#0-+", *s); ++s) {
364 /* Read the width if given */
365 s = read_int(s, &occ.width);
369 /* read the precision if given */
372 s = read_int(s + 1, &val);
374 /* Negative or lacking precision after a '.' is treated as
376 occ.precision = LC_MAX(0, val);
380 * Now, we can either have:
381 * - a named argument like {node}
382 * - some modifiers followed by a conversion specifier
383 * - or some other character, which ends this format invalidly
389 res += lc_appendable_chadd(app, '%');
393 const char *named = ++s;
395 /* Read until the closing brace or end of the string. */
396 for(ch = *s; ch != '}' && ch != '\0'; ch = *++s);
403 name = malloc(sizeof(char) * (n + 1));
404 memcpy(name, named, sizeof(char) * n);
408 arg = set_find(env->args, &tmp, sizeof(tmp), HASH_STR(named, n));
410 occ.modifier_length = 0;
412 /* Set the conversion specifier of the occurrence to the
413 * letter specified in the argument description. */
415 occ.conversion = arg->letter;
419 /* If we ended with a closing brace, move the current
420 * pointer after it, since it is not to be dumped. */
431 /* Read, as long there are letters */
432 while(isalpha(ch) && !arg) {
434 lc_arg_t * const *map = env->lower;
436 /* If uppercase, select the uppercase map from the environment */
442 if(map[ch - base] != NULL) {
444 occ.modifier_length = s - mod;
446 arg = map[ch - base];
454 /* Call the handler if an argument was determined */
455 if(arg != NULL && arg->handler != NULL) {
456 const lc_arg_handler_t *handler = arg->handler;
458 /* Let the handler determine the type of the argument based on the
459 * information gathered. */
460 occ.lc_arg_type = handler->get_lc_arg_type(&occ);
462 /* Store the value according to argument information */
463 switch(occ.lc_arg_type) {
464 #define LC_ARG_TYPE(type,name) case lc_arg_type_ ## name: val.v_ ## name = va_arg(args, type); break;
465 #include "lc_printf_arg_types.def"
469 /* Finally, call the handler. */
470 res += handler->emit(app, &occ, &val);
475 res += lc_appendable_snadd(app, old, (s ? s : last) - old);
481 /* Convenience implementations */
483 int lc_epprintf(const lc_arg_env_t *env, lc_appendable_t *app, const char *fmt, ...)
488 res = lc_evpprintf(env, app, fmt, args);
493 int lc_pprintf(lc_appendable_t *app, const char *fmt, ...)
498 res = lc_vpprintf(app, fmt, args);
503 int lc_vpprintf(lc_appendable_t *app, const char *fmt, va_list args)
505 return lc_evpprintf(_lc_arg_get_default_env(), app, fmt, args);
508 int lc_eprintf(const lc_arg_env_t *env, const char *fmt, ...)
513 res = lc_efprintf(env, stdout, fmt, args);
518 int lc_esnprintf(const lc_arg_env_t *env, char *buf, size_t len, const char *fmt, ...)
523 res = lc_evsnprintf(env, buf, len, fmt, args);
528 int lc_efprintf(const lc_arg_env_t *env, FILE *file, const char *fmt, ...)
533 res = lc_evfprintf(env, file, fmt, args);
538 int lc_eoprintf(const lc_arg_env_t *env, struct obstack *obst, const char *fmt, ...)
543 res = lc_evoprintf(env, obst, fmt, args);
548 int lc_evprintf(const lc_arg_env_t *env, const char *fmt, va_list args)
550 return lc_evfprintf(env, stdout, fmt, args);
553 int lc_evsnprintf(const lc_arg_env_t *env, char *buf, size_t len, const char *fmt, va_list args)
558 lc_appendable_init(&app, lc_appendable_string, buf, len);
559 res = lc_evpprintf(env, &app, fmt, args);
560 lc_appendable_finish(&app);
564 int lc_evfprintf(const lc_arg_env_t *env, FILE *f, const char *fmt, va_list args)
569 lc_appendable_init(&app, lc_appendable_file, f, 0);
570 res = lc_evpprintf(env, &app, fmt, args);
571 lc_appendable_finish(&app);
575 int lc_evoprintf(const lc_arg_env_t *env, struct obstack *obst, const char *fmt, va_list args)
580 lc_appendable_init(&app, lc_appendable_obstack, obst, 0);
581 res = lc_evpprintf(env, &app, fmt, args);
582 lc_appendable_finish(&app);
587 int lc_printf(const char *fmt, ...)
592 res = lc_vprintf(fmt, args);
597 int lc_snprintf(char *buf, size_t len, const char *fmt, ...)
602 res = lc_vsnprintf(buf, len, fmt, args);
607 int lc_fprintf(FILE *f, const char *fmt, ...)
612 res = lc_vfprintf(f, fmt, args);
617 int lc_oprintf(struct obstack *obst, const char *fmt, ...)
622 res = lc_voprintf(obst, fmt, args);
628 int lc_vprintf(const char *fmt, va_list args)
630 return lc_evprintf(_lc_arg_get_default_env(), fmt, args);
633 int lc_vsnprintf(char *buf, size_t len, const char *fmt, va_list args)
635 return lc_evsnprintf(_lc_arg_get_default_env(), buf, len, fmt, args);
638 int lc_vfprintf(FILE *f, const char *fmt, va_list args)
640 return lc_evfprintf(_lc_arg_get_default_env(), f, fmt, args);
643 int lc_voprintf(struct obstack *obst, const char *fmt, va_list args)
645 return lc_evoprintf(_lc_arg_get_default_env(), obst, fmt, args);