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
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <stddef.h>
  30 #include <stdarg.h>
  31 #include <string.h>
  32 #include <assert.h>
  33 #include <ctype.h>
  34
  35 #include "lc_common_t.h"
  36 #include "xmalloc.h"
  37 #include "lc_printf.h"
  38 #include "lc_defines.h"
  39 #include "hashptr.h"
  40 #include "set.h"
  41
  42 /* printf implementation */
  43
  44 typedef struct _lc_arg_t {
  45         struct _lc_arg_t *next;
  46         const char *name;
  47         char letter;
  48         int lc_arg_type;
  49         const lc_arg_handler_t *handler;
  50 } lc_arg_t;
  51
  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. */
  56 };
  57
  58 /** The default argument environment. */
  59 static lc_arg_env_t *default_env = NULL;
  60
  61 static INLINE lc_arg_env_t *_lc_arg_get_default_env(void)
  62 {
  63         if(!default_env)
  64                 default_env = lc_arg_add_std(lc_arg_new_env());
  65
  66         return default_env;
  67 }
  68
  69 lc_arg_env_t *lc_arg_get_default_env(void)
  70 {
  71         return _lc_arg_get_default_env();
  72 }
  73
  74 static int lc_arg_cmp(const void *p1, const void *p2, UNUSED(size_t size))
  75 {
  76         const lc_arg_t *a1 = p1;
  77         const lc_arg_t *a2 = p2;
  78         return strcmp(a1->name, a2->name);
  79 }
  80
  81
  82 lc_arg_env_t *lc_arg_new_env(void)
  83 {
  84         lc_arg_env_t *env = xmalloc(sizeof(*env));
  85         memset(env, 0, sizeof(*env));
  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 ovverides 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         const char *mod = occ->modifier;
 194         int res = -1;
 195
 196
 197         /* check, if the type can be derived from the modifier */
 198         if(modlen > 0) {
 199                 switch(mod[0]) {
 200                         case 'l':
 201                                 res = modlen > 1 && mod[1] == 'l' ? lc_arg_type_long_long : lc_arg_type_long;
 202                                 break;
 203 #define TYPE_CASE(letter,type) case letter: res = lc_arg_type_ ## type; break
 204 #if 0
 205                         TYPE_CASE('j', intmax_t);
 206                         TYPE_CASE('z', size_t);
 207                         TYPE_CASE('t', ptrdiff_t);
 208 #endif
 209                         TYPE_CASE('L', long_double);
 210 #undef TYPE_CASE
 211                 }
 212         }
 213
 214         /* The type is given by the conversion specifier and cannot be
 215          * determined from the modifier. */
 216         if(res == -1) {
 217                 switch(occ->conversion) {
 218                         case 'e':
 219                         case 'E':
 220                         case 'f':
 221                         case 'F':
 222                         case 'g':
 223                         case 'G':
 224                                 res = lc_arg_type_double;
 225                                 break;
 226                         case 's':
 227                         case 'n':
 228                         case 'p':
 229                                 res = lc_arg_type_ptr;
 230                                 break;
 231                         default:
 232                                 res = lc_arg_type_int;
 233                 }
 234         }
 235
 236         return res;
 237 }
 238
 239 static int std_emit(lc_appendable_t *app, const lc_arg_occ_t *occ, const lc_arg_value_t *val)
 240 {
 241         char fmt[32];
 242         int res = 0;
 243
 244         make_fmt(fmt, sizeof(fmt), occ);
 245
 246         switch(occ->conversion) {
 247
 248                 /* Store the number of written characters in the given
 249                  * int pointer location */
 250                 case 'n':
 251                         {
 252                                 int *num = val->v_ptr;
 253                                 *num = app->written;
 254                         }
 255                         break;
 256
 257                 /* strings are dumped directly, since they can get really big. A
 258                  * buffer of 128 letters for all other types should be enough. */
 259                 case 's':
 260                         {
 261                                 const char *str = val->v_ptr;
 262                                 res = lc_arg_append(app, occ, str, strlen(str));
 263                         }
 264                         break;
 265
 266                 default:
 267                         {
 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);
 272                                 free(buf);
 273                         }
 274         }
 275
 276         return res;
 277 }
 278
 279 static const lc_arg_handler_t std_handler = {
 280         std_get_lc_arg_type,
 281         std_emit
 282 };
 283
 284 lc_arg_env_t *lc_arg_add_std(lc_arg_env_t *env)
 285 {
 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);
 293
 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);
 300
 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);
 304
 305         return env;
 306 }
 307
 308 static char *read_int(const char *s, int *value)
 309 {
 310         char *endptr;
 311         int res = (int) strtol(s, &endptr, 10);
 312         *value = endptr == s ? -1 : res;
 313         return endptr;
 314 }
 315
 316 /* Generic printf() function. */
 317
 318 int lc_evpprintf(const lc_arg_env_t *env, lc_appendable_t *app, const char *fmt, va_list args)
 319 {
 320         int res = 0;
 321         const char *s;
 322         const char *last = fmt + strlen(fmt);
 323
 324         /* Find the fisrt % */
 325         s = strchr(fmt, '%');
 326
 327         /* Emit the text before the first % was found */
 328         lc_appendable_snadd(app, fmt, (s ? s : last) - fmt);
 329
 330         while(s != NULL) {
 331                 lc_arg_occ_t occ;
 332                 lc_arg_value_t val;
 333                 const lc_arg_t *arg = NULL;
 334                 const char *old;
 335                 char ch;
 336
 337                 /* We must be at a '%' */
 338                 assert(*s == '%');
 339
 340                 /* Reset the occurrence structure */
 341                 memset(&occ, 0, sizeof(occ));
 342
 343                 /* Eat all flags and set the corresponding flags in the occ struct */
 344                 for(++s; strchr("#0-+", *s); ++s) {
 345                         switch(*s) {
 346                                 case '#':
 347                                         occ.flag_hash = 1;
 348                                         break;
 349                                 case '0':
 350                                         occ.flag_zero = 1;
 351                                         break;
 352                                 case '-':
 353                                         occ.flag_minus = 1;
 354                                         break;
 355                                 case '+':
 356                                         occ.flag_plus = 1;
 357                                         break;
 358                                 case ' ':
 359                                         occ.flag_space = 1;
 360                                         break;
 361                         }
 362                 }
 363
 364                 /* Read the width if given */
 365                 s = read_int(s, &occ.width);
 366
 367                 occ.precision = -1;
 368
 369                 /* read the precision if given */
 370                 if(*s == '.') {
 371                         int val;
 372                         s = read_int(s + 1, &val);
 373
 374                         /* Negative or lacking precision after a '.' is treated as
 375                          * precision 0. */
 376                         occ.precision = LC_MAX(0, val);
 377                 }
 378
 379                 /*
 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
 384                  */
 385                 ch = *s;
 386                 switch(ch) {
 387                         case '%':
 388                                 s++;
 389                                 res += lc_appendable_chadd(app, '%');
 390                                 break;
 391                         case '{':
 392                                 {
 393                                         const char *named = ++s;
 394
 395                                         /* Read until the closing brace or end of the string. */
 396                                         for(ch = *s; ch != '}' && ch != '\0'; ch = *++s);
 397
 398                                         if(s - named) {
 399                                                 int n = s - named;
 400                                                 char *name;
 401                                                 lc_arg_t tmp;
 402
 403                                                 name = malloc(sizeof(char) * (n + 1));
 404                                                 memcpy(name, named, sizeof(char) * n);
 405                                                 name[n] = '\0';
 406                                                 tmp.name = name;
 407
 408                                                 arg = set_find(env->args, &tmp, sizeof(tmp), HASH_STR(named, n));
 409                                                 occ.modifier = "";
 410                                                 occ.modifier_length = 0;
 411
 412                                                 /* Set the conversion specifier of the occurrence to the
 413                                                  * letter specified in the argument description. */
 414                                                 if(arg)
 415                                                         occ.conversion = arg->letter;
 416
 417                                                 free(name);
 418
 419                                                 /* If we ended with a closing brace, move the current
 420                                                  * pointer after it, since it is not to be dumped. */
 421                                                 if(ch == '}')
 422                                                         s++;
 423                                         }
 424                                 }
 425                                 break;
 426
 427                         default:
 428                                 {
 429                                         const char *mod = s;
 430
 431                                         /* Read, as long there are letters */
 432                                         while(isalpha(ch) && !arg) {
 433                                                 int base = 'a';
 434                                                 lc_arg_t * const *map = env->lower;
 435
 436                                                 /* If uppercase, select the uppercase map from the environment */
 437                                                 if(isupper(ch)) {
 438                                                         base = 'A';
 439                                                         map = env->upper;
 440                                                 }
 441
 442                                                 if(map[ch - base] != NULL) {
 443                                                         occ.modifier = s;
 444                                                         occ.modifier_length = s - mod;
 445                                                         occ.conversion = ch;
 446                                                         arg = map[ch - base];
 447                                                 }
 448
 449                                                 ch = *++s;
 450                                         }
 451                                 }
 452                 }
 453
 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;
 457
 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);
 461
 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"
 466 #undef LC_ARG_TYPE
 467                         }
 468
 469                         /* Finally, call the handler. */
 470                         res += handler->emit(app, &occ, &val);
 471                 }
 472
 473                 old = s;
 474                 s = strchr(s, '%');
 475                 res += lc_appendable_snadd(app, old, (s ? s : last) - old);
 476         }
 477
 478         return res;
 479 }
 480
 481 /* Convenience implementations */
 482
 483 int lc_epprintf(const lc_arg_env_t *env, lc_appendable_t *app, const char *fmt, ...)
 484 {
 485         int res;
 486         va_list args;
 487         va_start(args, fmt);
 488         res = lc_evpprintf(env, app, fmt, args);
 489         va_end(args);
 490         return res;
 491 }
 492
 493 int lc_pprintf(lc_appendable_t *app, const char *fmt, ...)
 494 {
 495         int res;
 496         va_list args;
 497         va_start(args, fmt);
 498         res = lc_vpprintf(app, fmt, args);
 499         va_end(args);
 500         return res;
 501 }
 502
 503 int lc_vpprintf(lc_appendable_t *app, const char *fmt, va_list args)
 504 {
 505         return lc_evpprintf(_lc_arg_get_default_env(), app, fmt, args);
 506 }
 507
 508 int lc_eprintf(const lc_arg_env_t *env, const char *fmt, ...)
 509 {
 510         int res;
 511         va_list args;
 512         va_start(args, fmt);
 513         res = lc_efprintf(env, stdout, fmt, args);
 514         va_end(args);
 515         return res;
 516 }
 517
 518 int lc_esnprintf(const lc_arg_env_t *env, char *buf, size_t len, const char *fmt, ...)
 519 {
 520         int res;
 521         va_list args;
 522         va_start(args, fmt);
 523         res = lc_evsnprintf(env, buf, len, fmt, args);
 524         va_end(args);
 525         return res;
 526 }
 527
 528 int lc_efprintf(const lc_arg_env_t *env, FILE *file, const char *fmt, ...)
 529 {
 530         int res;
 531         va_list args;
 532         va_start(args, fmt);
 533         res = lc_evfprintf(env, file, fmt, args);
 534         va_end(args);
 535         return res;
 536 }
 537
 538 int lc_eoprintf(const lc_arg_env_t *env, struct obstack *obst, const char *fmt, ...)
 539 {
 540         int res;
 541         va_list args;
 542         va_start(args, fmt);
 543         res = lc_evoprintf(env, obst, fmt, args);
 544         va_end(args);
 545         return res;
 546 }
 547
 548 int lc_evprintf(const lc_arg_env_t *env, const char *fmt, va_list args)
 549 {
 550         return lc_evfprintf(env, stdout, fmt, args);
 551 }
 552
 553 int lc_evsnprintf(const lc_arg_env_t *env, char *buf, size_t len, const char *fmt, va_list args)
 554 {
 555         int res;
 556         lc_appendable_t app;
 557
 558         lc_appendable_init(&app, lc_appendable_string, buf, len);
 559         res = lc_evpprintf(env, &app, fmt, args);
 560         lc_appendable_finish(&app);
 561         return res;
 562 }
 563
 564 int lc_evfprintf(const lc_arg_env_t *env, FILE *f, const char *fmt, va_list args)
 565 {
 566         int res;
 567         lc_appendable_t app;
 568
 569         lc_appendable_init(&app, lc_appendable_file, f, 0);
 570         res = lc_evpprintf(env, &app, fmt, args);
 571         lc_appendable_finish(&app);
 572         return res;
 573 }
 574
 575 int lc_evoprintf(const lc_arg_env_t *env, struct obstack *obst, const char *fmt, va_list args)
 576 {
 577         int res;
 578         lc_appendable_t app;
 579
 580         lc_appendable_init(&app, lc_appendable_obstack, obst, 0);
 581         res = lc_evpprintf(env, &app, fmt, args);
 582         lc_appendable_finish(&app);
 583         return res;
 584 }
 585
 586
 587 int lc_printf(const char *fmt, ...)
 588 {
 589         int res;
 590         va_list args;
 591         va_start(args, fmt);
 592         res = lc_vprintf(fmt, args);
 593         va_end(args);
 594         return res;
 595 }
 596
 597 int lc_snprintf(char *buf, size_t len, const char *fmt, ...)
 598 {
 599         int res;
 600         va_list args;
 601         va_start(args, fmt);
 602         res = lc_vsnprintf(buf, len, fmt, args);
 603         va_end(args);
 604         return res;
 605 }
 606
 607 int lc_fprintf(FILE *f, const char *fmt, ...)
 608 {
 609         int res;
 610         va_list args;
 611         va_start(args, fmt);
 612         res = lc_vfprintf(f, fmt, args);
 613         va_end(args);
 614         return res;
 615 }
 616
 617 int lc_oprintf(struct obstack *obst, const char *fmt, ...)
 618 {
 619         int res;
 620         va_list args;
 621         va_start(args, fmt);
 622         res = lc_voprintf(obst, fmt, args);
 623         va_end(args);
 624         return res;
 625 }
 626
 627
 628 int lc_vprintf(const char *fmt, va_list args)
 629 {
 630         return lc_evprintf(_lc_arg_get_default_env(), fmt, args);
 631 }
 632
 633 int lc_vsnprintf(char *buf, size_t len, const char *fmt, va_list args)
 634 {
 635         return lc_evsnprintf(_lc_arg_get_default_env(), buf, len, fmt, args);
 636 }
 637
 638 int lc_vfprintf(FILE *f, const char *fmt, va_list args)
 639 {
 640         return lc_evfprintf(_lc_arg_get_default_env(), f, fmt, args);
 641 }
 642
 643 int lc_voprintf(struct obstack *obst, const char *fmt, va_list args)
 644 {
 645         return lc_evoprintf(_lc_arg_get_default_env(), obst, fmt, args);
 646 }