This source file includes following definitions.
- mca_base_var_source_file
- mca_base_var_generate_full_name4
- compare_strings
- append_filename_to_list
- mca_base_var_init
- process_env_list
- mca_base_var_process_env_list
- mca_base_var_process_env_list_from_file
- resolve_relative_paths
- mca_base_var_cache_files
- mca_base_var_get_value
- var_set_string
- int_from_string
- var_set_from_string
- mca_base_var_set_value
- mca_base_var_deregister
- var_get
- mca_base_var_env_name
- var_find_by_name
- var_find
- mca_base_var_find
- mca_base_var_find_by_name
- mca_base_var_set_flag
- mca_base_var_get
- mca_base_var_build_env
- mca_base_var_finalize
- fixup_files
- read_files
- register_variable
- mca_base_var_register
- mca_base_component_var_register
- mca_base_framework_var_register
- mca_base_var_register_synonym
- var_get_env
- var_set_from_env
- var_set_from_file
- var_set_initial
- var_constructor
- var_destructor
- fv_constructor
- fv_destructor
- source_name
- var_value_string
- mca_base_var_check_exclusive
- mca_base_var_get_count
- mca_base_var_dump
   1 
   2 
   3 
   4 
   5 
   6 
   7 
   8 
   9 
  10 
  11 
  12 
  13 
  14 
  15 
  16 
  17 
  18 
  19 
  20 
  21 
  22 
  23 
  24 
  25 
  26 
  27 
  28 
  29 
  30 #include "opal_config.h"
  31 
  32 #include <stdio.h>
  33 #include <string.h>
  34 #include <stdlib.h>
  35 #ifdef HAVE_UNISTD_H
  36 #include <unistd.h>
  37 #endif
  38 #ifdef HAVE_SYS_PARAM_H
  39 #include <sys/param.h>
  40 #endif
  41 #include <errno.h>
  42 
  43 #include "opal/include/opal_stdint.h"
  44 #include "opal/mca/installdirs/installdirs.h"
  45 #include "opal/util/os_path.h"
  46 #include "opal/util/path.h"
  47 #include "opal/util/show_help.h"
  48 #include "opal/util/printf.h"
  49 #include "opal/util/argv.h"
  50 #include "opal/mca/mca.h"
  51 #include "opal/mca/base/mca_base_vari.h"
  52 #include "opal/constants.h"
  53 #include "opal/util/output.h"
  54 #include "opal/util/opal_environ.h"
  55 #include "opal/runtime/opal.h"
  56 
  57 
  58 
  59 
  60 static opal_pointer_array_t mca_base_vars;
  61 static const char *mca_prefix = OPAL_MCA_PREFIX;
  62 static char *home = NULL;
  63 static char *cwd  = NULL;
  64 bool mca_base_var_initialized = false;
  65 static char * force_agg_path = NULL;
  66 static char *mca_base_var_files = NULL;
  67 static char *mca_base_envar_files = NULL;
  68 static char **mca_base_var_file_list = NULL;
  69 static char *mca_base_var_override_file = NULL;
  70 static char *mca_base_var_file_prefix = NULL;
  71 static char *mca_base_envar_file_prefix = NULL;
  72 static char *mca_base_param_file_path = NULL;
  73 char *mca_base_env_list = NULL;
  74 char *mca_base_env_list_sep = MCA_BASE_ENV_LIST_SEP_DEFAULT;
  75 char *mca_base_env_list_internal = NULL;
  76 static bool mca_base_var_suppress_override_warning = false;
  77 static opal_list_t mca_base_var_file_values;
  78 static opal_list_t mca_base_envar_file_values;
  79 static opal_list_t mca_base_var_override_values;
  80 
  81 static int mca_base_var_count = 0;
  82 
  83 static opal_hash_table_t mca_base_var_index_hash;
  84 
  85 const char *ompi_var_type_names[] = {
  86     "int",
  87     "unsigned_int",
  88     "unsigned_long",
  89     "unsigned_long_long",
  90     "size_t",
  91     "string",
  92     "version_string",
  93     "bool",
  94     "double",
  95     "long",
  96     "int32_t",
  97     "uint32_t",
  98     "int64_t",
  99     "uint64_t",
 100 };
 101 
 102 const size_t ompi_var_type_sizes[] = {
 103     sizeof (int),
 104     sizeof (unsigned),
 105     sizeof (unsigned long),
 106     sizeof (unsigned long long),
 107     sizeof (size_t),
 108     sizeof (char),
 109     sizeof (char),
 110     sizeof (bool),
 111     sizeof (double),
 112     sizeof (long),
 113     sizeof (int32_t),
 114     sizeof (uint32_t),
 115     sizeof (int64_t),
 116     sizeof (uint64_t),
 117 };
 118 
 119 static const char *var_source_names[] = {
 120     "default",
 121     "command line",
 122     "environment",
 123     "file",
 124     "set",
 125     "override"
 126 };
 127 
 128 
 129 static const char *info_lvl_strings[] = {
 130     "user/basic",
 131     "user/detail",
 132     "user/all",
 133     "tuner/basic",
 134     "tuner/detail",
 135     "tuner/all",
 136     "dev/basic",
 137     "dev/detail",
 138     "dev/all"
 139 };
 140 
 141 
 142 
 143 
 144 static int fixup_files(char **file_list, char * path, bool rel_path_search, char sep);
 145 static int read_files (char *file_list, opal_list_t *file_values, char sep);
 146 static int var_set_initial (mca_base_var_t *var, mca_base_var_t *original);
 147 static int var_get (int vari, mca_base_var_t **var_out, bool original);
 148 static int var_value_string (mca_base_var_t *var, char **value_string);
 149 static void mca_base_var_finalize (void);
 150 
 151 
 152 
 153 
 154 static void var_constructor (mca_base_var_t *p);
 155 static void var_destructor (mca_base_var_t *p);
 156 OBJ_CLASS_INSTANCE(mca_base_var_t, opal_object_t,
 157                    var_constructor, var_destructor);
 158 
 159 static void fv_constructor (mca_base_var_file_value_t *p);
 160 static void fv_destructor (mca_base_var_file_value_t *p);
 161 OBJ_CLASS_INSTANCE(mca_base_var_file_value_t, opal_list_item_t,
 162                    fv_constructor, fv_destructor);
 163 
 164 static const char *mca_base_var_source_file (const mca_base_var_t *var)
 165 {
 166     mca_base_var_file_value_t *fv = (mca_base_var_file_value_t *) var->mbv_file_value;
 167 
 168     if (NULL != var->mbv_source_file) {
 169         return var->mbv_source_file;
 170     }
 171 
 172     if (fv) {
 173         return fv->mbvfv_file;
 174     }
 175 
 176     return NULL;
 177 }
 178 
 179 
 180 
 181 
 182 int mca_base_var_generate_full_name4 (const char *project, const char *framework, const char *component,
 183                                       const char *variable, char **full_name)
 184 {
 185     const char * const names[] = {project, framework, component, variable};
 186     char *name, *tmp;
 187     size_t i, len;
 188 
 189     *full_name = NULL;
 190 
 191     for (i = 0, len = 0 ; i < 4 ; ++i) {
 192         if (NULL != names[i]) {
 193             
 194             len += strlen (names[i]) + 1;
 195         }
 196     }
 197 
 198     name = calloc (1, len);
 199     if (NULL == name) {
 200         return OPAL_ERR_OUT_OF_RESOURCE;
 201     }
 202 
 203     for (i = 0, tmp = name ; i < 4 ; ++i) {
 204         if (NULL != names[i]) {
 205             if (name != tmp) {
 206                 *tmp++ = '_';
 207             }
 208             strncat (name, names[i], len - (size_t)(uintptr_t)(tmp - name));
 209             tmp += strlen (names[i]);
 210         }
 211     }
 212 
 213     *full_name = name;
 214     return OPAL_SUCCESS;
 215 }
 216 
 217 static int compare_strings (const char *str1, const char *str2) {
 218     if ((NULL != str1 && 0 == strcmp (str1, "*")) ||
 219         (NULL == str1 && NULL == str2)) {
 220         return 0;
 221     }
 222 
 223     if (NULL != str1 && NULL != str2) {
 224         return strcmp (str1, str2);
 225     }
 226 
 227     return 1;
 228 }
 229 
 230 
 231 
 232 
 233 
 234 static char *append_filename_to_list(const char *filename)
 235 {
 236     int i, count;
 237 
 238     (void) opal_argv_append_unique_nosize(&mca_base_var_file_list, filename, false);
 239 
 240     count = opal_argv_count(mca_base_var_file_list);
 241 
 242     for (i = count - 1; i >= 0; --i) {
 243         if (0 == strcmp (mca_base_var_file_list[i], filename)) {
 244             return mca_base_var_file_list[i];
 245         }
 246     }
 247 
 248     
 249     return NULL;
 250 }
 251 
 252 
 253 
 254 
 255 int mca_base_var_init(void)
 256 {
 257     int ret;
 258 
 259     if (!mca_base_var_initialized) {
 260         
 261 
 262         OBJ_CONSTRUCT(&mca_base_vars, opal_pointer_array_t);
 263         
 264         ret = opal_pointer_array_init (&mca_base_vars, 128, 16384, 128);
 265         if (OPAL_SUCCESS != ret) {
 266             return ret;
 267         }
 268 
 269         mca_base_var_count = 0;
 270 
 271         
 272 
 273         OBJ_CONSTRUCT(&mca_base_var_file_values, opal_list_t);
 274         OBJ_CONSTRUCT(&mca_base_envar_file_values, opal_list_t);
 275         OBJ_CONSTRUCT(&mca_base_var_override_values, opal_list_t);
 276         OBJ_CONSTRUCT(&mca_base_var_index_hash, opal_hash_table_t);
 277 
 278         ret = opal_hash_table_init (&mca_base_var_index_hash, 1024);
 279         if (OPAL_SUCCESS != ret) {
 280             return ret;
 281         }
 282 
 283         ret = mca_base_var_group_init ();
 284         if  (OPAL_SUCCESS != ret) {
 285             return ret;
 286         }
 287 
 288         ret = mca_base_pvar_init ();
 289         if (OPAL_SUCCESS != ret) {
 290             return ret;
 291         }
 292 
 293         
 294 
 295         mca_base_var_initialized = true;
 296 
 297     }
 298 
 299     opal_finalize_register_cleanup (mca_base_var_finalize);
 300 
 301     return OPAL_SUCCESS;
 302 }
 303 
 304 static void process_env_list(char *env_list, char ***argv, char sep)
 305 {
 306     char** tokens;
 307     char *ptr, *value;
 308 
 309     tokens = opal_argv_split(env_list, (int)sep);
 310     if (NULL == tokens) {
 311         return;
 312     }
 313 
 314     for (int i = 0 ; NULL != tokens[i] ; ++i) {
 315         if (NULL == (ptr = strchr(tokens[i], '='))) {
 316             value = getenv(tokens[i]);
 317             if (NULL == value) {
 318                 opal_show_help("help-mca-var.txt", "incorrect-env-list-param",
 319                                true, tokens[i], env_list);
 320                 break;
 321             }
 322 
 323             
 324             value = strdup (value);
 325             if (NULL == value) {
 326                 
 327                 break;
 328             }
 329 
 330             if (NULL != (ptr = strchr(value, '='))) {
 331                 *ptr = '\0';
 332                 opal_setenv(value, ptr + 1, true, argv);
 333             } else {
 334                 opal_setenv(tokens[i], value, true, argv);
 335             }
 336 
 337             free (value);
 338         } else {
 339             *ptr = '\0';
 340             opal_setenv(tokens[i], ptr + 1, true, argv);
 341             
 342         }
 343     }
 344 
 345     opal_argv_free(tokens);
 346 }
 347 
 348 int mca_base_var_process_env_list(char *list, char ***argv)
 349 {
 350     char sep;
 351     sep = ';';
 352     if (NULL != mca_base_env_list_sep) {
 353         if (1 == strlen(mca_base_env_list_sep)) {
 354             sep = mca_base_env_list_sep[0];
 355         } else {
 356             opal_show_help("help-mca-var.txt", "incorrect-env-list-sep",
 357                     true, mca_base_env_list_sep);
 358             return OPAL_SUCCESS;
 359         }
 360     }
 361     if (NULL != list) {
 362         process_env_list(list, argv, sep);
 363     } else if (NULL != mca_base_env_list) {
 364         process_env_list(mca_base_env_list, argv, sep);
 365     }
 366 
 367     return OPAL_SUCCESS;
 368 }
 369 
 370 int mca_base_var_process_env_list_from_file(char ***argv)
 371 {
 372     if (NULL != mca_base_env_list_internal) {
 373         process_env_list(mca_base_env_list_internal, argv, ';');
 374     }
 375     return OPAL_SUCCESS;
 376 }
 377 
 378 static void resolve_relative_paths(char **file_prefix, char *file_path, bool rel_path_search, char **files, char sep)
 379 {
 380     char *tmp_str;
 381     
 382 
 383 
 384 
 385     if( OPAL_SUCCESS != fixup_files(file_prefix, file_path, rel_path_search, sep) ) {
 386 #if 0
 387         
 388         abort();
 389 #else
 390         ;
 391 #endif
 392     }
 393     else {
 394         
 395         opal_asprintf(&tmp_str, "%s%c%s", *file_prefix, sep, *files);
 396         free (*files);
 397         *files = tmp_str;
 398     }
 399 }
 400 
 401 int mca_base_var_cache_files(bool rel_path_search)
 402 {
 403     char *tmp;
 404     int ret;
 405 
 406     
 407     home = (char*)opal_home_directory();
 408 
 409     if (NULL == cwd) {
 410         cwd = (char *) malloc(sizeof(char) * MAXPATHLEN);
 411         if( NULL == (cwd = getcwd(cwd, MAXPATHLEN) )) {
 412             opal_output(0, "Error: Unable to get the current working directory\n");
 413             cwd = strdup(".");
 414         }
 415     }
 416 
 417 #if OPAL_WANT_HOME_CONFIG_FILES
 418     opal_asprintf(&mca_base_var_files, "%s"OPAL_PATH_SEP".openmpi" OPAL_PATH_SEP
 419              "mca-params.conf%c%s" OPAL_PATH_SEP "openmpi-mca-params.conf",
 420              home, ',', opal_install_dirs.sysconfdir);
 421 #else
 422     opal_asprintf(&mca_base_var_files, "%s" OPAL_PATH_SEP "openmpi-mca-params.conf",
 423              opal_install_dirs.sysconfdir);
 424 #endif
 425 
 426     
 427 
 428     tmp = mca_base_var_files;
 429     ret = mca_base_var_register ("opal", "mca", "base", "param_files", "Path for MCA "
 430                                  "configuration files containing variable values",
 431                                  MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0, OPAL_INFO_LVL_2,
 432                                  MCA_BASE_VAR_SCOPE_READONLY, &mca_base_var_files);
 433     free (tmp);
 434     if (0 > ret) {
 435         return ret;
 436     }
 437 
 438     mca_base_envar_files = strdup(mca_base_var_files);
 439 
 440     (void) mca_base_var_register_synonym (ret, "opal", "mca", NULL, "param_files",
 441                                           MCA_BASE_VAR_SYN_FLAG_DEPRECATED);
 442 
 443     ret = opal_asprintf(&mca_base_var_override_file, "%s" OPAL_PATH_SEP "openmpi-mca-params-override.conf",
 444                    opal_install_dirs.sysconfdir);
 445     if (0 > ret) {
 446         return OPAL_ERR_OUT_OF_RESOURCE;
 447     }
 448 
 449     tmp = mca_base_var_override_file;
 450     ret = mca_base_var_register ("opal", "mca", "base", "override_param_file",
 451                                  "Variables set in this file will override any value set in"
 452                                  "the environment or another configuration file",
 453                                  MCA_BASE_VAR_TYPE_STRING, NULL, 0, MCA_BASE_VAR_FLAG_DEFAULT_ONLY,
 454                                  OPAL_INFO_LVL_2, MCA_BASE_VAR_SCOPE_CONSTANT,
 455                                  &mca_base_var_override_file);
 456     free (tmp);
 457     if (0 > ret) {
 458         return ret;
 459     }
 460 
 461     
 462     if (0 == strcmp (mca_base_var_files, "none")) {
 463         return OPAL_SUCCESS;
 464     }
 465 
 466     mca_base_var_suppress_override_warning = false;
 467     ret = mca_base_var_register ("opal", "mca", "base", "suppress_override_warning",
 468                                  "Suppress warnings when attempting to set an overridden value (default: false)",
 469                                  MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0, OPAL_INFO_LVL_2,
 470                                  MCA_BASE_VAR_SCOPE_LOCAL, &mca_base_var_suppress_override_warning);
 471     if (0 > ret) {
 472         return ret;
 473     }
 474 
 475     
 476 
 477 
 478 
 479     mca_base_var_file_prefix = NULL;
 480     ret = mca_base_var_register ("opal", "mca", "base", "param_file_prefix",
 481                                  "Aggregate MCA parameter file sets",
 482                                  MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0, OPAL_INFO_LVL_3,
 483                                  MCA_BASE_VAR_SCOPE_READONLY, &mca_base_var_file_prefix);
 484     if (0 > ret) {
 485         return ret;
 486     }
 487 
 488     mca_base_envar_file_prefix = NULL;
 489     ret = mca_base_var_register ("opal", "mca", "base", "envar_file_prefix",
 490                                  "Aggregate MCA parameter file set for env variables",
 491                                  MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0, OPAL_INFO_LVL_3,
 492                                  MCA_BASE_VAR_SCOPE_READONLY, &mca_base_envar_file_prefix);
 493     if (0 > ret) {
 494         return ret;
 495     }
 496 
 497     ret = opal_asprintf(&mca_base_param_file_path, "%s" OPAL_PATH_SEP "amca-param-sets%c%s",
 498                    opal_install_dirs.opaldatadir, OPAL_ENV_SEP, cwd);
 499     if (0 > ret) {
 500         return OPAL_ERR_OUT_OF_RESOURCE;
 501     }
 502 
 503     tmp = mca_base_param_file_path;
 504     ret = mca_base_var_register ("opal", "mca", "base", "param_file_path",
 505                                  "Aggregate MCA parameter Search path",
 506                                  MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0, OPAL_INFO_LVL_3,
 507                                  MCA_BASE_VAR_SCOPE_READONLY, &mca_base_param_file_path);
 508     free (tmp);
 509     if (0 > ret) {
 510         return ret;
 511     }
 512 
 513     force_agg_path = NULL;
 514     ret = mca_base_var_register ("opal", "mca", "base", "param_file_path_force",
 515                                  "Forced Aggregate MCA parameter Search path",
 516                                  MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0, OPAL_INFO_LVL_3,
 517                                  MCA_BASE_VAR_SCOPE_READONLY, &force_agg_path);
 518     if (0 > ret) {
 519         return ret;
 520     }
 521 
 522     if (NULL != force_agg_path) {
 523         if (NULL != mca_base_param_file_path) {
 524             char *tmp_str = mca_base_param_file_path;
 525 
 526             opal_asprintf(&mca_base_param_file_path, "%s%c%s", force_agg_path, OPAL_ENV_SEP, tmp_str);
 527             free(tmp_str);
 528         } else {
 529             mca_base_param_file_path = strdup(force_agg_path);
 530         }
 531     }
 532 
 533     if (NULL != mca_base_var_file_prefix) {
 534        resolve_relative_paths(&mca_base_var_file_prefix, mca_base_param_file_path, rel_path_search, &mca_base_var_files, OPAL_ENV_SEP);
 535     }
 536     read_files (mca_base_var_files, &mca_base_var_file_values, ',');
 537 
 538     if (NULL != mca_base_envar_file_prefix) {
 539        resolve_relative_paths(&mca_base_envar_file_prefix, mca_base_param_file_path, rel_path_search, &mca_base_envar_files, ',');
 540     }
 541     read_files (mca_base_envar_files, &mca_base_envar_file_values, ',');
 542 
 543     if (0 == access(mca_base_var_override_file, F_OK)) {
 544         read_files (mca_base_var_override_file, &mca_base_var_override_values, OPAL_ENV_SEP);
 545     }
 546 
 547     return OPAL_SUCCESS;
 548 }
 549 
 550 
 551 
 552 
 553 int mca_base_var_get_value (int vari, const void *value,
 554                             mca_base_var_source_t *source,
 555                             const char **source_file)
 556 {
 557     mca_base_var_t *var;
 558     void **tmp = (void **) value;
 559     int ret;
 560 
 561     ret = var_get (vari, &var, true);
 562     if (OPAL_SUCCESS != ret) {
 563         return ret;
 564     }
 565 
 566     if (!VAR_IS_VALID(var[0])) {
 567         return OPAL_ERR_NOT_FOUND;
 568     }
 569 
 570     if (NULL != value) {
 571         
 572 
 573         *tmp = var->mbv_storage;
 574     }
 575 
 576     if (NULL != source) {
 577         *source = var->mbv_source;
 578     }
 579 
 580     if (NULL != source_file) {
 581         *source_file = mca_base_var_source_file (var);
 582     }
 583 
 584     return OPAL_SUCCESS;
 585 }
 586 
 587 static int var_set_string (mca_base_var_t *var, char *value)
 588 {
 589     char *tmp;
 590     int ret;
 591 
 592     if (NULL != var->mbv_storage->stringval) {
 593         free (var->mbv_storage->stringval);
 594     }
 595 
 596     var->mbv_storage->stringval = NULL;
 597 
 598     if (NULL == value || 0 == strlen (value)) {
 599         return OPAL_SUCCESS;
 600     }
 601 
 602     
 603 
 604 
 605     if (0 == strncmp (value, "~/", 2)) {
 606         if (NULL != home) {
 607             ret = opal_asprintf (&value, "%s/%s", home, value + 2);
 608             if (0 > ret) {
 609                 return OPAL_ERROR;
 610             }
 611         } else {
 612             value = strdup (value + 2);
 613         }
 614     } else {
 615         value = strdup (value);
 616     }
 617 
 618     if (NULL == value) {
 619         return OPAL_ERR_OUT_OF_RESOURCE;
 620     }
 621 
 622     while (NULL != (tmp = strstr (value, ":~/"))) {
 623         tmp[0] = '\0';
 624         tmp += 3;
 625 
 626         ret = opal_asprintf (&tmp, "%s:%s%s%s", value,
 627                         home ? home : "", home ? "/" : "", tmp);
 628 
 629         free (value);
 630 
 631         if (0 > ret) {
 632             return OPAL_ERR_OUT_OF_RESOURCE;
 633         }
 634 
 635         value = tmp;
 636     }
 637 
 638     var->mbv_storage->stringval = value;
 639 
 640     return OPAL_SUCCESS;
 641 }
 642 
 643 static int int_from_string(const char *src, mca_base_var_enum_t *enumerator, uint64_t *value_out)
 644 {
 645     uint64_t value;
 646     bool is_int;
 647     char *tmp;
 648 
 649     if (NULL == src || 0 == strlen (src)) {
 650         if (NULL == enumerator) {
 651             *value_out = 0;
 652         }
 653 
 654         return OPAL_SUCCESS;
 655     }
 656 
 657     if (enumerator) {
 658         int int_val, ret;
 659         ret = enumerator->value_from_string(enumerator, src, &int_val);
 660         if (OPAL_SUCCESS != ret) {
 661             return ret;
 662         }
 663         *value_out = (uint64_t) int_val;
 664 
 665         return OPAL_SUCCESS;
 666     }
 667 
 668     
 669     value = strtoull (src, &tmp, 0);
 670     is_int = tmp[0] == '\0';
 671 
 672     if (!is_int && tmp != src) {
 673         switch (tmp[0]) {
 674         case 'G':
 675         case 'g':
 676             value <<= 10;
 677         case 'M':
 678         case 'm':
 679             value <<= 10;
 680         case 'K':
 681         case 'k':
 682             value <<= 10;
 683             break;
 684         default:
 685             break;
 686         }
 687     }
 688 
 689     *value_out = value;
 690 
 691     return OPAL_SUCCESS;
 692 }
 693 
 694 static int var_set_from_string (mca_base_var_t *var, char *src)
 695 {
 696     mca_base_var_storage_t *dst = var->mbv_storage;
 697     uint64_t int_value = 0;
 698     int ret;
 699 
 700     switch (var->mbv_type) {
 701     case MCA_BASE_VAR_TYPE_INT:
 702     case MCA_BASE_VAR_TYPE_INT32_T:
 703     case MCA_BASE_VAR_TYPE_UINT32_T:
 704     case MCA_BASE_VAR_TYPE_LONG:
 705     case MCA_BASE_VAR_TYPE_UNSIGNED_INT:
 706     case MCA_BASE_VAR_TYPE_UNSIGNED_LONG:
 707     case MCA_BASE_VAR_TYPE_INT64_T:
 708     case MCA_BASE_VAR_TYPE_UINT64_T:
 709     case MCA_BASE_VAR_TYPE_UNSIGNED_LONG_LONG:
 710     case MCA_BASE_VAR_TYPE_BOOL:
 711     case MCA_BASE_VAR_TYPE_SIZE_T:
 712         ret = int_from_string(src, var->mbv_enumerator, &int_value);
 713         if (OPAL_SUCCESS != ret ||
 714             (MCA_BASE_VAR_TYPE_INT == var->mbv_type && ((int) int_value != (int64_t) int_value)) ||
 715             (MCA_BASE_VAR_TYPE_UNSIGNED_INT == var->mbv_type && ((unsigned int) int_value != int_value))) {
 716             if (var->mbv_enumerator) {
 717                 char *valid_values;
 718                 (void) var->mbv_enumerator->dump(var->mbv_enumerator, &valid_values);
 719                 opal_show_help("help-mca-var.txt", "invalid-value-enum",
 720                                true, var->mbv_full_name, src, valid_values);
 721                 free(valid_values);
 722             } else {
 723                 opal_show_help("help-mca-var.txt", "invalid-value",
 724                                true, var->mbv_full_name, src);
 725             }
 726 
 727             return OPAL_ERR_VALUE_OUT_OF_BOUNDS;
 728         }
 729 
 730         if (MCA_BASE_VAR_TYPE_INT == var->mbv_type ||
 731             MCA_BASE_VAR_TYPE_UNSIGNED_INT == var->mbv_type) {
 732             int *castme = (int*) var->mbv_storage;
 733             *castme = int_value;
 734         } else if (MCA_BASE_VAR_TYPE_INT32_T == var->mbv_type ||
 735             MCA_BASE_VAR_TYPE_UINT32_T == var->mbv_type) {
 736             int32_t *castme = (int32_t *) var->mbv_storage;
 737             *castme = int_value;
 738         } else if (MCA_BASE_VAR_TYPE_INT64_T == var->mbv_type ||
 739             MCA_BASE_VAR_TYPE_UINT64_T == var->mbv_type) {
 740             int64_t *castme = (int64_t *) var->mbv_storage;
 741             *castme = int_value;
 742         } else if (MCA_BASE_VAR_TYPE_LONG == var->mbv_type) {
 743             long *castme = (long*) var->mbv_storage;
 744             *castme = (long) int_value;
 745         } else if (MCA_BASE_VAR_TYPE_UNSIGNED_LONG == var->mbv_type) {
 746             unsigned long *castme = (unsigned long*) var->mbv_storage;
 747             *castme = (unsigned long) int_value;
 748         } else if (MCA_BASE_VAR_TYPE_UNSIGNED_LONG_LONG == var->mbv_type) {
 749             unsigned long long *castme = (unsigned long long*) var->mbv_storage;
 750             *castme = (unsigned long long) int_value;
 751         } else if (MCA_BASE_VAR_TYPE_SIZE_T == var->mbv_type) {
 752             size_t *castme = (size_t*) var->mbv_storage;
 753             *castme = (size_t) int_value;
 754         } else if (MCA_BASE_VAR_TYPE_BOOL == var->mbv_type) {
 755             bool *castme = (bool*) var->mbv_storage;
 756             *castme = !!int_value;
 757         }
 758 
 759         return ret;
 760     case MCA_BASE_VAR_TYPE_DOUBLE:
 761         dst->lfval = strtod (src, NULL);
 762         break;
 763     case MCA_BASE_VAR_TYPE_STRING:
 764     case MCA_BASE_VAR_TYPE_VERSION_STRING:
 765         var_set_string (var, src);
 766         break;
 767     case MCA_BASE_VAR_TYPE_MAX:
 768         return OPAL_ERROR;
 769     }
 770 
 771     return OPAL_SUCCESS;
 772 }
 773 
 774 
 775 
 776 
 777 int mca_base_var_set_value (int vari, const void *value, size_t size, mca_base_var_source_t source,
 778                             const char *source_file)
 779 {
 780     mca_base_var_t *var;
 781     int ret;
 782 
 783     ret = var_get (vari, &var, true);
 784     if (OPAL_SUCCESS != ret) {
 785         return ret;
 786     }
 787 
 788     if (!VAR_IS_VALID(var[0])) {
 789         return OPAL_ERR_BAD_PARAM;
 790     }
 791 
 792     if (!VAR_IS_SETTABLE(var[0])) {
 793         return OPAL_ERR_PERM;
 794     }
 795 
 796     if (NULL != var->mbv_enumerator) {
 797         
 798         ret = var->mbv_enumerator->string_from_value(var->mbv_enumerator,
 799                                                      ((int *) value)[0], NULL);
 800         if (OPAL_SUCCESS != ret) {
 801             return ret;
 802         }
 803     }
 804 
 805     if (MCA_BASE_VAR_TYPE_STRING != var->mbv_type && MCA_BASE_VAR_TYPE_VERSION_STRING != var->mbv_type) {
 806         memmove (var->mbv_storage, value, ompi_var_type_sizes[var->mbv_type]);
 807     } else {
 808         var_set_string (var, (char *) value);
 809     }
 810 
 811     var->mbv_source = source;
 812 
 813     if (MCA_BASE_VAR_SOURCE_FILE == source && NULL != source_file) {
 814         var->mbv_file_value = NULL;
 815         var->mbv_source_file = append_filename_to_list(source_file);
 816     }
 817 
 818     return OPAL_SUCCESS;
 819 }
 820 
 821 
 822 
 823 
 824 int mca_base_var_deregister(int vari)
 825 {
 826     mca_base_var_t *var;
 827     int ret;
 828 
 829     ret = var_get (vari, &var, false);
 830     if (OPAL_SUCCESS != ret) {
 831         return ret;
 832     }
 833 
 834     if (!VAR_IS_VALID(var[0])) {
 835         return OPAL_ERR_BAD_PARAM;
 836     }
 837 
 838     
 839 
 840     var->mbv_flags &= ~MCA_BASE_VAR_FLAG_VALID;
 841 
 842     
 843     if (MCA_BASE_VAR_FLAG_SYNONYM & var->mbv_flags) {
 844         return OPAL_SUCCESS;
 845     }
 846 
 847     
 848     if ((MCA_BASE_VAR_TYPE_STRING == var->mbv_type || MCA_BASE_VAR_TYPE_VERSION_STRING == var->mbv_type) &&
 849         var->mbv_storage->stringval) {
 850         free (var->mbv_storage->stringval);
 851         var->mbv_storage->stringval = NULL;
 852     } else if (var->mbv_enumerator && !var->mbv_enumerator->enum_is_static) {
 853         OBJ_RELEASE(var->mbv_enumerator);
 854     }
 855 
 856     var->mbv_enumerator = NULL;
 857 
 858     var->mbv_storage = NULL;
 859 
 860     return OPAL_SUCCESS;
 861 }
 862 
 863 static int var_get (int vari, mca_base_var_t **var_out, bool original)
 864 {
 865     mca_base_var_t *var;
 866 
 867     if (var_out) {
 868         *var_out = NULL;
 869     }
 870 
 871     
 872     if (!mca_base_var_initialized) {
 873         return OPAL_ERROR;
 874     }
 875 
 876     if (vari < 0) {
 877         return OPAL_ERR_BAD_PARAM;
 878     }
 879 
 880     var = opal_pointer_array_get_item (&mca_base_vars, vari);
 881     if (NULL == var) {
 882         return OPAL_ERR_BAD_PARAM;
 883     }
 884 
 885     if (VAR_IS_SYNONYM(var[0]) && original) {
 886         return var_get(var->mbv_synonym_for, var_out, false);
 887     }
 888 
 889     if (var_out) {
 890         *var_out = var;
 891     }
 892 
 893     return OPAL_SUCCESS;
 894 }
 895 
 896 int mca_base_var_env_name(const char *param_name,
 897                           char **env_name)
 898 {
 899     int ret;
 900 
 901     assert (NULL != env_name);
 902 
 903     ret = opal_asprintf(env_name, "%s%s", mca_prefix, param_name);
 904     if (0 > ret) {
 905         return OPAL_ERR_OUT_OF_RESOURCE;
 906     }
 907 
 908     return OPAL_SUCCESS;
 909 }
 910 
 911 
 912 
 913 
 914 static int var_find_by_name (const char *full_name, int *vari, bool invalidok)
 915 {
 916     mca_base_var_t *var = NULL;
 917     void *tmp;
 918     int rc;
 919 
 920     rc = opal_hash_table_get_value_ptr (&mca_base_var_index_hash, full_name, strlen (full_name),
 921                                         &tmp);
 922     if (OPAL_SUCCESS != rc) {
 923         return rc;
 924     }
 925 
 926     (void) var_get ((int)(uintptr_t) tmp, &var, false);
 927 
 928     if (invalidok || (var && VAR_IS_VALID(var[0]))) {
 929         *vari = (int)(uintptr_t) tmp;
 930         return OPAL_SUCCESS;
 931     }
 932 
 933     return OPAL_ERR_NOT_FOUND;
 934 }
 935 
 936 static int var_find (const char *project_name, const char *framework_name,
 937                      const char *component_name, const char *variable_name,
 938                      bool invalidok)
 939 {
 940     char *full_name;
 941     int ret, vari;
 942 
 943     ret = mca_base_var_generate_full_name4 (NULL, framework_name, component_name,
 944                                             variable_name, &full_name);
 945     if (OPAL_SUCCESS != ret) {
 946         return OPAL_ERROR;
 947     }
 948 
 949     ret = var_find_by_name(full_name, &vari, invalidok);
 950 
 951     
 952 
 953     free (full_name);
 954 
 955     if (OPAL_SUCCESS != ret) {
 956         return ret;
 957     }
 958 
 959     return vari;
 960 }
 961 
 962 
 963 
 964 
 965 int mca_base_var_find (const char *project_name, const char *framework_name,
 966                        const char *component_name, const char *variable_name)
 967 {
 968     return var_find (project_name, framework_name, component_name, variable_name, false);
 969 }
 970 
 971 
 972 
 973 
 974 int mca_base_var_find_by_name (const char *full_name, int *vari)
 975 {
 976     return var_find_by_name (full_name, vari, false);
 977 }
 978 
 979 int mca_base_var_set_flag (int vari, mca_base_var_flag_t flag, bool set)
 980 {
 981     mca_base_var_t *var;
 982     int ret;
 983 
 984     ret = var_get (vari, &var, true);
 985     if (OPAL_SUCCESS != ret || VAR_IS_SYNONYM(var[0])) {
 986         return OPAL_ERR_BAD_PARAM;
 987     }
 988 
 989     var->mbv_flags = (var->mbv_flags & ~flag) | (set ? flag : 0);
 990 
 991     
 992     return OPAL_SUCCESS;
 993 }
 994 
 995 
 996 
 997 
 998 int mca_base_var_get (int vari, const mca_base_var_t **var)
 999 {
1000     int ret;
1001     ret = var_get (vari, (mca_base_var_t **) var, false);
1002 
1003     if (OPAL_SUCCESS != ret) {
1004         return ret;
1005     }
1006 
1007     if (!VAR_IS_VALID(*(var[0]))) {
1008         return OPAL_ERR_NOT_FOUND;
1009     }
1010 
1011     return OPAL_SUCCESS;
1012 }
1013 
1014 
1015 
1016 
1017 int mca_base_var_build_env(char ***env, int *num_env, bool internal)
1018 {
1019     mca_base_var_t *var;
1020     size_t i, len;
1021     int ret;
1022 
1023     
1024 
1025     if (!mca_base_var_initialized) {
1026         return OPAL_ERROR;
1027     }
1028 
1029     
1030 
1031     len = opal_pointer_array_get_size(&mca_base_vars);
1032     for (i = 0; i < len; ++i) {
1033         char *value_string;
1034         char *str = NULL;
1035 
1036         var = opal_pointer_array_get_item (&mca_base_vars, i);
1037         if (NULL == var) {
1038             continue;
1039         }
1040 
1041         
1042 
1043         if (MCA_BASE_VAR_SOURCE_DEFAULT == var->mbv_source ||
1044             (!internal && VAR_IS_INTERNAL(var[0]))) {
1045             continue;
1046         }
1047 
1048         if ((MCA_BASE_VAR_TYPE_STRING == var->mbv_type || MCA_BASE_VAR_TYPE_VERSION_STRING == var->mbv_type) &&
1049             NULL == var->mbv_storage->stringval) {
1050             continue;
1051         }
1052 
1053         ret = var_value_string (var, &value_string);
1054         if (OPAL_SUCCESS != ret) {
1055             goto cleanup;
1056         }
1057 
1058         ret = opal_asprintf (&str, "%s%s=%s", mca_prefix, var->mbv_full_name,
1059                         value_string);
1060         free (value_string);
1061         if (0 > ret) {
1062             goto cleanup;
1063         }
1064 
1065         opal_argv_append(num_env, env, str);
1066         free(str);
1067 
1068         switch (var->mbv_source) {
1069         case MCA_BASE_VAR_SOURCE_FILE:
1070         case MCA_BASE_VAR_SOURCE_OVERRIDE:
1071             opal_asprintf (&str, "%sSOURCE_%s=FILE:%s", mca_prefix, var->mbv_full_name,
1072                       mca_base_var_source_file (var));
1073             break;
1074         case MCA_BASE_VAR_SOURCE_COMMAND_LINE:
1075             opal_asprintf (&str, "%sSOURCE_%s=COMMAND_LINE", mca_prefix, var->mbv_full_name);
1076             break;
1077         case MCA_BASE_VAR_SOURCE_ENV:
1078         case MCA_BASE_VAR_SOURCE_SET:
1079         case MCA_BASE_VAR_SOURCE_DEFAULT:
1080             str = NULL;
1081             break;
1082         case MCA_BASE_VAR_SOURCE_MAX:
1083             goto cleanup;
1084         }
1085 
1086         if (NULL != str) {
1087             opal_argv_append(num_env, env, str);
1088             free(str);
1089         }
1090     }
1091 
1092     
1093 
1094     return OPAL_SUCCESS;
1095 
1096     
1097 
1098  cleanup:
1099     if (*num_env > 0) {
1100         opal_argv_free(*env);
1101         *num_env = 0;
1102         *env = NULL;
1103     }
1104     return OPAL_ERR_NOT_FOUND;
1105 }
1106 
1107 
1108 
1109 
1110 
1111 static void mca_base_var_finalize (void)
1112 {
1113     opal_object_t *object;
1114     opal_list_item_t *item;
1115     int size, i;
1116 
1117     if (mca_base_var_initialized) {
1118         size = opal_pointer_array_get_size(&mca_base_vars);
1119         for (i = 0 ; i < size ; ++i) {
1120             object = opal_pointer_array_get_item (&mca_base_vars, i);
1121             if (NULL != object) {
1122                 OBJ_RELEASE(object);
1123             }
1124         }
1125         OBJ_DESTRUCT(&mca_base_vars);
1126 
1127         while (NULL !=
1128                (item = opal_list_remove_first(&mca_base_var_file_values))) {
1129             OBJ_RELEASE(item);
1130         }
1131         OBJ_DESTRUCT(&mca_base_var_file_values);
1132 
1133         while (NULL !=
1134                (item = opal_list_remove_first(&mca_base_envar_file_values))) {
1135             OBJ_RELEASE(item);
1136         }
1137         OBJ_DESTRUCT(&mca_base_envar_file_values);
1138 
1139         while (NULL !=
1140                (item = opal_list_remove_first(&mca_base_var_override_values))) {
1141             OBJ_RELEASE(item);
1142         }
1143         OBJ_DESTRUCT(&mca_base_var_override_values);
1144 
1145         if( NULL != cwd ) {
1146             free(cwd);
1147             cwd = NULL;
1148         }
1149 
1150         mca_base_var_initialized = false;
1151         mca_base_var_count = 0;
1152 
1153         if (NULL != mca_base_var_file_list) {
1154             opal_argv_free(mca_base_var_file_list);
1155         }
1156         mca_base_var_file_list = NULL;
1157 
1158         (void) mca_base_var_group_finalize ();
1159         (void) mca_base_pvar_finalize ();
1160 
1161         OBJ_DESTRUCT(&mca_base_var_index_hash);
1162 
1163         free (mca_base_envar_files);
1164         mca_base_envar_files = NULL;
1165     }
1166 }
1167 
1168 
1169 
1170 static int fixup_files(char **file_list, char * path, bool rel_path_search, char sep) {
1171     int exit_status = OPAL_SUCCESS;
1172     char **files = NULL;
1173     char **search_path = NULL;
1174     char * tmp_file = NULL;
1175     char **argv = NULL;
1176     char *rel_path;
1177     int mode = R_OK; 
1178     int count, i, argc = 0;
1179 
1180     search_path = opal_argv_split(path, OPAL_ENV_SEP);
1181     files = opal_argv_split(*file_list, sep);
1182     count = opal_argv_count(files);
1183 
1184     rel_path = force_agg_path ? force_agg_path : cwd;
1185 
1186     
1187     for (i = 0 ; i < count; ++i) {
1188         char *msg_path = path;
1189         if (opal_path_is_absolute(files[i])) {
1190             
1191             tmp_file = opal_path_access(files[i], NULL, mode);
1192         } else if (!rel_path_search && NULL != strchr(files[i], OPAL_PATH_SEP[0])) {
1193             
1194 
1195 
1196 
1197 
1198 
1199             msg_path = rel_path;
1200             tmp_file = opal_path_access(files[i], rel_path, mode);
1201         } else {
1202             
1203 
1204 
1205 
1206 
1207             tmp_file = opal_path_find (files[i], search_path, mode, NULL);
1208         }
1209 
1210         if (NULL == tmp_file) {
1211             opal_show_help("help-mca-var.txt", "missing-param-file",
1212                            true, getpid(), files[i], msg_path);
1213             exit_status = OPAL_ERROR;
1214             break;
1215         }
1216 
1217         opal_argv_append(&argc, &argv, tmp_file);
1218 
1219         free(tmp_file);
1220         tmp_file = NULL;
1221     }
1222 
1223     if (OPAL_SUCCESS == exit_status) {
1224         free(*file_list);
1225         *file_list = opal_argv_join(argv, sep);
1226     }
1227 
1228     if( NULL != files ) {
1229         opal_argv_free(files);
1230         files = NULL;
1231     }
1232 
1233     if( NULL != argv ) {
1234         opal_argv_free(argv);
1235         argv = NULL;
1236     }
1237 
1238     if( NULL != search_path ) {
1239         opal_argv_free(search_path);
1240         search_path = NULL;
1241     }
1242 
1243     return exit_status;
1244 }
1245 
1246 static int read_files(char *file_list, opal_list_t *file_values, char sep)
1247 {
1248     char **tmp = opal_argv_split(file_list, sep);
1249     int i, count;
1250 
1251     if (!tmp) {
1252         return OPAL_ERR_OUT_OF_RESOURCE;
1253     }
1254 
1255     count = opal_argv_count(tmp);
1256 
1257     
1258 
1259 
1260 
1261     for (i = count - 1; i >= 0; --i) {
1262         char *file_name = append_filename_to_list (tmp[i]);
1263         mca_base_parse_paramfile(file_name, file_values);
1264     }
1265 
1266     opal_argv_free (tmp);
1267 
1268     mca_base_internal_env_store();
1269 
1270     return OPAL_SUCCESS;
1271 }
1272 
1273 
1274 static int register_variable (const char *project_name, const char *framework_name,
1275                               const char *component_name, const char *variable_name,
1276                               const char *description, mca_base_var_type_t type,
1277                               mca_base_var_enum_t *enumerator, int bind,
1278                               mca_base_var_flag_t flags, mca_base_var_info_lvl_t info_lvl,
1279                               mca_base_var_scope_t scope, int synonym_for,
1280                               void *storage)
1281 {
1282     int ret, var_index, group_index, tmp;
1283     mca_base_var_group_t *group;
1284     mca_base_var_t *var, *original = NULL;
1285 
1286     
1287     assert (((flags & MCA_BASE_VAR_FLAG_SYNONYM) || NULL != storage) && type >= 0 && type < MCA_BASE_VAR_TYPE_MAX);
1288 
1289     
1290     if (NULL != project_name &&
1291         strlen(project_name) > MCA_BASE_MAX_PROJECT_NAME_LEN) {
1292         return OPAL_ERR_BAD_PARAM;
1293     }
1294     if (NULL != framework_name &&
1295         strlen(framework_name) > MCA_BASE_MAX_TYPE_NAME_LEN) {
1296         return OPAL_ERR_BAD_PARAM;
1297     }
1298     if (NULL != component_name &&
1299         strlen(component_name) > MCA_BASE_MAX_COMPONENT_NAME_LEN) {
1300         return OPAL_ERR_BAD_PARAM;
1301     }
1302     if (NULL != variable_name &&
1303         strlen(variable_name) > MCA_BASE_MAX_VARIABLE_NAME_LEN) {
1304         return OPAL_ERR_BAD_PARAM;
1305     }
1306 
1307 #if OPAL_ENABLE_DEBUG
1308     
1309     uintptr_t align = 0;
1310     switch (type) {
1311     case MCA_BASE_VAR_TYPE_INT:
1312     case MCA_BASE_VAR_TYPE_UNSIGNED_INT:
1313         align = OPAL_ALIGNMENT_INT;
1314         break;
1315     case MCA_BASE_VAR_TYPE_INT32_T:
1316     case MCA_BASE_VAR_TYPE_UINT32_T:
1317         align = OPAL_ALIGNMENT_INT32;
1318         break;
1319     case MCA_BASE_VAR_TYPE_INT64_T:
1320     case MCA_BASE_VAR_TYPE_UINT64_T:
1321         align = OPAL_ALIGNMENT_INT64;
1322         break;
1323     case MCA_BASE_VAR_TYPE_LONG:
1324     case MCA_BASE_VAR_TYPE_UNSIGNED_LONG:
1325         align = OPAL_ALIGNMENT_LONG;
1326         break;
1327     case MCA_BASE_VAR_TYPE_UNSIGNED_LONG_LONG:
1328         align = OPAL_ALIGNMENT_LONG_LONG;
1329         break;
1330     case MCA_BASE_VAR_TYPE_SIZE_T:
1331         align = OPAL_ALIGNMENT_SIZE_T;
1332         break;
1333     case MCA_BASE_VAR_TYPE_BOOL:
1334         align = OPAL_ALIGNMENT_BOOL;
1335         break;
1336     case MCA_BASE_VAR_TYPE_DOUBLE:
1337         align = OPAL_ALIGNMENT_DOUBLE;
1338         break;
1339     case MCA_BASE_VAR_TYPE_VERSION_STRING:
1340     case MCA_BASE_VAR_TYPE_STRING:
1341     default:
1342         align = 0;
1343         break;
1344     }
1345 
1346     if (0 != align) {
1347         assert(((uintptr_t) storage) % align == 0);
1348     }
1349 
1350     
1351 
1352     if (flags & MCA_BASE_VAR_FLAG_SYNONYM && synonym_for < 0) {
1353         assert((flags & MCA_BASE_VAR_FLAG_SYNONYM) && synonym_for >= 0);
1354     }
1355 #endif
1356 
1357     if (flags & MCA_BASE_VAR_FLAG_SYNONYM) {
1358         original = opal_pointer_array_get_item (&mca_base_vars, synonym_for);
1359         if (NULL == original) {
1360             
1361 
1362             assert (NULL != original);
1363             return OPAL_ERR_NOT_FOUND;
1364         }
1365     }
1366 
1367     
1368     OPAL_DEBUG_ZERO(var);
1369 
1370     
1371     if (!mca_base_var_initialized) {
1372         mca_base_var_init();
1373     }
1374 
1375     
1376     var_index = var_find (project_name, framework_name, component_name, variable_name,
1377                           true);
1378 
1379     if (0 > var_index) {
1380         
1381         group_index = mca_base_var_group_register (project_name, framework_name, component_name,
1382                                                    NULL);
1383         if (-1 > group_index) {
1384             return group_index;
1385         }
1386 
1387         
1388         if (scope < MCA_BASE_VAR_SCOPE_LOCAL || (flags & MCA_BASE_VAR_FLAG_DEFAULT_ONLY)) {
1389             if ((flags & MCA_BASE_VAR_FLAG_DEFAULT_ONLY) && (flags & MCA_BASE_VAR_FLAG_SETTABLE)) {
1390                 opal_show_help("help-mca-var.txt", "invalid-flag-combination",
1391                                true, "MCA_BASE_VAR_FLAG_DEFAULT_ONLY", "MCA_BASE_VAR_FLAG_SETTABLE");
1392                 return OPAL_ERROR;
1393             }
1394 
1395             
1396             flags &= ~MCA_BASE_VAR_FLAG_SETTABLE;
1397         }
1398 
1399         var = OBJ_NEW(mca_base_var_t);
1400 
1401         var->mbv_type        = type;
1402         var->mbv_flags       = flags;
1403         var->mbv_group_index = group_index;
1404         var->mbv_info_lvl    = info_lvl;
1405         var->mbv_scope       = scope;
1406         var->mbv_synonym_for = synonym_for;
1407         var->mbv_bind        = bind;
1408 
1409         if (NULL != description) {
1410             var->mbv_description = strdup(description);
1411         }
1412 
1413         ret = mca_base_var_generate_full_name4 (project_name, framework_name, component_name,
1414                                                 variable_name, &var->mbv_long_name);
1415         if (OPAL_SUCCESS != ret) {
1416             OBJ_RELEASE(var);
1417             return OPAL_ERROR;
1418         }
1419         
1420 
1421 
1422 
1423         var->mbv_full_name = var->mbv_long_name +
1424                              (NULL == project_name ? 0 : (strlen(project_name)+1)); 
1425         if( NULL != variable_name ) {
1426             var->mbv_variable_name = var->mbv_full_name +
1427                                      (NULL == framework_name ? 0 : (strlen(framework_name)+1)) +
1428                                      (NULL == component_name ? 0 : (strlen(component_name)+1));
1429         }
1430 
1431         
1432 
1433 
1434 
1435         var_index = opal_pointer_array_add (&mca_base_vars, var);
1436         if (0 > var_index) {
1437             OBJ_RELEASE(var);
1438             return OPAL_ERROR;
1439         }
1440 
1441         var->mbv_index = var_index;
1442 
1443         if (0 <= group_index) {
1444             mca_base_var_group_add_var (group_index, var_index);
1445         }
1446 
1447         mca_base_var_count++;
1448         if (0 <= var_find_by_name (var->mbv_full_name, &tmp, 0)) {
1449             
1450             assert (0);
1451         }
1452 
1453         opal_hash_table_set_value_ptr (&mca_base_var_index_hash, var->mbv_full_name, strlen (var->mbv_full_name),
1454                                        (void *)(uintptr_t) var_index);
1455     } else {
1456         ret = var_get (var_index, &var, false);
1457         if (OPAL_SUCCESS != ret) {
1458             
1459             return OPAL_ERROR;
1460         }
1461 
1462         ret = mca_base_var_group_get_internal (var->mbv_group_index, &group, true);
1463         if (OPAL_SUCCESS != ret) {
1464             
1465             return OPAL_ERROR;
1466         }
1467 
1468         if (!group->group_isvalid) {
1469             group->group_isvalid = true;
1470         }
1471 
1472         
1473         if (0 != compare_strings(framework_name, group->group_framework) ||
1474             0 != compare_strings(component_name, group->group_component) ||
1475             0 != compare_strings(variable_name, var->mbv_variable_name)) {
1476             opal_show_help("help-mca-var.txt", "var-name-conflict",
1477                            true, var->mbv_full_name, framework_name,
1478                            component_name, variable_name,
1479                            group->group_framework, group->group_component,
1480                            var->mbv_variable_name);
1481             
1482             assert (0);
1483             return OPAL_ERROR;
1484         }
1485 
1486         if (var->mbv_type != type) {
1487 #if OPAL_ENABLE_DEBUG
1488             opal_show_help("help-mca-var.txt",
1489                            "re-register-with-different-type",
1490                            true, var->mbv_full_name);
1491 #endif
1492             return OPAL_ERR_VALUE_OUT_OF_BOUNDS;
1493         }
1494     }
1495 
1496     if (MCA_BASE_VAR_TYPE_BOOL == var->mbv_type) {
1497         enumerator = &mca_base_var_enum_bool;
1498     } else if (NULL != enumerator) {
1499         if (var->mbv_enumerator) {
1500             OBJ_RELEASE (var->mbv_enumerator);
1501         }
1502 
1503         if (!enumerator->enum_is_static) {
1504             OBJ_RETAIN(enumerator);
1505         }
1506     }
1507 
1508     var->mbv_enumerator = enumerator;
1509 
1510     if (!original) {
1511         var->mbv_storage = storage;
1512 
1513         
1514         if ((MCA_BASE_VAR_TYPE_STRING == type || MCA_BASE_VAR_TYPE_VERSION_STRING == type) && NULL != ((char **)storage)[0]) {
1515             ((char **)storage)[0] = strdup (((char **)storage)[0]);
1516         }
1517     } else {
1518         
1519         opal_value_array_append_item(&original->mbv_synonyms, &var_index);
1520     }
1521 
1522     
1523     var->mbv_flags |= MCA_BASE_VAR_FLAG_VALID;
1524 
1525     ret = var_set_initial (var, original);
1526     if (OPAL_SUCCESS != ret) {
1527         return ret;
1528     }
1529 
1530     
1531     return var_index;
1532 }
1533 
1534 int mca_base_var_register (const char *project_name, const char *framework_name,
1535                            const char *component_name, const char *variable_name,
1536                            const char *description, mca_base_var_type_t type,
1537                            mca_base_var_enum_t *enumerator, int bind,
1538                            mca_base_var_flag_t flags,
1539                            mca_base_var_info_lvl_t info_lvl,
1540                            mca_base_var_scope_t scope, void *storage)
1541 {
1542     
1543     assert (NULL == enumerator || (MCA_BASE_VAR_TYPE_INT == type || MCA_BASE_VAR_TYPE_UNSIGNED_INT == type));
1544 
1545     return register_variable (project_name, framework_name, component_name,
1546                               variable_name, description, type, enumerator,
1547                               bind, flags, info_lvl, scope, -1, storage);
1548 }
1549 
1550 int mca_base_component_var_register (const mca_base_component_t *component,
1551                                      const char *variable_name, const char *description,
1552                                      mca_base_var_type_t type, mca_base_var_enum_t *enumerator,
1553                                      int bind, mca_base_var_flag_t flags,
1554                                      mca_base_var_info_lvl_t info_lvl,
1555                                      mca_base_var_scope_t scope, void *storage)
1556 {
1557     return mca_base_var_register (component->mca_project_name, component->mca_type_name,
1558                                   component->mca_component_name,
1559                                   variable_name, description, type, enumerator,
1560                                   bind, flags | MCA_BASE_VAR_FLAG_DWG,
1561                                   info_lvl, scope, storage);
1562 }
1563 
1564 int mca_base_framework_var_register (const mca_base_framework_t *framework,
1565                                      const char *variable_name,
1566                                      const char *help_msg, mca_base_var_type_t type,
1567                                      mca_base_var_enum_t *enumerator, int bind,
1568                                      mca_base_var_flag_t flags,
1569                                      mca_base_var_info_lvl_t info_level,
1570                                      mca_base_var_scope_t scope, void *storage)
1571 {
1572     return mca_base_var_register (framework->framework_project, framework->framework_name,
1573                                   "base", variable_name, help_msg, type, enumerator, bind,
1574                                   flags | MCA_BASE_VAR_FLAG_DWG, info_level, scope, storage);
1575 }
1576 
1577 int mca_base_var_register_synonym (int synonym_for, const char *project_name,
1578                                    const char *framework_name,
1579                                    const char *component_name,
1580                                    const char *synonym_name,
1581                                    mca_base_var_syn_flag_t flags)
1582 {
1583     mca_base_var_flag_t var_flags = (mca_base_var_flag_t) MCA_BASE_VAR_FLAG_SYNONYM;
1584     mca_base_var_t *var;
1585     int ret;
1586 
1587     ret = var_get (synonym_for, &var, false);
1588     if (OPAL_SUCCESS != ret || VAR_IS_SYNONYM(var[0])) {
1589         return OPAL_ERR_BAD_PARAM;
1590     }
1591 
1592     if (flags & MCA_BASE_VAR_SYN_FLAG_DEPRECATED) {
1593         var_flags |= MCA_BASE_VAR_FLAG_DEPRECATED;
1594     }
1595     if (flags & MCA_BASE_VAR_SYN_FLAG_INTERNAL) {
1596         var_flags |= MCA_BASE_VAR_FLAG_INTERNAL;
1597     }
1598 
1599     return register_variable (project_name, framework_name, component_name,
1600                               synonym_name, var->mbv_description, var->mbv_type, var->mbv_enumerator,
1601                               var->mbv_bind, var_flags, var->mbv_info_lvl, var->mbv_scope,
1602                               synonym_for, NULL);
1603 }
1604 
1605 static int var_get_env (mca_base_var_t *var, const char *name, char **source, char **value)
1606 {
1607     const char source_prefix[] = "SOURCE_";
1608     const int max_len = strlen(mca_prefix) + strlen(source_prefix) +
1609         strlen(name) + 1;
1610     char *envvar = alloca(max_len);
1611     if (NULL == envvar) {
1612         return OPAL_ERR_OUT_OF_RESOURCE;
1613     }
1614 
1615     int ret;
1616     ret = snprintf(envvar, max_len, "%s%s", mca_prefix, name);
1617     if (0 > ret) {
1618         return OPAL_ERROR;
1619     }
1620     *value = getenv(envvar);
1621     if( NULL == *value ) {
1622         *source = NULL;
1623         return OPAL_ERR_NOT_FOUND;
1624     }
1625 
1626     ret = snprintf(envvar, max_len, "%s%s%s", mca_prefix,
1627                    source_prefix, name);
1628     if( 0 > ret ) {
1629         return OPAL_ERROR;
1630     }
1631     *source = getenv(envvar);
1632 
1633     return OPAL_SUCCESS;
1634 }
1635 
1636 
1637 
1638 
1639 static int var_set_from_env (mca_base_var_t *var, mca_base_var_t *original)
1640 {
1641     const char *var_full_name = var->mbv_full_name;
1642     const char *var_long_name = var->mbv_long_name;
1643     bool deprecated = VAR_IS_DEPRECATED(var[0]);
1644     bool is_synonym = VAR_IS_SYNONYM(var[0]);
1645     char *source_env, *value_env;
1646     int ret;
1647 
1648     ret = var_get_env (var, var_long_name, &source_env, &value_env);
1649     if (OPAL_SUCCESS != ret) {
1650         ret = var_get_env (var, var_full_name, &source_env, &value_env);
1651     }
1652 
1653     if (OPAL_SUCCESS != ret) {
1654         return ret;
1655     }
1656 
1657     
1658 
1659     if (VAR_IS_DEFAULT_ONLY(original[0])) {
1660         opal_show_help("help-mca-var.txt", "default-only-param-set",
1661                        true, var_full_name);
1662 
1663         return OPAL_ERR_NOT_FOUND;
1664     }
1665 
1666     if (MCA_BASE_VAR_SOURCE_OVERRIDE == original->mbv_source) {
1667         if (!mca_base_var_suppress_override_warning) {
1668             opal_show_help("help-mca-var.txt", "overridden-param-set",
1669                            true, var_full_name);
1670         }
1671 
1672         return OPAL_ERR_NOT_FOUND;
1673     }
1674 
1675     original->mbv_source = MCA_BASE_VAR_SOURCE_ENV;
1676 
1677     if (NULL != source_env) {
1678         if (0 == strncasecmp (source_env, "file:", 5)) {
1679             original->mbv_source_file = append_filename_to_list(source_env + 5);
1680             if (0 == strcmp (var->mbv_source_file, mca_base_var_override_file)) {
1681                 original->mbv_source = MCA_BASE_VAR_SOURCE_OVERRIDE;
1682             } else {
1683                 original->mbv_source = MCA_BASE_VAR_SOURCE_FILE;
1684             }
1685         } else if (0 == strcasecmp (source_env, "command")) {
1686             var->mbv_source = MCA_BASE_VAR_SOURCE_COMMAND_LINE;
1687         }
1688     }
1689 
1690     if (deprecated) {
1691         const char *new_variable = "None (going away)";
1692 
1693         if (is_synonym) {
1694             new_variable = original->mbv_full_name;
1695         }
1696 
1697         switch (var->mbv_source) {
1698         case MCA_BASE_VAR_SOURCE_ENV:
1699             opal_show_help("help-mca-var.txt", "deprecated-mca-env",
1700                            true, var_full_name, new_variable);
1701             break;
1702         case MCA_BASE_VAR_SOURCE_COMMAND_LINE:
1703             opal_show_help("help-mca-var.txt", "deprecated-mca-cli",
1704                            true, var_full_name, new_variable);
1705             break;
1706         case MCA_BASE_VAR_SOURCE_FILE:
1707         case MCA_BASE_VAR_SOURCE_OVERRIDE:
1708             opal_show_help("help-mca-var.txt", "deprecated-mca-file",
1709                            true, var_full_name, mca_base_var_source_file (var),
1710                            new_variable);
1711             break;
1712 
1713         case MCA_BASE_VAR_SOURCE_DEFAULT:
1714         case MCA_BASE_VAR_SOURCE_MAX:
1715         case MCA_BASE_VAR_SOURCE_SET:
1716             
1717             break;
1718         }
1719     }
1720 
1721     return var_set_from_string (original, value_env);
1722 }
1723 
1724 
1725 
1726 
1727 static int var_set_from_file (mca_base_var_t *var, mca_base_var_t *original, opal_list_t *file_values)
1728 {
1729     const char *var_full_name = var->mbv_full_name;
1730     const char *var_long_name = var->mbv_long_name;
1731     bool deprecated = VAR_IS_DEPRECATED(var[0]);
1732     bool is_synonym = VAR_IS_SYNONYM(var[0]);
1733     mca_base_var_file_value_t *fv;
1734 
1735     
1736 
1737 
1738 
1739     OPAL_LIST_FOREACH(fv, file_values, mca_base_var_file_value_t) {
1740         if (0 != strcmp(fv->mbvfv_var, var_full_name) &&
1741             0 != strcmp(fv->mbvfv_var, var_long_name)) {
1742             continue;
1743         }
1744 
1745         
1746         if (VAR_IS_DEFAULT_ONLY(var[0])) {
1747             opal_show_help("help-mca-var.txt", "default-only-param-set",
1748                            true, var_full_name);
1749 
1750             return OPAL_ERR_NOT_FOUND;
1751         }
1752 
1753         if (MCA_BASE_VAR_FLAG_ENVIRONMENT_ONLY & original->mbv_flags) {
1754             opal_show_help("help-mca-var.txt", "environment-only-param",
1755                            true, var_full_name, fv->mbvfv_value,
1756                            fv->mbvfv_file);
1757 
1758             return OPAL_ERR_NOT_FOUND;
1759         }
1760 
1761         if (MCA_BASE_VAR_SOURCE_OVERRIDE == original->mbv_source) {
1762             if (!mca_base_var_suppress_override_warning) {
1763                 opal_show_help("help-mca-var.txt", "overridden-param-set",
1764                                true, var_full_name);
1765             }
1766 
1767             return OPAL_ERR_NOT_FOUND;
1768         }
1769 
1770         if (deprecated) {
1771             const char *new_variable = "None (going away)";
1772 
1773             if (is_synonym) {
1774                 new_variable = original->mbv_full_name;
1775             }
1776 
1777             opal_show_help("help-mca-var.txt", "deprecated-mca-file",
1778                            true, var_full_name, fv->mbvfv_file,
1779                            new_variable);
1780         }
1781 
1782         original->mbv_file_value = (void *) fv;
1783         original->mbv_source = MCA_BASE_VAR_SOURCE_FILE;
1784         if (is_synonym) {
1785             var->mbv_file_value = (void *) fv;
1786             var->mbv_source = MCA_BASE_VAR_SOURCE_FILE;
1787         }
1788 
1789         return var_set_from_string (original, fv->mbvfv_value);
1790     }
1791 
1792     return OPAL_ERR_NOT_FOUND;
1793 }
1794 
1795 
1796 
1797 
1798 static int var_set_initial (mca_base_var_t *var, mca_base_var_t *original)
1799 {
1800     int ret;
1801 
1802     if (original) {
1803         
1804         var->mbv_source = original->mbv_source;
1805         var->mbv_file_value = original->mbv_file_value;
1806         var->mbv_source_file = original->mbv_source_file;
1807     } else {
1808         var->mbv_source = MCA_BASE_VAR_SOURCE_DEFAULT;
1809         original = var;
1810     }
1811 
1812     
1813 
1814 
1815 
1816     ret = var_set_from_file (var, original, &mca_base_var_override_values);
1817     if (OPAL_SUCCESS == ret) {
1818         var->mbv_flags = ~MCA_BASE_VAR_FLAG_SETTABLE & (var->mbv_flags | MCA_BASE_VAR_FLAG_OVERRIDE);
1819         var->mbv_source = MCA_BASE_VAR_SOURCE_OVERRIDE;
1820     }
1821 
1822     ret = var_set_from_env (var, original);
1823     if (OPAL_ERR_NOT_FOUND != ret) {
1824         return ret;
1825     }
1826 
1827     ret = var_set_from_file (var, original, &mca_base_envar_file_values);
1828     if (OPAL_ERR_NOT_FOUND != ret) {
1829         return ret;
1830     }
1831 
1832     ret = var_set_from_file (var, original, &mca_base_var_file_values);
1833     if (OPAL_ERR_NOT_FOUND != ret) {
1834         return ret;
1835     }
1836 
1837     return OPAL_SUCCESS;
1838 }
1839 
1840 
1841 
1842 
1843 static void var_constructor(mca_base_var_t *var)
1844 {
1845     memset ((char *) var + sizeof (var->super), 0, sizeof (*var) - sizeof (var->super));
1846 
1847     var->mbv_type = MCA_BASE_VAR_TYPE_MAX;
1848     OBJ_CONSTRUCT(&var->mbv_synonyms, opal_value_array_t);
1849     opal_value_array_init (&var->mbv_synonyms, sizeof (int));
1850 }
1851 
1852 
1853 
1854 
1855 
1856 static void var_destructor(mca_base_var_t *var)
1857 {
1858     if ((MCA_BASE_VAR_TYPE_STRING == var->mbv_type ||
1859                 MCA_BASE_VAR_TYPE_VERSION_STRING == var->mbv_type) &&
1860         NULL != var->mbv_storage &&
1861         NULL != var->mbv_storage->stringval) {
1862         free (var->mbv_storage->stringval);
1863         var->mbv_storage->stringval = NULL;
1864     }
1865 
1866     
1867     if (var->mbv_enumerator && !var->mbv_enumerator->enum_is_static) {
1868         OBJ_RELEASE(var->mbv_enumerator);
1869     }
1870 
1871     if (NULL != var->mbv_long_name) {
1872         free(var->mbv_long_name);
1873     }
1874     var->mbv_full_name = NULL;
1875     var->mbv_variable_name = NULL;
1876 
1877     if (NULL != var->mbv_description) {
1878         free(var->mbv_description);
1879     }
1880 
1881     
1882     OBJ_DESTRUCT(&var->mbv_synonyms);
1883 
1884     
1885     var->mbv_type = MCA_BASE_VAR_TYPE_MAX;
1886 
1887 #if OPAL_ENABLE_DEBUG
1888     
1889     memset ((char *) var + sizeof (var->super), 0, sizeof (*var) - sizeof (var->super));
1890 #endif
1891 }
1892 
1893 
1894 static void fv_constructor(mca_base_var_file_value_t *f)
1895 {
1896     memset ((char *) f + sizeof (f->super), 0, sizeof (*f) - sizeof (f->super));
1897 }
1898 
1899 
1900 static void fv_destructor(mca_base_var_file_value_t *f)
1901 {
1902     if (NULL != f->mbvfv_var) {
1903         free(f->mbvfv_var);
1904     }
1905     if (NULL != f->mbvfv_value) {
1906         free(f->mbvfv_value);
1907     }
1908     
1909     fv_constructor(f);
1910 }
1911 
1912 static char *source_name(mca_base_var_t *var)
1913 {
1914     char *ret;
1915 
1916     if (MCA_BASE_VAR_SOURCE_FILE == var->mbv_source || MCA_BASE_VAR_SOURCE_OVERRIDE == var->mbv_source) {
1917         struct mca_base_var_file_value_t *fv = var->mbv_file_value;
1918         int rc;
1919 
1920         if (fv) {
1921             rc = opal_asprintf(&ret, "file (%s:%d)", fv->mbvfv_file, fv->mbvfv_lineno);
1922         } else {
1923             rc = opal_asprintf(&ret, "file (%s)", var->mbv_source_file);
1924         }
1925 
1926         
1927         if (0 > rc) {
1928             return NULL;
1929         }
1930         return ret;
1931     } else if (MCA_BASE_VAR_SOURCE_MAX <= var->mbv_source) {
1932         return strdup ("unknown(!!)");
1933     }
1934 
1935     return strdup (var_source_names[var->mbv_source]);
1936 }
1937 
1938 static int var_value_string (mca_base_var_t *var, char **value_string)
1939 {
1940     const mca_base_var_storage_t *value=NULL;
1941     int ret;
1942 
1943     assert (MCA_BASE_VAR_TYPE_MAX > var->mbv_type);
1944 
1945     
1946 
1947     if ((var->mbv_flags & MCA_BASE_VAR_FLAG_DEF_UNSET) &&
1948         (MCA_BASE_VAR_SOURCE_DEFAULT == var->mbv_source)){
1949         opal_asprintf (value_string, "%s", "unset");
1950         return OPAL_SUCCESS;
1951     }
1952 
1953     ret = mca_base_var_get_value(var->mbv_index, &value, NULL, NULL);
1954     if (OPAL_SUCCESS != ret || NULL == value) {
1955         return ret;
1956     }
1957 
1958     if (NULL == var->mbv_enumerator) {
1959         switch (var->mbv_type) {
1960         case MCA_BASE_VAR_TYPE_INT:
1961             ret = opal_asprintf (value_string, "%d", value->intval);
1962             break;
1963         case MCA_BASE_VAR_TYPE_INT32_T:
1964             ret = opal_asprintf (value_string, "%" PRId32, value->int32tval);
1965             break;
1966         case MCA_BASE_VAR_TYPE_UINT32_T:
1967             ret = opal_asprintf (value_string, "%" PRIu32, value->uint32tval);
1968             break;
1969         case MCA_BASE_VAR_TYPE_INT64_T:
1970             ret = opal_asprintf (value_string, "%" PRId64, value->int64tval);
1971             break;
1972         case MCA_BASE_VAR_TYPE_UINT64_T:
1973             ret = opal_asprintf (value_string, "%" PRIu64, value->uint64tval);
1974             break;
1975         case MCA_BASE_VAR_TYPE_LONG:
1976             ret = opal_asprintf (value_string, "%ld", value->longval);
1977             break;
1978         case MCA_BASE_VAR_TYPE_UNSIGNED_INT:
1979             ret = opal_asprintf (value_string, "%u", value->uintval);
1980             break;
1981         case MCA_BASE_VAR_TYPE_UNSIGNED_LONG:
1982             ret = opal_asprintf (value_string, "%lu", value->ulval);
1983             break;
1984         case MCA_BASE_VAR_TYPE_UNSIGNED_LONG_LONG:
1985             ret = opal_asprintf (value_string, "%llu", value->ullval);
1986             break;
1987         case MCA_BASE_VAR_TYPE_SIZE_T:
1988             ret = opal_asprintf (value_string, "%" PRIsize_t, value->sizetval);
1989             break;
1990         case MCA_BASE_VAR_TYPE_STRING:
1991         case MCA_BASE_VAR_TYPE_VERSION_STRING:
1992             ret = opal_asprintf (value_string, "%s",
1993                             value->stringval ? value->stringval : "");
1994             break;
1995         case MCA_BASE_VAR_TYPE_BOOL:
1996             ret = opal_asprintf (value_string, "%d", value->boolval);
1997             break;
1998         case MCA_BASE_VAR_TYPE_DOUBLE:
1999             ret = opal_asprintf (value_string, "%lf", value->lfval);
2000             break;
2001         default:
2002             ret = -1;
2003             break;
2004         }
2005 
2006         ret = (0 > ret) ? OPAL_ERR_OUT_OF_RESOURCE : OPAL_SUCCESS;
2007     } else {
2008         
2009         if (MCA_BASE_VAR_TYPE_BOOL == var->mbv_type) {
2010             ret = var->mbv_enumerator->string_from_value(var->mbv_enumerator, value->boolval, value_string);
2011         } else {
2012             ret = var->mbv_enumerator->string_from_value(var->mbv_enumerator, value->intval, value_string);
2013         }
2014     }
2015 
2016     return ret;
2017 }
2018 
2019 int mca_base_var_check_exclusive (const char *project,
2020                                   const char *type_a,
2021                                   const char *component_a,
2022                                   const char *param_a,
2023                                   const char *type_b,
2024                                   const char *component_b,
2025                                   const char *param_b)
2026 {
2027     mca_base_var_t *var_a = NULL, *var_b = NULL;
2028     int var_ai, var_bi;
2029 
2030     
2031     project = NULL;
2032 
2033     var_ai = mca_base_var_find (project, type_a, component_a, param_a);
2034     var_bi = mca_base_var_find (project, type_b, component_b, param_b);
2035     if (var_bi < 0 || var_ai < 0) {
2036         return OPAL_ERR_NOT_FOUND;
2037     }
2038 
2039     (void) var_get (var_ai, &var_a, true);
2040     (void) var_get (var_bi, &var_b, true);
2041     if (NULL == var_a || NULL == var_b) {
2042         return OPAL_ERR_NOT_FOUND;
2043     }
2044 
2045     if (MCA_BASE_VAR_SOURCE_DEFAULT != var_a->mbv_source &&
2046         MCA_BASE_VAR_SOURCE_DEFAULT != var_b->mbv_source) {
2047         char *str_a, *str_b;
2048 
2049         
2050         str_a = source_name(var_a);
2051 
2052         
2053         str_b = source_name(var_b);
2054 
2055         
2056         opal_show_help("help-mca-var.txt",
2057                        "mutually-exclusive-vars",
2058                        true, var_a->mbv_full_name,
2059                        str_a, var_b->mbv_full_name,
2060                        str_b);
2061 
2062         
2063         free(str_a);
2064         free(str_b);
2065 
2066         return OPAL_ERR_BAD_PARAM;
2067     }
2068 
2069     return OPAL_SUCCESS;
2070 }
2071 
2072 int mca_base_var_get_count (void)
2073 {
2074     return mca_base_var_count;
2075 }
2076 
2077 int mca_base_var_dump(int vari, char ***out, mca_base_var_dump_type_t output_type)
2078 {
2079     const char *framework, *component, *full_name;
2080     int i, line_count, line = 0, enum_count = 0;
2081     char *value_string, *source_string, *tmp;
2082     int synonym_count, ret, *synonyms = NULL;
2083     mca_base_var_t *var, *original=NULL;
2084     mca_base_var_group_t *group;
2085 
2086     ret = var_get(vari, &var, false);
2087     if (OPAL_SUCCESS != ret) {
2088         return ret;
2089     }
2090 
2091     ret = mca_base_var_group_get_internal(var->mbv_group_index, &group, false);
2092     if (OPAL_SUCCESS != ret) {
2093         return ret;
2094     }
2095 
2096     if (VAR_IS_SYNONYM(var[0])) {
2097         ret = var_get(var->mbv_synonym_for, &original, false);
2098         if (OPAL_SUCCESS != ret) {
2099             return ret;
2100         }
2101         
2102         if (NULL == original) {
2103             return OPAL_ERR_NOT_FOUND;
2104         }
2105     }
2106 
2107     framework = group->group_framework;
2108     component = group->group_component ? group->group_component : "base";
2109     full_name = var->mbv_full_name;
2110 
2111     synonym_count = opal_value_array_get_size(&var->mbv_synonyms);
2112     if (synonym_count) {
2113         synonyms = OPAL_VALUE_ARRAY_GET_BASE(&var->mbv_synonyms, int);
2114     }
2115 
2116     ret = var_value_string (var, &value_string);
2117     if (OPAL_SUCCESS != ret) {
2118         return ret;
2119     }
2120 
2121     source_string = source_name(var);
2122     if (NULL == source_string) {
2123         free (value_string);
2124         return OPAL_ERR_OUT_OF_RESOURCE;
2125     }
2126 
2127     if (MCA_BASE_VAR_DUMP_PARSABLE == output_type) {
2128         if (NULL != var->mbv_enumerator) {
2129             (void) var->mbv_enumerator->get_count(var->mbv_enumerator, &enum_count);
2130         }
2131 
2132         line_count = 8 + (var->mbv_description ? 1 : 0) + (VAR_IS_SYNONYM(var[0]) ? 1 : synonym_count) +
2133             enum_count;
2134 
2135         *out = (char **) calloc (line_count + 1, sizeof (char *));
2136         if (NULL == *out) {
2137             free (value_string);
2138             free (source_string);
2139             return OPAL_ERR_OUT_OF_RESOURCE;
2140         }
2141 
2142         
2143         opal_asprintf(&tmp, "mca:%s:%s:param:%s:", framework, component,
2144                  full_name);
2145 
2146         
2147         char *colon = strchr(value_string, ':');
2148         if (NULL != colon) {
2149             opal_asprintf(out[0] + line++, "%svalue:\"%s\"", tmp, value_string);
2150         } else {
2151             opal_asprintf(out[0] + line++, "%svalue:%s", tmp, value_string);
2152         }
2153 
2154         
2155         opal_asprintf(out[0] + line++, "%ssource:%s", tmp, source_string);
2156 
2157         
2158         opal_asprintf(out[0] + line++, "%sstatus:%s", tmp,
2159                       VAR_IS_SETTABLE(var[0]) ? "writeable" : "read-only");
2160 
2161         
2162         opal_asprintf(out[0] + line++, "%slevel:%d", tmp, var->mbv_info_lvl + 1);
2163 
2164         
2165         if (var->mbv_description) {
2166             opal_asprintf(out[0] + line++, "%shelp:%s", tmp, var->mbv_description);
2167         }
2168 
2169         if (NULL != var->mbv_enumerator) {
2170             for (i = 0 ; i < enum_count ; ++i) {
2171                 const char *enum_string = NULL;
2172                 int enum_value;
2173 
2174                 ret = var->mbv_enumerator->get_value(var->mbv_enumerator, i, &enum_value,
2175                                                      &enum_string);
2176                 if (OPAL_SUCCESS != ret) {
2177                     continue;
2178                 }
2179 
2180                 opal_asprintf(out[0] + line++, "%senumerator:value:%d:%s", tmp, enum_value, enum_string);
2181             }
2182         }
2183 
2184         
2185         opal_asprintf(out[0] + line++, "%sdeprecated:%s", tmp, VAR_IS_DEPRECATED(var[0]) ? "yes" : "no");
2186 
2187         opal_asprintf(out[0] + line++, "%stype:%s", tmp, ompi_var_type_names[var->mbv_type]);
2188 
2189         
2190         if (VAR_IS_SYNONYM(var[0])) {
2191             opal_asprintf(out[0] + line++, "%ssynonym_of:name:%s", tmp, original->mbv_full_name);
2192         } else if (opal_value_array_get_size(&var->mbv_synonyms)) {
2193             for (i = 0 ; i < synonym_count ; ++i) {
2194                 mca_base_var_t *synonym;
2195 
2196                 ret = var_get(synonyms[i], &synonym, false);
2197                 if (OPAL_SUCCESS != ret) {
2198                     continue;
2199                 }
2200 
2201                 opal_asprintf(out[0] + line++, "%ssynonym:name:%s", tmp, synonym->mbv_full_name);
2202             }
2203         }
2204 
2205         free (tmp);
2206     } else if (MCA_BASE_VAR_DUMP_READABLE == output_type) {
2207         
2208         *out = (char **) calloc (4, sizeof (char *));
2209         if (NULL == *out) {
2210             free (value_string);
2211             free (source_string);
2212             return OPAL_ERR_OUT_OF_RESOURCE;
2213         }
2214 
2215         opal_asprintf (out[0], "%s \"%s\" (current value: \"%s\", data source: %s, level: %d %s, type: %s",
2216                   VAR_IS_DEFAULT_ONLY(var[0]) ? "informational" : "parameter",
2217                   full_name, value_string, source_string, var->mbv_info_lvl + 1,
2218                   info_lvl_strings[var->mbv_info_lvl], ompi_var_type_names[var->mbv_type]);
2219 
2220         tmp = out[0][0];
2221         if (VAR_IS_DEPRECATED(var[0])) {
2222             opal_asprintf (out[0], "%s, deprecated", tmp);
2223             free (tmp);
2224             tmp = out[0][0];
2225         }
2226 
2227         
2228         if (VAR_IS_SYNONYM(var[0])) {
2229             opal_asprintf(out[0], "%s, synonym of: %s)", tmp, original->mbv_full_name);
2230             free (tmp);
2231         } else if (synonym_count) {
2232             opal_asprintf(out[0], "%s, synonyms: ", tmp);
2233             free (tmp);
2234 
2235             for (i = 0 ; i < synonym_count ; ++i) {
2236                 mca_base_var_t *synonym;
2237 
2238                 ret = var_get(synonyms[i], &synonym, false);
2239                 if (OPAL_SUCCESS != ret) {
2240                     continue;
2241                 }
2242 
2243                 tmp = out[0][0];
2244                 if (synonym_count == i+1) {
2245                     opal_asprintf(out[0], "%s%s)", tmp, synonym->mbv_full_name);
2246                 } else {
2247                     opal_asprintf(out[0], "%s%s, ", tmp, synonym->mbv_full_name);
2248                 }
2249                 free(tmp);
2250             }
2251         } else {
2252             opal_asprintf(out[0], "%s)", tmp);
2253             free(tmp);
2254         }
2255 
2256         line++;
2257 
2258         if (var->mbv_description) {
2259             opal_asprintf(out[0] + line++, "%s", var->mbv_description);
2260         }
2261 
2262         if (NULL != var->mbv_enumerator) {
2263             char *values;
2264 
2265             ret = var->mbv_enumerator->dump(var->mbv_enumerator, &values);
2266             if (OPAL_SUCCESS == ret) {
2267                 opal_asprintf (out[0] + line++, "Valid values: %s", values);
2268                 free (values);
2269             }
2270         }
2271     } else if (MCA_BASE_VAR_DUMP_SIMPLE == output_type) {
2272         *out = (char **) calloc (2, sizeof (char *));
2273         if (NULL == *out) {
2274             free (value_string);
2275             free (source_string);
2276             return OPAL_ERR_OUT_OF_RESOURCE;
2277         }
2278 
2279         opal_asprintf(out[0], "%s=%s (%s)", var->mbv_full_name, value_string, source_string);
2280     }
2281 
2282     free (value_string);
2283     free (source_string);
2284 
2285     return OPAL_SUCCESS;
2286 }
2287