src/xbt/config.cpp

   1 /* Copyright (c) 2004-2014,2016. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 #include <stdio.h>
   5
   6 #include <cerrno>
   7 #include <cstring>
   8 #include <climits>
   9 #include <functional>
  10 #include <stdexcept>
  11 #include <string>
  12 #include <type_traits>
  13
  14 #include <xbt/config.h>
  15 #include <xbt/config.hpp>
  16 #include "xbt/misc.h"
  17 #include "xbt/sysdep.h"
  18 #include "xbt/log.h"
  19 #include "xbt/ex.h"
  20 #include "xbt/dynar.h"
  21 #include "xbt/dict.h"
  22
  23 // *****
  24
  25 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_cfg, xbt, "configuration support");
  26
  27 XBT_EXPORT_NO_IMPORT(xbt_cfg_t) simgrid_config = NULL;
  28
  29 namespace {
  30
  31 static inline
  32 void increment(e_xbt_cfgelm_type_t& type)
  33 {
  34   typedef std::underlying_type<e_xbt_cfgelm_type_t>::type underlying_type;
  35   type = (e_xbt_cfgelm_type_t) ((underlying_type) type + 1);
  36 }
  37
  38 }
  39
  40 /* xbt_cfgelm_t: the typedef corresponding to a config variable. */
  41
  42 typedef struct s_xbt_cfgelm_t {
  43   /* Description */
  44   std::string desc;
  45
  46   /* Allowed type of the variable */
  47   e_xbt_cfgelm_type_t type;
  48   bool isdefault = true;
  49
  50   /* Callback */
  51   xbt_cfg_cb_t cb_set = nullptr;
  52
  53   /* Advanced callback (for xbt_cfgelm_string only) */
  54   std::function<void(const char* value)> callback;
  55
  56   /* actual content (could be an union or something) */
  57   xbt_dynar_t content = nullptr;
  58
  59   ~s_xbt_cfgelm_t()
  60   {
  61     XBT_DEBUG("Frees cfgelm %p", this);
  62     if (this->type != xbt_cfgelm_alias)
  63       xbt_dynar_free(&(this->content));
  64   }
  65
  66 } s_xbt_cfgelm_t, *xbt_cfgelm_t;
  67
  68 static const char *xbt_cfgelm_type_name[xbt_cfgelm_type_count] = { "int", "double", "string", "boolean", "any", "outofbound" };
  69
  70 const struct xbt_boolean_couple xbt_cfgelm_boolean_values[] = {
  71   { "yes",    "no"},
  72   {  "on",   "off"},
  73   {"true", "false"},
  74   {   "1",     "0"},
  75   {  NULL,    NULL}
  76 };
  77
  78 /* Internal stuff used in cache to free a variable */
  79 static void xbt_cfgelm_free(void *data)
  80 {
  81   if (data)
  82     delete (xbt_cfgelm_t) data;
  83 }
  84
  85 /* Retrieve the variable we'll modify */
  86 static xbt_cfgelm_t xbt_cfgelm_get(xbt_cfg_t cfg, const char *name, e_xbt_cfgelm_type_t type);
  87
  88 /*----[ Memory management ]-----------------------------------------------*/
  89 /** @brief Constructor
  90  *
  91  * Initialise a config set
  92  */
  93 xbt_cfg_t xbt_cfg_new(void)
  94 {
  95   return (xbt_cfg_t) xbt_dict_new_homogeneous(&xbt_cfgelm_free);
  96 }
  97
  98 /** @brief Destructor */
  99 void xbt_cfg_free(xbt_cfg_t * cfg)
 100 {
 101   XBT_DEBUG("Frees cfg set %p", cfg);
 102   xbt_dict_free((xbt_dict_t *) cfg);
 103 }
 104
 105 /** @brief Dump a config set for debuging purpose
 106  *
 107  * @param name The name to give to this config set
 108  * @param indent what to write at the beginning of each line (right number of spaces)
 109  * @param cfg the config set
 110  */
 111 void xbt_cfg_dump(const char *name, const char *indent, xbt_cfg_t cfg)
 112 {
 113   xbt_dict_t dict = (xbt_dict_t) cfg;
 114   xbt_dict_cursor_t cursor = NULL;
 115   xbt_cfgelm_t variable = NULL;
 116   char *key = NULL;
 117   int i;
 118   int size;
 119   int ival;
 120   char *sval;
 121   double dval;
 122
 123   if (name)
 124     printf("%s>> Dumping of the config set '%s':\n", indent, name);
 125
 126   xbt_dict_foreach(dict, cursor, key, variable) {
 127     printf("%s  %s:", indent, key);
 128
 129     size = xbt_dynar_length(variable->content);
 130     printf ("%s. Actual size=%d. postset=%p\n",
 131             xbt_cfgelm_type_name[variable->type], size, variable->cb_set);
 132
 133     switch (variable->type) {
 134     case xbt_cfgelm_int:
 135       for (i = 0; i < size; i++) {
 136         ival = xbt_dynar_get_as(variable->content, i, int);
 137         printf("%s    %d\n", indent, ival);
 138       }
 139       break;
 140     case xbt_cfgelm_double:
 141       for (i = 0; i < size; i++) {
 142         dval = xbt_dynar_get_as(variable->content, i, double);
 143         printf("%s    %f\n", indent, dval);
 144       }
 145       break;
 146     case xbt_cfgelm_string:
 147       for (i = 0; i < size; i++) {
 148         sval = xbt_dynar_get_as(variable->content, i, char *);
 149         printf("%s    %s\n", indent, sval);
 150       }
 151       break;
 152     case xbt_cfgelm_boolean:
 153       for (i = 0; i < size; i++) {
 154         ival = xbt_dynar_get_as(variable->content, i, int);
 155         printf("%s    %d\n", indent, ival);
 156       }
 157       break;
 158     case xbt_cfgelm_alias:
 159       /* no content */
 160       break;
 161     default:
 162       printf("%s    Invalid type!!\n", indent);
 163       break;
 164     }
 165   }
 166
 167   if (name)
 168     printf("%s<< End of the config set '%s'\n", indent, name);
 169   fflush(stdout);
 170
 171   xbt_dict_cursor_free(&cursor);
 172 }
 173
 174 /*----[ Registering stuff ]-----------------------------------------------*/
 175 /** @brief Register an element within a config set
 176  *
 177  *  @param cfg the config set
 178  *  @param name the name of the config element
 179  *  @param desc a description for this item (used by xbt_cfg_help())
 180  *  @param type the type of the config element
 181  *  @param cb_set callback function called when a value is set
 182  */
 183 static void xbt_cfg_register(
 184   xbt_cfg_t * cfg, const char *name, const char *desc, e_xbt_cfgelm_type_t type,
 185   xbt_cfg_cb_t cb_set,
 186   std::function<void(const char* value)> callback = std::function<void(const char* value)>())
 187 {
 188   if (*cfg == NULL)
 189     *cfg = xbt_cfg_new();
 190   xbt_assert(type >= xbt_cfgelm_int && type <= xbt_cfgelm_boolean,
 191               "type of %s not valid (%d should be between %d and %d)",
 192              name, (int)type, xbt_cfgelm_int, xbt_cfgelm_boolean);
 193
 194   xbt_cfgelm_t res = (xbt_cfgelm_t) xbt_dict_get_or_null((xbt_dict_t) * cfg, name);
 195   xbt_assert(NULL == res, "Refusing to register the config element '%s' twice.", name);
 196
 197   res = new s_xbt_cfgelm_t();
 198   XBT_DEBUG("Register cfg elm %s (%s) (%s (=%d) @%p in set %p)",
 199             name, desc, xbt_cfgelm_type_name[type], (int)type, res, *cfg);
 200   res->type = type;
 201   if (desc)
 202     res->desc = desc;
 203   res->cb_set = cb_set;
 204   res->callback = std::move(callback);
 205
 206   switch (type) {
 207   case xbt_cfgelm_int:
 208     res->content = xbt_dynar_new(sizeof(int), NULL);
 209     break;
 210   case xbt_cfgelm_double:
 211     res->content = xbt_dynar_new(sizeof(double), NULL);
 212     break;
 213   case xbt_cfgelm_string:
 214     res->content = xbt_dynar_new(sizeof(char *), xbt_free_ref);
 215     break;
 216   case xbt_cfgelm_boolean:
 217     res->content = xbt_dynar_new(sizeof(int), NULL);
 218     break;
 219   default:
 220     XBT_ERROR("%d is an invalid type code", (int)type);
 221     break;
 222   }
 223
 224   xbt_dict_set((xbt_dict_t) * cfg, name, res, NULL);
 225 }
 226
 227 void xbt_cfg_register_double(const char *name, double default_value,xbt_cfg_cb_t cb_set, const char *desc){
 228   xbt_cfg_register(&simgrid_config,name,desc,xbt_cfgelm_double,cb_set);
 229   xbt_cfg_setdefault_double(name, default_value);
 230 }
 231 void xbt_cfg_register_int(const char *name, int default_value,xbt_cfg_cb_t cb_set, const char *desc) {
 232   xbt_cfg_register(&simgrid_config,name,desc,xbt_cfgelm_int,cb_set);
 233   xbt_cfg_setdefault_int(name, default_value);
 234 }
 235 void xbt_cfg_register_string(const char *name, const char *default_value, xbt_cfg_cb_t cb_set, const char *desc){
 236   xbt_cfg_register(&simgrid_config,name,desc,xbt_cfgelm_string,cb_set);
 237   xbt_cfg_setdefault_string(name, default_value);
 238 }
 239 void xbt_cfg_register_boolean(const char *name, const char*default_value,xbt_cfg_cb_t cb_set, const char *desc){
 240   xbt_cfg_register(&simgrid_config,name,desc,xbt_cfgelm_boolean,cb_set);
 241   xbt_cfg_setdefault_boolean(name, default_value);
 242 }
 243
 244 void xbt_cfg_register_alias(const char *newname, const char *oldname)
 245 {
 246   if (simgrid_config == NULL)
 247     simgrid_config = xbt_cfg_new();
 248
 249   xbt_cfgelm_t res = (xbt_cfgelm_t) xbt_dict_get_or_null((xbt_dict_t) simgrid_config, oldname);
 250   xbt_assert(NULL == res, "Refusing to register the option '%s' twice.", oldname);
 251
 252   res = (xbt_cfgelm_t) xbt_dict_get_or_null((xbt_dict_t) simgrid_config, newname);
 253   xbt_assert(res, "Cannot define an alias to the non-existing option '%s'.", newname);
 254
 255   res = new s_xbt_cfgelm_t();
 256   XBT_DEBUG("Register cfg alias %s -> %s)",oldname,newname);
 257
 258   res->desc = bprintf("Deprecated alias for %s",newname);
 259   res->type = xbt_cfgelm_alias;
 260   res->content = (xbt_dynar_t)newname;
 261
 262   xbt_dict_set((xbt_dict_t) simgrid_config, oldname, res, NULL);
 263 }
 264
 265 /**
 266  * @brief Parse a string and register the stuff described.
 267  *
 268  * @param cfg the config set
 269  * @param entry a string describing the element to register
 270  *
 271  * The string may consist in several variable descriptions separated by a space.
 272  * Each of them must use the following syntax: \<name\>:\<type\>
 273  * with type being one of  'string','int','bool' or 'double'.
 274  *
 275  * Note that this does not allow to set the description, so you should prefer the other interface
 276  */
 277 void xbt_cfg_register_str(xbt_cfg_t * cfg, const char *entry)
 278 {
 279   char *entrycpy = xbt_strdup(entry);
 280   char *tok;
 281
 282   e_xbt_cfgelm_type_t type;
 283   XBT_DEBUG("Register string '%s'", entry);
 284
 285   tok = strchr(entrycpy, ':');
 286   xbt_assert(tok, "Invalid config element descriptor: %s; Should be <name>:<type>", entry);
 287   *(tok++) = '\0';
 288
 289   for (type = (e_xbt_cfgelm_type_t)0; type < xbt_cfgelm_type_count && strcmp(tok, xbt_cfgelm_type_name[type]); increment(type));
 290   xbt_assert(type < xbt_cfgelm_type_count,
 291       "Invalid type in config element descriptor: %s; Should be one of 'string', 'int' or 'double'.", entry);
 292
 293   xbt_cfg_register(cfg, entrycpy, NULL, type, NULL);
 294
 295   free(entrycpy);               /* strdup'ed by dict mechanism, but cannot be const */
 296 }
 297
 298 /** @brief Displays the declared aliases and their description */
 299 void xbt_cfg_aliases(void)
 300 {
 301   xbt_dict_cursor_t dict_cursor;
 302   unsigned int dynar_cursor;
 303   xbt_cfgelm_t variable;
 304   char *name;
 305   xbt_dynar_t names = xbt_dynar_new(sizeof(char *), NULL);
 306
 307   xbt_dict_foreach((xbt_dict_t )simgrid_config, dict_cursor, name, variable)
 308     xbt_dynar_push(names, &name);
 309   xbt_dynar_sort_strings(names);
 310
 311   xbt_dynar_foreach(names, dynar_cursor, name) {
 312     variable = (xbt_cfgelm_t) xbt_dict_get((xbt_dict_t )simgrid_config, name);
 313
 314     if (variable->type == xbt_cfgelm_alias)
 315       printf("   %s: %s\n", name, variable->desc.c_str());
 316   }
 317 }
 318
 319 /** @brief Displays the declared options and their description */
 320 void xbt_cfg_help(void)
 321 {
 322   xbt_dict_cursor_t dict_cursor;
 323   unsigned int dynar_cursor;
 324   xbt_cfgelm_t variable;
 325   char *name;
 326   xbt_dynar_t names = xbt_dynar_new(sizeof(char *), NULL);
 327
 328   xbt_dict_foreach((xbt_dict_t )simgrid_config, dict_cursor, name, variable)
 329     xbt_dynar_push(names, &name);
 330   xbt_dynar_sort_strings(names);
 331
 332   xbt_dynar_foreach(names, dynar_cursor, name) {
 333     int size;
 334     variable = (xbt_cfgelm_t) xbt_dict_get((xbt_dict_t )simgrid_config, name);
 335     if (variable->type == xbt_cfgelm_alias)
 336       continue;
 337
 338     printf("   %s: %s\n", name, variable->desc.c_str());
 339     printf("       Type: %s; ", xbt_cfgelm_type_name[variable->type]);
 340     size = xbt_dynar_length(variable->content);
 341     printf("Current value: ");
 342
 343     if (size != 1)
 344       printf(size == 0 ? "n/a\n" : "{ ");
 345     for (int i = 0; i < size; i++) {
 346       const char *sep = (size == 1 ? "\n" : (i < size - 1 ? ", " : " }\n"));
 347
 348       switch (variable->type) {
 349       case xbt_cfgelm_int:
 350         printf("%d%s", xbt_dynar_get_as(variable->content, i, int), sep);
 351         break;
 352       case xbt_cfgelm_double:
 353         printf("%f%s", xbt_dynar_get_as(variable->content, i, double), sep);
 354         break;
 355       case xbt_cfgelm_string:
 356         printf("'%s'%s", xbt_dynar_get_as(variable->content, i, char *), sep);
 357         break;
 358       case xbt_cfgelm_boolean: {
 359         int b = xbt_dynar_get_as(variable->content, i, int);
 360         const char *bs = b ? xbt_cfgelm_boolean_values[0].true_val: xbt_cfgelm_boolean_values[0].false_val;
 361         if (b == 0 || b == 1)
 362           printf("'%s'%s", bs, sep);
 363         else
 364           printf("'%s/%d'%s", bs, b, sep);
 365         break;
 366       }
 367       default:
 368         printf("Invalid type!!%s", sep);
 369         break;
 370       }
 371     }
 372   }
 373   xbt_dynar_free(&names);
 374 }
 375
 376 static xbt_cfgelm_t xbt_cfgelm_get(xbt_cfg_t cfg, const char *name, e_xbt_cfgelm_type_t type)
 377 {
 378   xbt_cfgelm_t res = (xbt_cfgelm_t) xbt_dict_get_or_null((xbt_dict_t) cfg, name);
 379
 380   // The user used the old name. Switch to the new one after a short warning
 381   while (res && res->type == xbt_cfgelm_alias) {
 382     const char* newname = (const char *)res->content;
 383     XBT_INFO("Option %s has been renamed to %s. Consider switching.", name, newname);
 384     res = xbt_cfgelm_get(cfg, newname, type);
 385   }
 386
 387   if (!res) {
 388     xbt_cfg_help();
 389     fflush(stdout);
 390     THROWF(not_found_error, 0, "No registered variable '%s' in this config set.", name);
 391   }
 392
 393   xbt_assert(type == xbt_cfgelm_any || res->type == type,
 394               "You tried to access to the config element %s as an %s, but its type is %s.",
 395               name, xbt_cfgelm_type_name[type], xbt_cfgelm_type_name[res->type]);
 396   return res;
 397 }
 398
 399 /** @brief Get the type of this variable in that configuration set
 400  *
 401  * @param cfg the config set
 402  * @param name the name of the element
 403  *
 404  * @return the type of the given element
 405  */
 406 e_xbt_cfgelm_type_t xbt_cfg_get_type(xbt_cfg_t cfg, const char *name)
 407 {
 408   xbt_cfgelm_t variable = NULL;
 409
 410   variable = (xbt_cfgelm_t) xbt_dict_get_or_null((xbt_dict_t) cfg, name);
 411   if (!variable)
 412     THROWF(not_found_error, 0, "Can't get the type of '%s' since this variable does not exist", name);
 413
 414   XBT_DEBUG("type in variable = %d", (int)variable->type);
 415   return variable->type;
 416 }
 417
 418 /*----[ Setting ]---------------------------------------------------------*/
 419 /**  @brief va_args version of xbt_cfg_set
 420  *
 421  * @param cfg config set to fill
 422  * @param name  variable name
 423  * @param pa  variable value
 424  *
 425  * Add some values to the config set.
 426  */
 427 void xbt_cfg_set_vargs(xbt_cfg_t cfg, const char *name, va_list pa)
 428 {
 429   char *str;
 430   int i;
 431   double d;
 432   e_xbt_cfgelm_type_t type = xbt_cfgelm_type_count; /* Set a dummy value to make gcc happy. It cannot get uninitialized */
 433
 434   xbt_ex_t e;
 435
 436   TRY {
 437     type = xbt_cfg_get_type(cfg, name);
 438   }
 439   CATCH(e) {
 440     if (e.category == not_found_error) {
 441       xbt_ex_free(e);
 442       THROWF(not_found_error, 0, "Can't set the property '%s' since it's not registered", name);
 443     }
 444     RETHROW;
 445   }
 446
 447   switch (type) {
 448   case xbt_cfgelm_string:
 449     str = va_arg(pa, char *);
 450     xbt_cfg_set_string(name, str);
 451     break;
 452   case xbt_cfgelm_int:
 453     i = va_arg(pa, int);
 454     xbt_cfg_set_int(name, i);
 455     break;
 456   case xbt_cfgelm_double:
 457     d = va_arg(pa, double);
 458     xbt_cfg_set_double(name, d);
 459     break;
 460   case xbt_cfgelm_boolean:
 461     str = va_arg(pa, char *);
 462     xbt_cfg_set_boolean(name, str);
 463     break;
 464   default:
 465     xbt_die("Config element variable %s not valid (type=%d)", name, (int)type);
 466   }
 467 }
 468
 469 /** @brief Add a NULL-terminated list of pairs {(char*)key, value} to the set
 470  *
 471  * @param cfg config set to fill
 472  * @param name variable name
 473  * @param ... variable value
 474  */
 475 void xbt_cfg_set(xbt_cfg_t cfg, const char *name, ...)
 476 {
 477   va_list pa;
 478
 479   va_start(pa, name);
 480   xbt_cfg_set_vargs(cfg, name, pa);
 481   va_end(pa);
 482 }
 483
 484 /** @brief Add values parsed from a string into a config set
 485  *
 486  * @param options a string containing the content to add to the config set. This is a '\\t',' ' or '\\n' or ','
 487  * separated list of variables. Each individual variable is like "[name]:[value]" where [name] is the name of an
 488  * already registered variable, and [value] conforms to the data type under which this variable was registered.
 489  *
 490  * @todo This is a crude manual parser, it should be a proper lexer.
 491  */
 492 void xbt_cfg_set_parse(const char *options)
 493 {
 494   if (!options || !strlen(options)) {   /* nothing to do */
 495     return;
 496   }
 497   char *optionlist_cpy = xbt_strdup(options);
 498
 499   XBT_DEBUG("List to parse and set:'%s'", options);
 500   char *option = optionlist_cpy;
 501   while (1) {                   /* breaks in the code */
 502     if (!option)
 503       break;
 504     char *name = option;
 505     int len = strlen(name);
 506     XBT_DEBUG("Still to parse and set: '%s'. len=%d; option-name=%ld", name, len, (long) (option - name));
 507
 508     /* Pass the value */
 509     while (option - name <= (len - 1) && *option != ' ' && *option != '\n' && *option != '\t' && *option != ',') {
 510       XBT_DEBUG("Take %c.", *option);
 511       option++;
 512     }
 513     if (option - name == len) {
 514       XBT_DEBUG("Boundary=EOL");
 515       option = NULL;            /* don't do next iteration */
 516     } else {
 517       XBT_DEBUG("Boundary on '%c'. len=%d;option-name=%ld", *option, len, (long) (option - name));
 518       /* Pass the following blank chars */
 519       *(option++) = '\0';
 520       while (option - name < (len - 1) && (*option == ' ' || *option == '\n' || *option == '\t')) {
 521         /*      fprintf(stderr,"Ignore a blank char.\n"); */
 522         option++;
 523       }
 524       if (option - name == len - 1)
 525         option = NULL;          /* don't do next iteration */
 526     }
 527     XBT_DEBUG("parse now:'%s'; parse later:'%s'", name, option);
 528
 529     if (name[0] == ' ' || name[0] == '\n' || name[0] == '\t')
 530       continue;
 531     if (!strlen(name))
 532       break;
 533
 534     char *val = strchr(name, ':');
 535     xbt_assert(val, "Option '%s' badly formatted. Should be of the form 'name:value'", name);
 536     /* don't free(optionlist_cpy) if the assert fails, 'name' points inside it */
 537     *(val++) = '\0';
 538
 539     if (strncmp(name, "contexts/", strlen("contexts/")) && strncmp(name, "path", strlen("path")))
 540       XBT_INFO("Configuration change: Set '%s' to '%s'", name, val);
 541
 542     TRY {
 543       xbt_cfg_set_as_string(name,val);
 544     } CATCH_ANONYMOUS {
 545       free(optionlist_cpy);
 546       RETHROW;
 547     }
 548   }
 549   free(optionlist_cpy);
 550 }
 551
 552 /** @brief Set the value of a variable, using the string representation of that value
 553  *
 554  * @param key name of the variable to modify
 555  * @param value string representation of the value to set
 556  *
 557  * @return the first char after the parsed value in val
 558  */
 559
 560 void *xbt_cfg_set_as_string(const char *key, const char *value) {
 561   xbt_ex_t e;
 562
 563   char *ret;
 564   volatile xbt_cfgelm_t variable = NULL;
 565   int i;
 566   double d;
 567
 568   TRY {
 569     while (variable == NULL) {
 570       variable = (xbt_cfgelm_t) xbt_dict_get((xbt_dict_t) simgrid_config, key);
 571       if (variable->type == xbt_cfgelm_alias) {
 572         const char *newname = (const char*)variable->content;
 573         XBT_INFO("Note: configuration '%s' is deprecated. Please use '%s' instead.", key, newname);
 574         key = newname;
 575         variable = NULL;
 576       }
 577     }
 578   } CATCH(e) {
 579     if (e.category == not_found_error) {
 580       xbt_ex_free(e);
 581       THROWF(not_found_error, 0, "No registered variable corresponding to '%s'.", key);
 582     }
 583     RETHROW;
 584   }
 585
 586   switch (variable->type) {
 587   case xbt_cfgelm_string:
 588     xbt_cfg_set_string(key, value);     /* throws */
 589     break;
 590   case xbt_cfgelm_int:
 591     i = strtol(value, &ret, 0);
 592     if (ret == value) {
 593       xbt_die("Value of option %s not valid. Should be an integer", key);
 594     }
 595     xbt_cfg_set_int(key, i);  /* throws */
 596     break;
 597   case xbt_cfgelm_double:
 598     d = strtod(value, &ret);
 599     if (ret == value) {
 600       xbt_die("Value of option %s not valid. Should be a double", key);
 601     }
 602     xbt_cfg_set_double(key, d);       /* throws */
 603     break;
 604   case xbt_cfgelm_boolean:
 605     xbt_cfg_set_boolean(key, value);  /* throws */
 606     ret = (char *)value + strlen(value);
 607     break;
 608   default:
 609     THROWF(unknown_error, 0, "Type of config element %s is not valid.", key);
 610     break;
 611   }
 612   return ret;
 613 }
 614
 615 /** @brief Set an integer value to \a name within \a cfg if it wasn't changed yet
 616  *
 617  * This is useful to change the default value of a variable while allowing
 618  * users to override it with command line arguments
 619  */
 620 void xbt_cfg_setdefault_int(const char *name, int val)
 621 {
 622   xbt_cfgelm_t variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_int);
 623
 624   if (variable->isdefault){
 625     xbt_cfg_set_int(name, val);
 626     variable->isdefault = true;
 627   } else
 628     XBT_DEBUG("Do not override configuration variable '%s' with value '%d' because it was already set.", name, val);
 629 }
 630
 631 /** @brief Set an integer value to \a name within \a cfg if it wasn't changed yet
 632  *
 633  * This is useful to change the default value of a variable while allowing
 634  * users to override it with command line arguments
 635  */
 636 void xbt_cfg_setdefault_double(const char *name, double val)
 637 {
 638   xbt_cfgelm_t variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_double);
 639
 640   if (variable->isdefault) {
 641     xbt_cfg_set_double(name, val);
 642     variable->isdefault = true;
 643   } else
 644     XBT_DEBUG("Do not override configuration variable '%s' with value '%f' because it was already set.", name, val);
 645 }
 646
 647 /** @brief Set a string value to \a name within \a cfg if it wasn't changed yet
 648  *
 649  * This is useful to change the default value of a variable while allowing
 650  * users to override it with command line arguments
 651  */
 652 void xbt_cfg_setdefault_string(const char *name, const char *val)
 653 {
 654   xbt_cfgelm_t variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_string);
 655
 656   if (variable->isdefault){
 657     xbt_cfg_set_string(name, val);
 658     variable->isdefault = true;
 659   } else
 660     XBT_DEBUG("Do not override configuration variable '%s' with value '%s' because it was already set.", name, val);
 661 }
 662
 663 /** @brief Set an boolean value to \a name within \a cfg if it wasn't changed yet
 664  *
 665  * This is useful to change the default value of a variable while allowing
 666  * users to override it with command line arguments
 667  */
 668 void xbt_cfg_setdefault_boolean(const char *name, const char *val)
 669 {
 670   xbt_cfgelm_t variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_boolean);
 671
 672   if (variable->isdefault){
 673     xbt_cfg_set_boolean(name, val);
 674     variable->isdefault = true;
 675   }
 676    else
 677     XBT_DEBUG("Do not override configuration variable '%s' with value '%s' because it was already set.", name, val);
 678 }
 679
 680 /** @brief Set an integer value to \a name within \a cfg
 681  *
 682  * @param name the name of the variable
 683  * @param val the value of the variable
 684  */
 685 void xbt_cfg_set_int(const char *name, int val)
 686 {
 687   xbt_cfgelm_t variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_int);
 688
 689   xbt_dynar_set(variable->content, 0, &val);
 690
 691   if (variable->cb_set)
 692     variable->cb_set(name);
 693   variable->isdefault = false;
 694 }
 695
 696 /** @brief Set or add a double value to \a name within \a cfg
 697  *
 698  * @param name the name of the variable
 699  * @param val the double to set
 700  */
 701 void xbt_cfg_set_double(const char *name, double val)
 702 {
 703   xbt_cfgelm_t variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_double);
 704
 705   xbt_dynar_set(variable->content, 0, &val);
 706
 707   if (variable->cb_set)
 708     variable->cb_set(name);
 709   variable->isdefault = false;
 710 }
 711
 712 /** @brief Set or add a string value to \a name within \a cfg
 713  *
 714  * @param cfg the config set
 715  * @param name the name of the variable
 716  * @param val the value to be added
 717  *
 718  */
 719 void xbt_cfg_set_string(const char *name, const char *val)
 720 {
 721   char *newval = xbt_strdup(val);
 722   xbt_cfgelm_t variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_string);
 723
 724   if (!xbt_dynar_is_empty(variable->content)) {
 725     char *sval = xbt_dynar_get_as(variable->content, 0, char *);
 726     free(sval);
 727   }
 728
 729   xbt_dynar_set(variable->content, 0, &newval);
 730
 731   if (variable->cb_set)
 732     variable->cb_set(name);
 733
 734   if (variable->callback) {
 735     try {
 736       variable->callback(val);
 737     }
 738     catch(std::range_error& e) {
 739       xbt_die("Invalid flag %s=%s: %s", val, name, e.what());
 740     }
 741     catch(std::exception& e) {
 742       xbt_die("Error for flag %s=%s: %s", val, name, e.what());
 743     }
 744     catch(...) {
 745       xbt_die("Error for flag %s=%s", val, name);
 746     }
 747   }
 748
 749   variable->isdefault = false;
 750 }
 751
 752 /** @brief Set or add a boolean value to \a name within \a cfg
 753  *
 754  * @param name the name of the variable
 755  * @param val the value of the variable
 756  */
 757 void xbt_cfg_set_boolean(const char *name, const char *val)
 758 {
 759   int bval=-1;
 760   xbt_cfgelm_t variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_boolean);
 761
 762   for (int i = 0; xbt_cfgelm_boolean_values[i].true_val != NULL; i++) {
 763     if (strcmp(val, xbt_cfgelm_boolean_values[i].true_val) == 0){
 764       bval = 1;
 765       break;
 766     }
 767     if (strcmp(val, xbt_cfgelm_boolean_values[i].false_val) == 0){
 768       bval = 0;
 769       break;
 770     }
 771   }
 772   xbt_assert(bval != -1, "Value of option '%s' not valid. Should be a boolean (yes,no,on,off,true,false,0,1)", val);
 773   xbt_dynar_set(variable->content, 0, &bval);
 774
 775   if (variable->cb_set)
 776     variable->cb_set(name);
 777   variable->isdefault = false;
 778 }
 779
 780
 781 /* Say if the value is the default value */
 782 int xbt_cfg_is_default_value(const char *name)
 783 {
 784   xbt_cfgelm_t variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_any);
 785   return variable->isdefault;
 786 }
 787
 788 /*----[ Getting ]---------------------------------------------------------*/
 789 /** @brief Retrieve an integer value of a variable (get a warning if not uniq)
 790  *
 791  * @param name the name of the variable
 792  *
 793  * Returns the first value from the config set under the given name.
 794  * If there is more than one value, it will issue a warning. Consider using xbt_cfg_get_dynar() instead.
 795  */
 796 int xbt_cfg_get_int(const char *name)
 797 {
 798   xbt_cfgelm_t variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_int);
 799
 800   if (xbt_dynar_length(variable->content) > 1) {
 801     XBT_WARN("You asked for the first value of the config element '%s', but there is %lu values",
 802          name, xbt_dynar_length(variable->content));
 803   }
 804
 805   return xbt_dynar_get_as(variable->content, 0, int);
 806 }
 807
 808 /** @brief Retrieve a double value of a variable (get a warning if not uniq)
 809  *
 810  * @param cfg the config set
 811  * @param name the name of the variable
 812  *
 813  * Returns the first value from the config set under the given name.
 814  * If there is more than one value, it will issue a warning. Consider using xbt_cfg_get_dynar() instead.
 815  */
 816 double xbt_cfg_get_double(const char *name)
 817 {
 818   xbt_cfgelm_t variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_double);
 819
 820   if (xbt_dynar_length(variable->content) > 1) {
 821     XBT_WARN ("You asked for the first value of the config element '%s', but there is %lu values\n",
 822          name, xbt_dynar_length(variable->content));
 823   }
 824
 825   return xbt_dynar_get_as(variable->content, 0, double);
 826 }
 827
 828 /** @brief Retrieve a string value of a variable (get a warning if not uniq)
 829  *
 830  * @param cfg the config set
 831  * @param name the name of the variable
 832  *
 833  * Returns the first value from the config set under the given name.
 834  * If there is more than one value, it will issue a warning. Consider using
 835  * xbt_cfg_get_dynar() instead. Returns NULL if there is no value.
 836  *
 837  * \warning the returned value is the actual content of the config set
 838  */
 839 char *xbt_cfg_get_string(const char *name)
 840 {
 841   xbt_cfgelm_t variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_string);
 842
 843   if (xbt_dynar_length(variable->content) > 1) {
 844     XBT_WARN("You asked for the first value of the config element '%s', but there is %lu values\n",
 845          name, xbt_dynar_length(variable->content));
 846   } else if (xbt_dynar_is_empty(variable->content)) {
 847     return NULL;
 848   }
 849
 850   return xbt_dynar_get_as(variable->content, 0, char *);
 851 }
 852
 853 /** @brief Retrieve a boolean value of a variable (get a warning if not uniq)
 854  *
 855  * @param cfg the config set
 856  * @param name the name of the variable
 857  *
 858  * Returns the first value from the config set under the given name.
 859  * If there is more than one value, it will issue a warning. Consider using xbt_cfg_get_dynar() instead.
 860  */
 861 int xbt_cfg_get_boolean(const char *name)
 862 {
 863   xbt_cfgelm_t variable = xbt_cfgelm_get(simgrid_config, name, xbt_cfgelm_boolean);
 864
 865   if (xbt_dynar_length(variable->content) > 1) {
 866     XBT_WARN("You asked for the first value of the config element '%s', but there is %lu values",
 867          name, xbt_dynar_length(variable->content));
 868   }
 869
 870   return xbt_dynar_get_as(variable->content, 0, int);
 871 }
 872
 873 namespace simgrid {
 874 namespace config {
 875
 876 bool parseBool(const char* value)
 877 {
 878   for (int i = 0; xbt_cfgelm_boolean_values[i].true_val != NULL; i++) {
 879     if (std::strcmp(value, xbt_cfgelm_boolean_values[i].true_val) == 0)
 880       return true;
 881     if (std::strcmp(value, xbt_cfgelm_boolean_values[i].false_val) == 0)
 882       return false;
 883   }
 884   throw std::range_error("not a boolean");
 885 }
 886
 887 double parseDouble(const char* value)
 888 {
 889   char* end;
 890   errno = 0;
 891   double res = std::strtod(value, &end);
 892   if (errno == ERANGE)
 893     throw std::range_error("out of range");
 894   else if (errno)
 895     xbt_die("Unexpected errno");
 896   if (end == value || *end != '\0')
 897     throw std::range_error("invalid double");
 898   else
 899     return res;
 900 }
 901
 902 long int parseLong(const char* value)
 903 {
 904   char* end;
 905   errno = 0;
 906   long int res = std::strtol(value, &end, 0);
 907   if (errno) {
 908     if (res == LONG_MIN && errno == ERANGE)
 909       throw std::range_error("underflow");
 910     else if (res == LONG_MAX && errno == ERANGE)
 911       throw std::range_error("overflow");
 912     xbt_die("Unexpected errno");
 913   }
 914   if (end == value || *end != '\0')
 915     throw std::range_error("invalid integer");
 916   else
 917     return res;
 918 }
 919
 920 void declareFlag(const char* name, const char* description,
 921   std::function<void(const char* value)> callback)
 922 {
 923   xbt_cfg_register(&simgrid_config, name, description, xbt_cfgelm_string, NULL,
 924     std::move(callback));
 925 }
 926
 927 }
 928 }
 929
 930 #ifdef SIMGRID_TEST
 931
 932 #include <string>
 933
 934 #include "xbt.h"
 935 #include "xbt/ex.h"
 936
 937 #include <xbt/config.hpp>
 938
 939 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(xbt_cfg);
 940
 941 XBT_TEST_SUITE("config", "Configuration support");
 942
 943 static xbt_cfg_t make_set()
 944 {
 945   xbt_cfg_t set = NULL;
 946
 947   xbt_log_threshold_set(&_XBT_LOGV(xbt_cfg), xbt_log_priority_critical);
 948   xbt_cfg_register_str(&set, "speed:int");
 949   xbt_cfg_register_str(&set, "peername:string");
 950   xbt_cfg_register_str(&set, "user:string");
 951
 952   return set;
 953 }                               /* end_of_make_set */
 954
 955 XBT_PUBLIC_DATA(xbt_cfg_t) simgrid_config;
 956
 957 XBT_TEST_UNIT("memuse", test_config_memuse, "Alloc and free a config set")
 958 {
 959   simgrid_config = make_set();
 960   xbt_test_add("Alloc and free a config set");
 961   xbt_cfg_set_parse("peername:veloce user:bidule");
 962   xbt_cfg_free(&simgrid_config);
 963 }
 964
 965 XBT_TEST_UNIT("use", test_config_use, "Data retrieving tests")
 966 {
 967   simgrid_config = make_set();
 968   xbt_test_add("Get a single value");
 969   {
 970     /* get_single_value */
 971     int ival;
 972
 973     xbt_cfg_set_parse("peername:toto:42 speed:42");
 974     ival = xbt_cfg_get_int("speed");
 975     if (ival != 42)
 976       xbt_test_fail("Speed value = %d, I expected 42", ival);
 977   }
 978
 979   xbt_test_add("Access to a non-existant entry");
 980   {
 981     xbt_ex_t e;
 982
 983     TRY {
 984       xbt_cfg_set_parse("color:blue");
 985     } CATCH(e) {
 986       if (e.category != not_found_error)
 987         xbt_test_exception(e);
 988       xbt_ex_free(e);
 989     }
 990   }
 991   xbt_cfg_free(&simgrid_config);
 992 }
 993
 994 XBT_TEST_UNIT("c++flags", test_config_cxx_flags, "C++ flags")
 995 {
 996   simgrid_config = make_set();
 997   xbt_test_add("C++ declaration of flags");
 998
 999   simgrid::config::Flag<int> int_flag("int", "", 0);
1000   simgrid::config::Flag<std::string> string_flag("string", "", "foo");
1001   simgrid::config::Flag<double> double_flag("double", "", 0.32);
1002   simgrid::config::Flag<bool> bool_flag1("bool1", "", false);
1003   simgrid::config::Flag<bool> bool_flag2("bool2", "", true);
1004
1005   xbt_test_add("Parse values");
1006   xbt_cfg_set_parse("int:42 string:bar double:8.0 bool1:true bool2:false");
1007   xbt_test_assert(int_flag == 42, "Check int flag");
1008   xbt_test_assert(string_flag == "bar", "Check string flag");
1009   xbt_test_assert(double_flag == 8.0, "Check double flag");
1010   xbt_test_assert(bool_flag1, "Check bool1 flag");
1011   xbt_test_assert(!bool_flag2, "Check bool2 flag");
1012
1013   xbt_cfg_free(&simgrid_config);
1014 }
1015
1016 #endif                          /* SIMGRID_TEST */