nsz Git - libfirm/blob - ir/libcore/lc_printf.c

   1 /*
   2   libcore: library for basic data structures and algorithms.
   3   Copyright (C) 2005  IPD Goos, Universit"at Karlsruhe, Germany
   4
   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.
   9
  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.
  14
  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
  18 */
  19
  20
  21 /**
  22  * A customizable printf clone.
  23  * @author Sebastian Hack
  24  * @date 4.12.2005
  25  */
  26 #include "config.h"
  27
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <stddef.h>
  31 #include <stdarg.h>
  32 #include <string.h>
  33 #include <assert.h>
  34 #include <ctype.h>
  35
  36 #include "lc_common_t.h"
  37 #include "xmalloc.h"
  38 #include "lc_printf.h"
  39 #include "lc_defines.h"
  40 #include "hashptr.h"
  41 #include "set.h"
  42
  43 /* printf implementation */
  44
  45 typedef struct lc_arg_t {
  46         struct lc_arg_t *next;
  47         const char *name;
  48         char letter;
  49         int lc_arg_type;
  50         const lc_arg_handler_t *handler;
  51 } lc_arg_t;
  52
  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. */
  57 };
  58
  59 /** The default argument environment. */
  60 static lc_arg_env_t *default_env = NULL;
  61
  62 static inline lc_arg_env_t *_lc_arg_get_default_env(void)
  63 {
  64         if (!default_env)
  65                 default_env = lc_arg_add_std(lc_arg_new_env());
  66
  67         return default_env;
  68 }
  69
  70 lc_arg_env_t *lc_arg_get_default_env(void)
  71 {
  72         return _lc_arg_get_default_env();
  73 }
  74
  75 static int lc_arg_cmp(const void *p1, const void *p2, UNUSED(size_t size))
  76 {
  77         const lc_arg_t *a1 = p1;
  78         const lc_arg_t *a2 = p2;
  79         return strcmp(a1->name, a2->name);
  80 }
  81
  82
  83 lc_arg_env_t *lc_arg_new_env(void)
  84 {
  85         lc_arg_env_t *env = XMALLOCZ(lc_arg_env_t);
  86         env->args = new_set(lc_arg_cmp, 16);
  87         return env;
  88 }
  89
  90 void lc_arg_free_env(lc_arg_env_t *env)
  91 {
  92         del_set(env->args);
  93         free(env);
  94 }
  95
  96 int lc_arg_register(lc_arg_env_t *env, const char *name, char letter, const lc_arg_handler_t *handler)
  97 {
  98         lc_arg_t arg;
  99         lc_arg_t *ent;
 100         int base = 0;
 101         lc_arg_t **map = NULL;
 102
 103         arg.name = name;
 104         arg.letter = letter;
 105         arg.handler = handler;
 106
 107         if (isupper(letter)) {
 108                 map = env->upper;
 109                 base = 'A';
 110         }
 111         else if (islower(letter)) {
 112                 map = env->lower;
 113                 base = 'a';
 114         }
 115
 116         ent = set_insert(env->args, &arg, sizeof(arg), HASH_STR(name, strlen(name)));
 117
 118         if (ent && base != 0)
 119                 map[letter - base] = ent;
 120
 121         return ent != NULL;
 122 }
 123
 124 void lc_arg_unregister(UNUSED(lc_arg_env_t *env), UNUSED(const char *name))
 125 {
 126 }
 127
 128 int lc_arg_append(lc_appendable_t *app, const lc_arg_occ_t *occ, const char *str, size_t len)
 129 {
 130         char pad = ' ';
 131
 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)
 135                 pad = '0';
 136
 137         return lc_appendable_snwadd(app, str, len, LC_MAX(0, occ->width), occ->flag_minus, pad);
 138 }
 139
 140
 141 static int dispatch_snprintf(char *buf, size_t len, const char *fmt,
 142                 int lc_arg_type, const lc_arg_value_t *val)
 143 {
 144         int res = 0;
 145
 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"
 150 #undef LC_ARG_TYPE
 151         }
 152
 153         return res;
 154 }
 155
 156 static char *make_fmt(char *buf, size_t len, const lc_arg_occ_t *occ)
 157 {
 158         char mod[64];
 159         char prec[16];
 160         char width[16];
 161
 162         prec[0] = '\0';
 163         width[0] = '\0';
 164
 165         if (occ->precision > 0)
 166                 snprintf(prec, sizeof(prec), ".%d", occ->precision);
 167
 168         if (occ->width > 0)
 169                 snprintf(width, sizeof(width), "%d", occ->width);
 170
 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';
 174
 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" : "",
 181                         width, prec,
 182                         mod, occ->conversion);
 183
 184         return buf;
 185 }
 186
 187 /**
 188  * Standard argument handler.
 189  */
 190 static int std_get_lc_arg_type(const lc_arg_occ_t *occ)
 191 {
 192         int modlen = occ->modifier_length;
 193
 194         /* check, if the type can be derived from the modifier */
 195         if (modlen > 0) {
 196                 const char *mod = occ->modifier;
 197                 switch (mod[0]) {
 198                         case 'l':
 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;
 201 #if 0
 202                         TYPE_CASE('j', intmax_t);
 203                         TYPE_CASE('z', size_t);
 204                         TYPE_CASE('t', ptrdiff_t);
 205 #endif
 206                         TYPE_CASE('L', long_double);
 207 #undef TYPE_CASE
 208                 }
 209         }
 210
 211         /* The type is given by the conversion specifier and cannot be
 212          * determined from the modifier. */
 213         switch (occ->conversion) {
 214                 case 'e':
 215                 case 'E':
 216                 case 'f':
 217                 case 'F':
 218                 case 'g':
 219                 case 'G':
 220                         return lc_arg_type_double;
 221                 case 's':
 222                 case 'n':
 223                 case 'p':
 224                         return lc_arg_type_ptr;
 225                 default:
 226                         return lc_arg_type_int;
 227         }
 228 }
 229
 230 static int std_emit(lc_appendable_t *app, const lc_arg_occ_t *occ, const lc_arg_value_t *val)
 231 {
 232         char fmt[32];
 233         int res = 0;
 234
 235         make_fmt(fmt, sizeof(fmt), occ);
 236
 237         switch (occ->conversion) {
 238
 239                 /* Store the number of written characters in the given
 240                  * int pointer location */
 241                 case 'n':
 242                         {
 243                                 int *num = val->v_ptr;
 244                                 *num = app->written;
 245                         }
 246                         break;
 247
 248                 /* strings are dumped directly, since they can get really big. A
 249                  * buffer of 128 letters for all other types should be enough. */
 250                 case 's':
 251                         {
 252                                 const char *str = val->v_ptr;
 253                                 res = lc_arg_append(app, occ, str, strlen(str));
 254                         }
 255                         break;
 256
 257                 default:
 258                         {
 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);
 263                                 xfree(buf);
 264                         }
 265         }
 266
 267         return res;
 268 }
 269
 270 static const lc_arg_handler_t std_handler = {
 271         std_get_lc_arg_type,
 272         std_emit
 273 };
 274
 275 lc_arg_env_t *lc_arg_add_std(lc_arg_env_t *env)
 276 {
 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);
 284
 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);
 291
 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);
 295
 296         return env;
 297 }
 298
 299 static char *read_int(const char *s, int *value)
 300 {
 301         char *endptr;
 302         int res = (int) strtol(s, &endptr, 10);
 303         *value = endptr == s ? -1 : res;
 304         return endptr;
 305 }
 306
 307 /* Generic printf() function. */
 308
 309 int lc_evpprintf(const lc_arg_env_t *env, lc_appendable_t *app, const char *fmt, va_list args)
 310 {
 311         int res = 0;
 312         const char *s;
 313         const char *last = fmt + strlen(fmt);
 314
 315         /* Find the first % */
 316         s = strchr(fmt, '%');
 317
 318         /* Emit the text before the first % was found */
 319         lc_appendable_snadd(app, fmt, (s ? s : last) - fmt);
 320
 321         while (s != NULL) {
 322                 lc_arg_occ_t occ;
 323                 lc_arg_value_t val;
 324                 const lc_arg_t *arg = NULL;
 325                 const char *old;
 326                 char ch;
 327
 328                 /* We must be at a '%' */
 329                 assert(*s == '%');
 330
 331                 /* Reset the occurrence structure */
 332                 memset(&occ, 0, sizeof(occ));
 333
 334                 /* Eat all flags and set the corresponding flags in the occ struct */
 335                 for (++s; strchr("#0-+", *s); ++s) {
 336                         switch (*s) {
 337                                 case '#':
 338                                         occ.flag_hash = 1;
 339                                         break;
 340                                 case '0':
 341                                         occ.flag_zero = 1;
 342                                         break;
 343                                 case '-':
 344                                         occ.flag_minus = 1;
 345                                         break;
 346                                 case '+':
 347                                         occ.flag_plus = 1;
 348                                         break;
 349                                 case ' ':
 350                                         occ.flag_space = 1;
 351                                         break;
 352                         }
 353                 }
 354
 355                 /* Read the width if given */
 356                 s = read_int(s, &occ.width);
 357
 358                 occ.precision = -1;
 359
 360                 /* read the precision if given */
 361                 if (*s == '.') {
 362                         int val;
 363                         s = read_int(s + 1, &val);
 364
 365                         /* Negative or lacking precision after a '.' is treated as
 366                          * precision 0. */
 367                         occ.precision = LC_MAX(0, val);
 368                 }
 369
 370                 /*
 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
 375                  */
 376                 ch = *s;
 377                 switch (ch) {
 378                         case '%':
 379                                 s++;
 380                                 res += lc_appendable_chadd(app, '%');
 381                                 break;
 382                         case '{':
 383                                 {
 384                                         const char *named = ++s;
 385
 386                                         /* Read until the closing brace or end of the string. */
 387                                         for (ch = *s; ch != '}' && ch != '\0'; ch = *++s);
 388
 389                                         if (s - named) {
 390                                                 int n = s - named;
 391                                                 char *name;
 392                                                 lc_arg_t tmp;
 393
 394                                                 name = malloc(sizeof(char) * (n + 1));
 395                                                 memcpy(name, named, sizeof(char) * n);
 396                                                 name[n] = '\0';
 397                                                 tmp.name = name;
 398
 399                                                 arg = set_find(env->args, &tmp, sizeof(tmp), HASH_STR(named, n));
 400                                                 occ.modifier = "";
 401                                                 occ.modifier_length = 0;
 402
 403                                                 /* Set the conversion specifier of the occurrence to the
 404                                                  * letter specified in the argument description. */
 405                                                 if (arg)
 406                                                         occ.conversion = arg->letter;
 407
 408                                                 free(name);
 409
 410                                                 /* If we ended with a closing brace, move the current
 411                                                  * pointer after it, since it is not to be dumped. */
 412                                                 if (ch == '}')
 413                                                         s++;
 414                                         }
 415                                 }
 416                                 break;
 417
 418                         default:
 419                                 {
 420                                         const char *mod = s;
 421
 422                                         /* Read, as long there are letters */
 423                                         while (isalpha(ch) && !arg) {
 424                                                 int base = 'a';
 425                                                 lc_arg_t * const *map = env->lower;
 426
 427                                                 /* If uppercase, select the uppercase map from the environment */
 428                                                 if (isupper(ch)) {
 429                                                         base = 'A';
 430                                                         map = env->upper;
 431                                                 }
 432
 433                                                 if (map[ch - base] != NULL) {
 434                                                         occ.modifier = mod;
 435                                                         occ.modifier_length = s - mod;
 436                                                         occ.conversion = ch;
 437                                                         arg = map[ch - base];
 438                                                 }
 439
 440                                                 ch = *++s;
 441                                         }
 442                                 }
 443                 }
 444
 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;
 448
 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);
 452
 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"
 457 #undef LC_ARG_TYPE
 458                         }
 459
 460                         /* Finally, call the handler. */
 461                         res += handler->emit(app, &occ, &val);
 462                 }
 463
 464                 old = s;
 465                 s = strchr(s, '%');
 466                 res += lc_appendable_snadd(app, old, (s ? s : last) - old);
 467         }
 468
 469         return res;
 470 }
 471
 472 /* Convenience implementations */
 473
 474 int lc_epprintf(const lc_arg_env_t *env, lc_appendable_t *app, const char *fmt, ...)
 475 {
 476         int res;
 477         va_list args;
 478         va_start(args, fmt);
 479         res = lc_evpprintf(env, app, fmt, args);
 480         va_end(args);
 481         return res;
 482 }
 483
 484 int lc_pprintf(lc_appendable_t *app, const char *fmt, ...)
 485 {
 486         int res;
 487         va_list args;
 488         va_start(args, fmt);
 489         res = lc_vpprintf(app, fmt, args);
 490         va_end(args);
 491         return res;
 492 }
 493
 494 int lc_vpprintf(lc_appendable_t *app, const char *fmt, va_list args)
 495 {
 496         return lc_evpprintf(_lc_arg_get_default_env(), app, fmt, args);
 497 }
 498
 499 int lc_eprintf(const lc_arg_env_t *env, const char *fmt, ...)
 500 {
 501         int res;
 502         va_list args;
 503         va_start(args, fmt);
 504         res = lc_efprintf(env, stdout, fmt, args);
 505         va_end(args);
 506         return res;
 507 }
 508
 509 int lc_esnprintf(const lc_arg_env_t *env, char *buf, size_t len, const char *fmt, ...)
 510 {
 511         int res;
 512         va_list args;
 513         va_start(args, fmt);
 514         res = lc_evsnprintf(env, buf, len, fmt, args);
 515         va_end(args);
 516         return res;
 517 }
 518
 519 int lc_efprintf(const lc_arg_env_t *env, FILE *file, const char *fmt, ...)
 520 {
 521         int res;
 522         va_list args;
 523         va_start(args, fmt);
 524         res = lc_evfprintf(env, file, fmt, args);
 525         va_end(args);
 526         return res;
 527 }
 528
 529 int lc_eoprintf(const lc_arg_env_t *env, struct obstack *obst, const char *fmt, ...)
 530 {
 531         int res;
 532         va_list args;
 533         va_start(args, fmt);
 534         res = lc_evoprintf(env, obst, fmt, args);
 535         va_end(args);
 536         return res;
 537 }
 538
 539 int lc_evprintf(const lc_arg_env_t *env, const char *fmt, va_list args)
 540 {
 541         return lc_evfprintf(env, stdout, fmt, args);
 542 }
 543
 544 int lc_evsnprintf(const lc_arg_env_t *env, char *buf, size_t len, const char *fmt, va_list args)
 545 {
 546         int res;
 547         lc_appendable_t app;
 548
 549         lc_appendable_init(&app, lc_appendable_string, buf, len);
 550         res = lc_evpprintf(env, &app, fmt, args);
 551         lc_appendable_finish(&app);
 552         return res;
 553 }
 554
 555 int lc_evfprintf(const lc_arg_env_t *env, FILE *f, const char *fmt, va_list args)
 556 {
 557         int res;
 558         lc_appendable_t app;
 559
 560         lc_appendable_init(&app, lc_appendable_file, f, 0);
 561         res = lc_evpprintf(env, &app, fmt, args);
 562         lc_appendable_finish(&app);
 563         return res;
 564 }
 565
 566 int lc_evoprintf(const lc_arg_env_t *env, struct obstack *obst, const char *fmt, va_list args)
 567 {
 568         int res;
 569         lc_appendable_t app;
 570
 571         lc_appendable_init(&app, lc_appendable_obstack, obst, 0);
 572         res = lc_evpprintf(env, &app, fmt, args);
 573         lc_appendable_finish(&app);
 574         return res;
 575 }
 576
 577
 578 int lc_printf(const char *fmt, ...)
 579 {
 580         int res;
 581         va_list args;
 582         va_start(args, fmt);
 583         res = lc_vprintf(fmt, args);
 584         va_end(args);
 585         return res;
 586 }
 587
 588 int lc_snprintf(char *buf, size_t len, const char *fmt, ...)
 589 {
 590         int res;
 591         va_list args;
 592         va_start(args, fmt);
 593         res = lc_vsnprintf(buf, len, fmt, args);
 594         va_end(args);
 595         return res;
 596 }
 597
 598 int lc_fprintf(FILE *f, const char *fmt, ...)
 599 {
 600         int res;
 601         va_list args;
 602         va_start(args, fmt);
 603         res = lc_vfprintf(f, fmt, args);
 604         va_end(args);
 605         return res;
 606 }
 607
 608 int lc_oprintf(struct obstack *obst, const char *fmt, ...)
 609 {
 610         int res;
 611         va_list args;
 612         va_start(args, fmt);
 613         res = lc_voprintf(obst, fmt, args);
 614         va_end(args);
 615         return res;
 616 }
 617
 618
 619 int lc_vprintf(const char *fmt, va_list args)
 620 {
 621         return lc_evprintf(_lc_arg_get_default_env(), fmt, args);
 622 }
 623
 624 int lc_vsnprintf(char *buf, size_t len, const char *fmt, va_list args)
 625 {
 626         return lc_evsnprintf(_lc_arg_get_default_env(), buf, len, fmt, args);
 627 }
 628
 629 int lc_vfprintf(FILE *f, const char *fmt, va_list args)
 630 {
 631         return lc_evfprintf(_lc_arg_get_default_env(), f, fmt, args);
 632 }
 633
 634 int lc_voprintf(struct obstack *obst, const char *fmt, va_list args)
 635 {
 636         return lc_evoprintf(_lc_arg_get_default_env(), obst, fmt, args);
 637 }