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 = (const lc_arg_t*)p1;
  78         const lc_arg_t *a2 = (const lc_arg_t*)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 = (lc_arg_t*)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 #ifdef _MSC_VER
 176         /* work-around for buggy mscrt not supporting z, j,  and t modifier */
 177         if (occ->modifier_length == 1) {
 178                 if (mod[0] == 'z') {
 179                         if (sizeof(size_t) == sizeof(int))
 180                                 mod[0] = '\0';
 181                         if (sizeof(size_t) == sizeof(__int64)) {
 182                                 mod[0] = 'I';
 183                                 mod[1] = '6';
 184                                 mod[2] = '4';
 185                                 mod[3] = '\0';
 186                         }
 187                 } else if (mod[0] == 't') {
 188                         if (sizeof(ptrdiff_t) == sizeof(int))
 189                                 mod[0] = '\0';
 190                         if (sizeof(ptrdiff_t) == sizeof(__int64)) {
 191                                 mod[0] = 'I';
 192                                 mod[1] = '6';
 193                                 mod[2] = '4';
 194                                 mod[3] = '\0';
 195                         }
 196                 } else if (mod[0] == 'j') {
 197                         if (sizeof(intmax_t) == sizeof(int))
 198                                 mod[0] = '\0';
 199                         if (sizeof(intmax_t) == sizeof(__int64)) {
 200                                 mod[0] = 'I';
 201                                 mod[1] = '6';
 202                                 mod[2] = '4';
 203                                 mod[3] = '\0';
 204                         }
 205                 }
 206         }
 207 #endif
 208         snprintf(buf, len, "%%%s%s%s%s%s%s%s%s%c",
 209                         occ->flag_space ? "#" : "",
 210                         occ->flag_hash ? "#" : "",
 211                         occ->flag_plus ? "+" : "",
 212                         occ->flag_minus ? "-" : "",
 213                         occ->flag_zero ? "0" : "",
 214                         width, prec,
 215                         mod, occ->conversion);
 216
 217         return buf;
 218 }
 219
 220 /**
 221  * Standard argument handler.
 222  */
 223 static int std_get_lc_arg_type(const lc_arg_occ_t *occ)
 224 {
 225         int modlen = occ->modifier_length;
 226
 227         /* check, if the type can be derived from the modifier */
 228         if (modlen > 0) {
 229                 const char *mod = occ->modifier;
 230                 switch (mod[0]) {
 231                         case 'l':
 232                                 return modlen > 1 && mod[1] == 'l' ? lc_arg_type_long_long : lc_arg_type_long;
 233 #define TYPE_CASE(letter,type) case letter: return lc_arg_type_ ## type;
 234                         TYPE_CASE('j', intmax_t);
 235                         TYPE_CASE('z', size_t);
 236                         TYPE_CASE('t', ptrdiff_t);
 237                         TYPE_CASE('L', long_double);
 238 #undef TYPE_CASE
 239                 }
 240         }
 241
 242         /* The type is given by the conversion specifier and cannot be
 243          * determined from the modifier. */
 244         switch (occ->conversion) {
 245                 case 'e':
 246                 case 'E':
 247                 case 'f':
 248                 case 'F':
 249                 case 'g':
 250                 case 'G':
 251                         return lc_arg_type_double;
 252                 case 's':
 253                 case 'n':
 254                 case 'p':
 255                         return lc_arg_type_ptr;
 256                 default:
 257                         return lc_arg_type_int;
 258         }
 259 }
 260
 261 static int std_emit(lc_appendable_t *app, const lc_arg_occ_t *occ, const lc_arg_value_t *val)
 262 {
 263         char fmt[32];
 264         int res = 0;
 265
 266         make_fmt(fmt, sizeof(fmt), occ);
 267
 268         switch (occ->conversion) {
 269
 270                 /* Store the number of written characters in the given
 271                  * int pointer location */
 272                 case 'n':
 273                         {
 274                                 int *num = (int*)val->v_ptr;
 275                                 *num = app->written;
 276                         }
 277                         break;
 278
 279                 /* strings are dumped directly, since they can get really big. A
 280                  * buffer of 128 letters for all other types should be enough. */
 281                 case 's':
 282                         {
 283                                 const char *str = (const char*)val->v_ptr;
 284                                 res = lc_arg_append(app, occ, str, strlen(str));
 285                         }
 286                         break;
 287
 288                 default:
 289                         {
 290                                 int len = LC_MAX(128, occ->width + 1);
 291                                 char *buf = XMALLOCN(char, len);
 292                                 res = dispatch_snprintf(buf, len, fmt, occ->lc_arg_type, val);
 293                                 res = lc_appendable_snadd(app, buf, res);
 294                                 xfree(buf);
 295                         }
 296         }
 297
 298         return res;
 299 }
 300
 301 static const lc_arg_handler_t std_handler = {
 302         std_get_lc_arg_type,
 303         std_emit
 304 };
 305
 306 lc_arg_env_t *lc_arg_add_std(lc_arg_env_t *env)
 307 {
 308         lc_arg_register(env, "std:c", 'c', &std_handler);
 309         lc_arg_register(env, "std:i", 'i', &std_handler);
 310         lc_arg_register(env, "std:d", 'd', &std_handler);
 311         lc_arg_register(env, "std:o", 'o', &std_handler);
 312         lc_arg_register(env, "std:u", 'u', &std_handler);
 313         lc_arg_register(env, "std:x", 'x', &std_handler);
 314         lc_arg_register(env, "std:X", 'X', &std_handler);
 315
 316         lc_arg_register(env, "std:e", 'e', &std_handler);
 317         lc_arg_register(env, "std:E", 'E', &std_handler);
 318         lc_arg_register(env, "std:f", 'f', &std_handler);
 319         lc_arg_register(env, "std:F", 'F', &std_handler);
 320         lc_arg_register(env, "std:g", 'g', &std_handler);
 321         lc_arg_register(env, "std:G", 'G', &std_handler);
 322
 323         lc_arg_register(env, "std:s", 's', &std_handler);
 324         lc_arg_register(env, "std:p", 'p', &std_handler);
 325         lc_arg_register(env, "std:n", 'n', &std_handler);
 326
 327         return env;
 328 }
 329
 330 static char *read_int(const char *s, int *value)
 331 {
 332         char *endptr;
 333         int res = (int) strtol(s, &endptr, 10);
 334         *value = endptr == s ? -1 : res;
 335         return endptr;
 336 }
 337
 338 /* Generic printf() function. */
 339
 340 int lc_evpprintf(const lc_arg_env_t *env, lc_appendable_t *app, const char *fmt, va_list args)
 341 {
 342         int res = 0;
 343         const char *s;
 344         const char *last = fmt + strlen(fmt);
 345
 346         /* Find the first % */
 347         s = strchr(fmt, '%');
 348
 349         /* Emit the text before the first % was found */
 350         lc_appendable_snadd(app, fmt, (s ? s : last) - fmt);
 351
 352         while (s != NULL) {
 353                 lc_arg_occ_t occ;
 354                 lc_arg_value_t val;
 355                 const lc_arg_t *arg = NULL;
 356                 const char *old;
 357                 char ch;
 358
 359                 /* We must be at a '%' */
 360                 assert(*s == '%');
 361
 362                 /* Reset the occurrence structure */
 363                 memset(&occ, 0, sizeof(occ));
 364
 365                 /* Eat all flags and set the corresponding flags in the occ struct */
 366                 for (++s; strchr("#0-+", *s); ++s) {
 367                         switch (*s) {
 368                                 case '#':
 369                                         occ.flag_hash = 1;
 370                                         break;
 371                                 case '0':
 372                                         occ.flag_zero = 1;
 373                                         break;
 374                                 case '-':
 375                                         occ.flag_minus = 1;
 376                                         break;
 377                                 case '+':
 378                                         occ.flag_plus = 1;
 379                                         break;
 380                                 case ' ':
 381                                         occ.flag_space = 1;
 382                                         break;
 383                         }
 384                 }
 385
 386                 /* Read the width if given */
 387                 s = read_int(s, &occ.width);
 388
 389                 occ.precision = -1;
 390
 391                 /* read the precision if given */
 392                 if (*s == '.') {
 393                         int val;
 394                         s = read_int(s + 1, &val);
 395
 396                         /* Negative or lacking precision after a '.' is treated as
 397                          * precision 0. */
 398                         occ.precision = LC_MAX(0, val);
 399                 }
 400
 401                 /*
 402                  * Now, we can either have:
 403                  * - a named argument like {node}
 404                  * - some modifiers followed by a conversion specifier
 405                  * - or some other character, which ends this format invalidly
 406                  */
 407                 ch = *s;
 408                 switch (ch) {
 409                         case '%':
 410                                 s++;
 411                                 res += lc_appendable_chadd(app, '%');
 412                                 break;
 413                         case '{':
 414                                 {
 415                                         const char *named = ++s;
 416
 417                                         /* Read until the closing brace or end of the string. */
 418                                         for (ch = *s; ch != '}' && ch != '\0'; ch = *++s);
 419
 420                                         if (s - named) {
 421                                                 size_t n = s - named;
 422                                                 char *name;
 423                                                 lc_arg_t tmp;
 424
 425                                                 name = (char*) malloc(sizeof(char) * (n + 1));
 426                                                 memcpy(name, named, sizeof(char) * n);
 427                                                 name[n] = '\0';
 428                                                 tmp.name = name;
 429
 430                                                 arg = (lc_arg_t*)set_find(env->args, &tmp, sizeof(tmp), HASH_STR(named, n));
 431                                                 occ.modifier = "";
 432                                                 occ.modifier_length = 0;
 433
 434                                                 /* Set the conversion specifier of the occurrence to the
 435                                                  * letter specified in the argument description. */
 436                                                 if (arg)
 437                                                         occ.conversion = arg->letter;
 438
 439                                                 free(name);
 440
 441                                                 /* If we ended with a closing brace, move the current
 442                                                  * pointer after it, since it is not to be dumped. */
 443                                                 if (ch == '}')
 444                                                         s++;
 445                                         }
 446                                 }
 447                                 break;
 448
 449                         default:
 450                                 {
 451                                         const char *mod = s;
 452
 453                                         /* Read, as long there are letters */
 454                                         while (isalpha(ch) && !arg) {
 455                                                 int base = 'a';
 456                                                 lc_arg_t * const *map = env->lower;
 457
 458                                                 /* If uppercase, select the uppercase map from the environment */
 459                                                 if (isupper(ch)) {
 460                                                         base = 'A';
 461                                                         map = env->upper;
 462                                                 }
 463
 464                                                 if (map[ch - base] != NULL) {
 465                                                         occ.modifier = mod;
 466                                                         occ.modifier_length = s - mod;
 467                                                         occ.conversion = ch;
 468                                                         arg = map[ch - base];
 469                                                 }
 470
 471                                                 ch = *++s;
 472                                         }
 473                                 }
 474                 }
 475
 476                 /* Call the handler if an argument was determined */
 477                 if (arg != NULL && arg->handler != NULL) {
 478                         const lc_arg_handler_t *handler = arg->handler;
 479
 480                         /* Let the handler determine the type of the argument based on the
 481                          * information gathered. */
 482                         occ.lc_arg_type = handler->get_lc_arg_type(&occ);
 483
 484                         /* Store the value according to argument information */
 485                         switch (occ.lc_arg_type) {
 486 #define LC_ARG_TYPE(type,name) case lc_arg_type_ ## name: val.v_ ## name = va_arg(args, type); break;
 487 #include "lc_printf_arg_types.def"
 488 #undef LC_ARG_TYPE
 489                         }
 490
 491                         /* Finally, call the handler. */
 492                         res += handler->emit(app, &occ, &val);
 493                 }
 494
 495                 old = s;
 496                 s = strchr(s, '%');
 497                 res += lc_appendable_snadd(app, old, (s ? s : last) - old);
 498         }
 499
 500         return res;
 501 }
 502
 503 /* Convenience implementations */
 504
 505 int lc_epprintf(const lc_arg_env_t *env, lc_appendable_t *app, const char *fmt, ...)
 506 {
 507         int res;
 508         va_list args;
 509         va_start(args, fmt);
 510         res = lc_evpprintf(env, app, fmt, args);
 511         va_end(args);
 512         return res;
 513 }
 514
 515 int lc_pprintf(lc_appendable_t *app, const char *fmt, ...)
 516 {
 517         int res;
 518         va_list args;
 519         va_start(args, fmt);
 520         res = lc_vpprintf(app, fmt, args);
 521         va_end(args);
 522         return res;
 523 }
 524
 525 int lc_vpprintf(lc_appendable_t *app, const char *fmt, va_list args)
 526 {
 527         return lc_evpprintf(_lc_arg_get_default_env(), app, fmt, args);
 528 }
 529
 530 int lc_eprintf(const lc_arg_env_t *env, const char *fmt, ...)
 531 {
 532         int res;
 533         va_list args;
 534         va_start(args, fmt);
 535         res = lc_efprintf(env, stdout, fmt, args);
 536         va_end(args);
 537         return res;
 538 }
 539
 540 int lc_esnprintf(const lc_arg_env_t *env, char *buf, size_t len, const char *fmt, ...)
 541 {
 542         int res;
 543         va_list args;
 544         va_start(args, fmt);
 545         res = lc_evsnprintf(env, buf, len, fmt, args);
 546         va_end(args);
 547         return res;
 548 }
 549
 550 int lc_efprintf(const lc_arg_env_t *env, FILE *file, const char *fmt, ...)
 551 {
 552         int res;
 553         va_list args;
 554         va_start(args, fmt);
 555         res = lc_evfprintf(env, file, fmt, args);
 556         va_end(args);
 557         return res;
 558 }
 559
 560 int lc_eoprintf(const lc_arg_env_t *env, struct obstack *obst, const char *fmt, ...)
 561 {
 562         int res;
 563         va_list args;
 564         va_start(args, fmt);
 565         res = lc_evoprintf(env, obst, fmt, args);
 566         va_end(args);
 567         return res;
 568 }
 569
 570 int lc_evprintf(const lc_arg_env_t *env, const char *fmt, va_list args)
 571 {
 572         return lc_evfprintf(env, stdout, fmt, args);
 573 }
 574
 575 int lc_evsnprintf(const lc_arg_env_t *env, char *buf, size_t len, const char *fmt, va_list args)
 576 {
 577         int res;
 578         lc_appendable_t app;
 579
 580         lc_appendable_init(&app, lc_appendable_string, buf, len);
 581         res = lc_evpprintf(env, &app, fmt, args);
 582         lc_appendable_finish(&app);
 583         return res;
 584 }
 585
 586 int lc_evfprintf(const lc_arg_env_t *env, FILE *f, const char *fmt, va_list args)
 587 {
 588         int res;
 589         lc_appendable_t app;
 590
 591         lc_appendable_init(&app, lc_appendable_file, f, 0);
 592         res = lc_evpprintf(env, &app, fmt, args);
 593         lc_appendable_finish(&app);
 594         return res;
 595 }
 596
 597 int lc_evoprintf(const lc_arg_env_t *env, struct obstack *obst, const char *fmt, va_list args)
 598 {
 599         int res;
 600         lc_appendable_t app;
 601
 602         lc_appendable_init(&app, lc_appendable_obstack, obst, 0);
 603         res = lc_evpprintf(env, &app, fmt, args);
 604         lc_appendable_finish(&app);
 605         return res;
 606 }
 607
 608
 609 int lc_printf(const char *fmt, ...)
 610 {
 611         int res;
 612         va_list args;
 613         va_start(args, fmt);
 614         res = lc_vprintf(fmt, args);
 615         va_end(args);
 616         return res;
 617 }
 618
 619 int lc_snprintf(char *buf, size_t len, const char *fmt, ...)
 620 {
 621         int res;
 622         va_list args;
 623         va_start(args, fmt);
 624         res = lc_vsnprintf(buf, len, fmt, args);
 625         va_end(args);
 626         return res;
 627 }
 628
 629 int lc_fprintf(FILE *f, const char *fmt, ...)
 630 {
 631         int res;
 632         va_list args;
 633         va_start(args, fmt);
 634         res = lc_vfprintf(f, fmt, args);
 635         va_end(args);
 636         return res;
 637 }
 638
 639 int lc_oprintf(struct obstack *obst, const char *fmt, ...)
 640 {
 641         int res;
 642         va_list args;
 643         va_start(args, fmt);
 644         res = lc_voprintf(obst, fmt, args);
 645         va_end(args);
 646         return res;
 647 }
 648
 649
 650 int lc_vprintf(const char *fmt, va_list args)
 651 {
 652         return lc_evprintf(_lc_arg_get_default_env(), fmt, args);
 653 }
 654
 655 int lc_vsnprintf(char *buf, size_t len, const char *fmt, va_list args)
 656 {
 657         return lc_evsnprintf(_lc_arg_get_default_env(), buf, len, fmt, args);
 658 }
 659
 660 int lc_vfprintf(FILE *f, const char *fmt, va_list args)
 661 {
 662         return lc_evfprintf(_lc_arg_get_default_env(), f, fmt, args);
 663 }
 664
 665 int lc_voprintf(struct obstack *obst, const char *fmt, va_list args)
 666 {
 667         return lc_evoprintf(_lc_arg_get_default_env(), obst, fmt, args);
 668 }