opal/mca/pmix/pmix4x/pmix/src/mca/bfrops/v20/print.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
pmix20_bfrop_print
pmix20_bfrop_print_bool
pmix20_bfrop_print_byte
pmix20_bfrop_print_string
pmix20_bfrop_print_size
pmix20_bfrop_print_pid
pmix20_bfrop_print_int
pmix20_bfrop_print_uint
pmix20_bfrop_print_uint8
pmix20_bfrop_print_uint16
pmix20_bfrop_print_uint32
pmix20_bfrop_print_int8
pmix20_bfrop_print_int16
pmix20_bfrop_print_int32
pmix20_bfrop_print_uint64
pmix20_bfrop_print_int64
pmix20_bfrop_print_float
pmix20_bfrop_print_double
pmix20_bfrop_print_time
pmix20_bfrop_print_timeval
pmix20_bfrop_print_status
pmix20_bfrop_print_value
pmix20_bfrop_print_info
pmix20_bfrop_print_pdata
pmix20_bfrop_print_buf
pmix20_bfrop_print_app
pmix20_bfrop_print_proc
pmix20_bfrop_print_kval
pmix20_bfrop_print_modex
pmix20_bfrop_print_persist
pmix20_bfrop_print_scope
pmix20_bfrop_print_range
pmix20_bfrop_print_cmd
pmix20_bfrop_print_infodirs
pmix20_bfrop_print_bo
pmix20_bfrop_print_ptr
pmix20_bfrop_print_pstate
pmix20_bfrop_print_pinfo
pmix20_bfrop_print_darray
pmix20_bfrop_print_query
pmix20_bfrop_print_rank
pmix20_bfrop_print_alloc_directive
pmix20_bfrop_print_array
   1 /*
   2  * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
   3  *                         University Research and Technology
   4  *                         Corporation.  All rights reserved.
   5  * Copyright (c) 2004-2006 The University of Tennessee and The University
   6  *                         of Tennessee Research Foundation.  All rights
   7  *                         reserved.
   8  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
   9  *                         University of Stuttgart.  All rights reserved.
  10  * Copyright (c) 2004-2005 The Regents of the University of California.
  11  *                         All rights reserved.
  12  * Copyright (c) 2012      Los Alamos National Security, Inc.  All rights reserved.
  13  * Copyright (c) 2014-2018 Intel, Inc.  All rights reserved.
  14  * Copyright (c) 2016      Mellanox Technologies, Inc.
  15  *                         All rights reserved.
  16  * Copyright (c) 2016      IBM Corporation.  All rights reserved.
  17  * $COPYRIGHT$
  18  *
  19  * Additional copyrights may follow
  20  *
  21  * $HEADER$
  22  */
  23 
  24 #include <src/include/pmix_config.h>
  25 
  26 #include <src/include/pmix_stdint.h>
  27 
  28 #include <stdio.h>
  29 #ifdef HAVE_TIME_H
  30 #include <time.h>
  31 #endif
  32 
  33 #include "src/util/error.h"
  34 #include "src/include/pmix_globals.h"
  35 #include "src/mca/bfrops/base/base.h"
  36 #include "bfrop_pmix20.h"
  37 #include "internal.h"
  38 
  39  pmix_status_t pmix20_bfrop_print(char **output, char *prefix, void *src, pmix_data_type_t type)
  40  {
  41     pmix_bfrop_type_info_t *info;
  42 
  43     /* check for error */
  44     if (NULL == output) {
  45         return PMIX_ERR_BAD_PARAM;
  46     }
  47 
  48     /* Lookup the print function for this type and call it */
  49 
  50     if(NULL == (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(&mca_bfrops_v20_component.types, type))) {
  51         return PMIX_ERR_UNKNOWN_DATA_TYPE;
  52     }
  53 
  54     return info->odti_print_fn(output, prefix, src, type);
  55 }
  56 
  57 /*
  58  * STANDARD PRINT FUNCTIONS FOR SYSTEM TYPES
  59  */
  60  pmix_status_t pmix20_bfrop_print_bool(char **output, char *prefix, bool *src, pmix_data_type_t type)
  61  {
  62     char *prefx;
  63 
  64     /* deal with NULL prefix */
  65     if (NULL == prefix) {
  66         if (0 > asprintf(&prefx, " ")) {
  67             return PMIX_ERR_NOMEM;
  68         }
  69     }
  70     else {
  71         prefx = prefix;
  72     }
  73 
  74     /* if src is NULL, just print data type and return */
  75     if (NULL == src) {
  76         if (0 > asprintf(output, "%sData type: PMIX_BOOL\tValue: NULL pointer", prefx)) {
  77             return PMIX_ERR_NOMEM;
  78         }
  79         if (prefx != prefix) {
  80             free(prefx);
  81         }
  82         return PMIX_SUCCESS;
  83     }
  84 
  85     if (0 > asprintf(output, "%sData type: PMIX_BOOL\tValue: %s", prefix,
  86                      (*src) ? "TRUE" : "FALSE")) {
  87         return PMIX_ERR_NOMEM;
  88 }
  89 if (prefx != prefix) {
  90     free(prefx);
  91 }
  92 
  93 return PMIX_SUCCESS;
  94 }
  95 
  96 pmix_status_t pmix20_bfrop_print_byte(char **output, char *prefix, uint8_t *src, pmix_data_type_t type)
  97 {
  98     char *prefx;
  99 
 100     /* deal with NULL prefix */
 101     if (NULL == prefix) {
 102         if (0 > asprintf(&prefx, " ")) {
 103             return PMIX_ERR_NOMEM;
 104         }
 105     } else {
 106         prefx = prefix;
 107     }
 108 
 109     /* if src is NULL, just print data type and return */
 110     if (NULL == src) {
 111         if (0 > asprintf(output, "%sData type: PMIX_BYTE\tValue: NULL pointer", prefx)) {
 112             return PMIX_ERR_NOMEM;
 113         }
 114         if (prefx != prefix) {
 115             free(prefx);
 116         }
 117         return PMIX_SUCCESS;
 118     }
 119 
 120     if (0 > asprintf(output, "%sData type: PMIX_BYTE\tValue: %x", prefix, *src)) {
 121         return PMIX_ERR_NOMEM;
 122     }
 123     if (prefx != prefix) {
 124         free(prefx);
 125     }
 126 
 127     return PMIX_SUCCESS;
 128 }
 129 
 130 pmix_status_t pmix20_bfrop_print_string(char **output, char *prefix, char *src, pmix_data_type_t type)
 131 {
 132     char *prefx;
 133 
 134     /* deal with NULL prefix */
 135     if (NULL == prefix) {
 136         if (0 > asprintf(&prefx, " ")) {
 137             return PMIX_ERR_NOMEM;
 138         }
 139     } else {
 140         prefx = prefix;
 141     }
 142 
 143     /* if src is NULL, just print data type and return */
 144     if (NULL == src) {
 145         if (0 > asprintf(output, "%sData type: PMIX_STRING\tValue: NULL pointer", prefx)) {
 146             return PMIX_ERR_NOMEM;
 147         }
 148         if (prefx != prefix) {
 149             free(prefx);
 150         }
 151         return PMIX_SUCCESS;
 152     }
 153 
 154     if (0 > asprintf(output, "%sData type: PMIX_STRING\tValue: %s", prefx, src)) {
 155         return PMIX_ERR_NOMEM;
 156     }
 157     if (prefx != prefix) {
 158         free(prefx);
 159     }
 160 
 161     return PMIX_SUCCESS;
 162 }
 163 
 164 pmix_status_t pmix20_bfrop_print_size(char **output, char *prefix, size_t *src, pmix_data_type_t type)
 165 {
 166     char *prefx;
 167 
 168     /* deal with NULL prefix */
 169     if (NULL == prefix) {
 170         if (0 > asprintf(&prefx, " ")) {
 171             return PMIX_ERR_NOMEM;
 172         }
 173     } else {
 174         prefx = prefix;
 175     }
 176 
 177     /* if src is NULL, just print data type and return */
 178     if (NULL == src) {
 179         if (0 > asprintf(output, "%sData type: PMIX_SIZE\tValue: NULL pointer", prefx)) {
 180             return PMIX_ERR_NOMEM;
 181         }
 182         if (prefx != prefix) {
 183             free(prefx);
 184         }
 185         return PMIX_SUCCESS;
 186     }
 187 
 188     if (0 > asprintf(output, "%sData type: PMIX_SIZE\tValue: %lu", prefx, (unsigned long) *src)) {
 189         return PMIX_ERR_NOMEM;
 190     }
 191     if (prefx != prefix) {
 192         free(prefx);
 193     }
 194 
 195     return PMIX_SUCCESS;
 196 }
 197 
 198 pmix_status_t pmix20_bfrop_print_pid(char **output, char *prefix, pid_t *src, pmix_data_type_t type)
 199 {
 200     char *prefx;
 201 
 202     /* deal with NULL prefix */
 203     if (NULL == prefix) {
 204         if (0 > asprintf(&prefx, " ")) {
 205             return PMIX_ERR_NOMEM;
 206         }
 207     } else {
 208         prefx = prefix;
 209     }
 210 
 211     /* if src is NULL, just print data type and return */
 212     if (NULL == src) {
 213         if (0 > asprintf(output, "%sData type: PMIX_PID\tValue: NULL pointer", prefx)) {
 214             return PMIX_ERR_NOMEM;
 215         }
 216         if (prefx != prefix) {
 217             free(prefx);
 218         }
 219         return PMIX_SUCCESS;
 220     }
 221 
 222     if (0 > asprintf(output, "%sData type: PMIX_PID\tValue: %lu", prefx, (unsigned long) *src)) {
 223         return PMIX_ERR_NOMEM;
 224     }
 225     if (prefx != prefix) {
 226         free(prefx);
 227     }
 228     return PMIX_SUCCESS;
 229 }
 230 
 231 pmix_status_t pmix20_bfrop_print_int(char **output, char *prefix, int *src, pmix_data_type_t type)
 232 {
 233     char *prefx;
 234 
 235     /* deal with NULL prefix */
 236     if (NULL == prefix) {
 237         if (0 > asprintf(&prefx, " ")) {
 238             return PMIX_ERR_NOMEM;
 239         }
 240     } else {
 241         prefx = prefix;
 242     }
 243 
 244     /* if src is NULL, just print data type and return */
 245     if (NULL == src) {
 246         if (0 > asprintf(output, "%sData type: PMIX_INT\tValue: NULL pointer", prefx)) {
 247             return PMIX_ERR_NOMEM;
 248         }
 249         if (prefx != prefix) {
 250             free(prefx);
 251         }
 252         return PMIX_SUCCESS;
 253     }
 254 
 255     if (0 > asprintf(output, "%sData type: PMIX_INT\tValue: %ld", prefx, (long) *src)) {
 256         return PMIX_ERR_NOMEM;
 257     }
 258     if (prefx != prefix) {
 259         free(prefx);
 260     }
 261 
 262     return PMIX_SUCCESS;
 263 }
 264 
 265 pmix_status_t pmix20_bfrop_print_uint(char **output, char *prefix, uint *src, pmix_data_type_t type)
 266 {
 267     char *prefx;
 268 
 269     /* deal with NULL prefix */
 270     if (NULL == prefix) {
 271         if (0 > asprintf(&prefx, " ")) {
 272             return PMIX_ERR_NOMEM;
 273         }
 274     } else {
 275         prefx = prefix;
 276     }
 277 
 278     /* if src is NULL, just print data type and return */
 279     if (NULL == src) {
 280         if (0 > asprintf(output, "%sData type: PMIX_UINT\tValue: NULL pointer", prefx)) {
 281             return PMIX_ERR_NOMEM;
 282         }
 283         if (prefx != prefix) {
 284             free(prefx);
 285         }
 286         return PMIX_SUCCESS;
 287     }
 288 
 289     if (0 > asprintf(output, "%sData type: PMIX_UINT\tValue: %lu", prefx, (unsigned long) *src)) {
 290         return PMIX_ERR_NOMEM;
 291     }
 292     if (prefx != prefix) {
 293         free(prefx);
 294     }
 295 
 296     return PMIX_SUCCESS;
 297 }
 298 
 299 pmix_status_t pmix20_bfrop_print_uint8(char **output, char *prefix, uint8_t *src, pmix_data_type_t type)
 300 {
 301     char *prefx;
 302 
 303     /* deal with NULL prefix */
 304     if (NULL == prefix) {
 305         if (0 > asprintf(&prefx, " ")) {
 306             return PMIX_ERR_NOMEM;
 307         }
 308     } else {
 309         prefx = prefix;
 310     }
 311 
 312     /* if src is NULL, just print data type and return */
 313     if (NULL == src) {
 314         if (0 > asprintf(output, "%sData type: PMIX_UINT8\tValue: NULL pointer", prefx)) {
 315             return PMIX_ERR_NOMEM;
 316         }
 317         if (prefx != prefix) {
 318             free(prefx);
 319         }
 320         return PMIX_SUCCESS;
 321     }
 322 
 323     if (0 > asprintf(output, "%sData type: PMIX_UINT8\tValue: %u", prefx, (unsigned int) *src)) {
 324         return PMIX_ERR_NOMEM;
 325     }
 326     if (prefx != prefix) {
 327         free(prefx);
 328     }
 329 
 330     return PMIX_SUCCESS;
 331 }
 332 
 333 pmix_status_t pmix20_bfrop_print_uint16(char **output, char *prefix, uint16_t *src, pmix_data_type_t type)
 334 {
 335     char *prefx;
 336 
 337     /* deal with NULL prefix */
 338     if (NULL == prefix) {
 339         if (0 > asprintf(&prefx, " ")) {
 340             return PMIX_ERR_NOMEM;
 341         }
 342     } else {
 343         prefx = prefix;
 344     }
 345 
 346     /* if src is NULL, just print data type and return */
 347     if (NULL == src) {
 348         if (0 > asprintf(output, "%sData type: PMIX_UINT16\tValue: NULL pointer", prefx)) {
 349             return PMIX_ERR_NOMEM;
 350         }
 351         if (prefx != prefix) {
 352             free(prefx);
 353         }
 354         return PMIX_SUCCESS;
 355     }
 356 
 357     if (0 > asprintf(output, "%sData type: PMIX_UINT16\tValue: %u", prefx, (unsigned int) *src)) {
 358         return PMIX_ERR_NOMEM;
 359     }
 360     if (prefx != prefix) {
 361         free(prefx);
 362     }
 363 
 364     return PMIX_SUCCESS;
 365 }
 366 
 367 pmix_status_t pmix20_bfrop_print_uint32(char **output, char *prefix,
 368                                       uint32_t *src, pmix_data_type_t type)
 369 {
 370     char *prefx;
 371 
 372     /* deal with NULL prefix */
 373     if (NULL == prefix) {
 374         if (0 > asprintf(&prefx, " ")) {
 375             return PMIX_ERR_NOMEM;
 376         }
 377     } else {
 378         prefx = prefix;
 379     }
 380 
 381     /* if src is NULL, just print data type and return */
 382     if (NULL == src) {
 383         if (0 > asprintf(output, "%sData type: PMIX_UINT32\tValue: NULL pointer", prefx)) {
 384             return PMIX_ERR_NOMEM;
 385         }
 386         if (prefx != prefix) {
 387             free(prefx);
 388         }
 389         return PMIX_SUCCESS;
 390     }
 391 
 392     if (0 > asprintf(output, "%sData type: PMIX_UINT32\tValue: %u", prefx, (unsigned int) *src)) {
 393         return PMIX_ERR_NOMEM;
 394     }
 395     if (prefx != prefix) {
 396         free(prefx);
 397     }
 398 
 399     return PMIX_SUCCESS;
 400 }
 401 
 402 pmix_status_t pmix20_bfrop_print_int8(char **output, char *prefix,
 403                                     int8_t *src, pmix_data_type_t type)
 404 {
 405     char *prefx;
 406 
 407     /* deal with NULL prefix */
 408     if (NULL == prefix) {
 409         if (0 > asprintf(&prefx, " ")) {
 410             return PMIX_ERR_NOMEM;
 411         }
 412     } else {
 413         prefx = prefix;
 414     }
 415 
 416     /* if src is NULL, just print data type and return */
 417     if (NULL == src) {
 418         if (0 > asprintf(output, "%sData type: PMIX_INT8\tValue: NULL pointer", prefx)) {
 419             return PMIX_ERR_NOMEM;
 420         }
 421         if (prefx != prefix) {
 422             free(prefx);
 423         }
 424         return PMIX_SUCCESS;
 425     }
 426 
 427     if (0 > asprintf(output, "%sData type: PMIX_INT8\tValue: %d", prefx, (int) *src)) {
 428         return PMIX_ERR_NOMEM;
 429     }
 430     if (prefx != prefix) {
 431         free(prefx);
 432     }
 433 
 434     return PMIX_SUCCESS;
 435 }
 436 
 437 pmix_status_t pmix20_bfrop_print_int16(char **output, char *prefix,
 438                                      int16_t *src, pmix_data_type_t type)
 439 {
 440     char *prefx;
 441 
 442     /* deal with NULL prefix */
 443     if (NULL == prefix) {
 444         if (0 > asprintf(&prefx, " ")) {
 445             return PMIX_ERR_NOMEM;
 446         }
 447     } else {
 448         prefx = prefix;
 449     }
 450 
 451     /* if src is NULL, just print data type and return */
 452     if (NULL == src) {
 453         if (0 > asprintf(output, "%sData type: PMIX_INT16\tValue: NULL pointer", prefx)) {
 454             return PMIX_ERR_NOMEM;
 455         }
 456         if (prefx != prefix) {
 457             free(prefx);
 458         }
 459         return PMIX_SUCCESS;
 460     }
 461 
 462     if (0 > asprintf(output, "%sData type: PMIX_INT16\tValue: %d", prefx, (int) *src)) {
 463         return PMIX_ERR_NOMEM;
 464     }
 465     if (prefx != prefix) {
 466         free(prefx);
 467     }
 468 
 469     return PMIX_SUCCESS;
 470 }
 471 
 472 pmix_status_t pmix20_bfrop_print_int32(char **output, char *prefix, int32_t *src, pmix_data_type_t type)
 473 {
 474     char *prefx;
 475 
 476     /* deal with NULL prefix */
 477     if (NULL == prefix) {
 478         if (0 > asprintf(&prefx, " ")) {
 479             return PMIX_ERR_NOMEM;
 480         }
 481     } else {
 482         prefx = prefix;
 483     }
 484 
 485     /* if src is NULL, just print data type and return */
 486     if (NULL == src) {
 487         if (0 > asprintf(output, "%sData type: PMIX_INT32\tValue: NULL pointer", prefx)) {
 488             return PMIX_ERR_NOMEM;
 489         }
 490         if (prefx != prefix) {
 491             free(prefx);
 492         }
 493         return PMIX_SUCCESS;
 494     }
 495 
 496     if (0 > asprintf(output, "%sData type: PMIX_INT32\tValue: %d", prefx, (int) *src)) {
 497         return PMIX_ERR_NOMEM;
 498     }
 499     if (prefx != prefix) {
 500         free(prefx);
 501     }
 502 
 503     return PMIX_SUCCESS;
 504 }
 505 pmix_status_t pmix20_bfrop_print_uint64(char **output, char *prefix,
 506                                       uint64_t *src,
 507                                       pmix_data_type_t type)
 508 {
 509     char *prefx;
 510 
 511     /* deal with NULL prefix */
 512     if (NULL == prefix) {
 513         if (0 > asprintf(&prefx, " ")) {
 514             return PMIX_ERR_NOMEM;
 515         }
 516     } else {
 517         prefx = prefix;
 518     }
 519 
 520     /* if src is NULL, just print data type and return */
 521     if (NULL == src) {
 522         if (0 > asprintf(output, "%sData type: PMIX_UINT64\tValue: NULL pointer", prefx)) {
 523             return PMIX_ERR_NOMEM;
 524         }
 525         if (prefx != prefix) {
 526             free(prefx);
 527         }
 528         return PMIX_SUCCESS;
 529     }
 530 
 531     if (0 > asprintf(output, "%sData type: PMIX_UINT64\tValue: %lu", prefx, (unsigned long) *src)) {
 532         return PMIX_ERR_NOMEM;
 533     }
 534     if (prefx != prefix) {
 535         free(prefx);
 536     }
 537 
 538     return PMIX_SUCCESS;
 539 }
 540 
 541 pmix_status_t pmix20_bfrop_print_int64(char **output, char *prefix,
 542                                      int64_t *src,
 543                                      pmix_data_type_t type)
 544 {
 545     char *prefx;
 546 
 547     /* deal with NULL prefix */
 548     if (NULL == prefix) {
 549         if (0 > asprintf(&prefx, " ")) {
 550             return PMIX_ERR_NOMEM;
 551         }
 552     } else {
 553         prefx = prefix;
 554     }
 555 
 556     /* if src is NULL, just print data type and return */
 557     if (NULL == src) {
 558         if (0 > asprintf(output, "%sData type: PMIX_INT64\tValue: NULL pointer", prefx)) {
 559             return PMIX_ERR_NOMEM;
 560         }
 561         if (prefx != prefix) {
 562             free(prefx);
 563         }
 564         return PMIX_SUCCESS;
 565     }
 566 
 567     if (0 > asprintf(output, "%sData type: PMIX_INT64\tValue: %ld", prefx, (long) *src)) {
 568         return PMIX_ERR_NOMEM;
 569     }
 570     if (prefx != prefix) {
 571         free(prefx);
 572     }
 573 
 574     return PMIX_SUCCESS;
 575 }
 576 
 577 pmix_status_t pmix20_bfrop_print_float(char **output, char *prefix,
 578                                      float *src, pmix_data_type_t type)
 579 {
 580     char *prefx;
 581 
 582     /* deal with NULL prefix */
 583     if (NULL == prefix) {
 584         if (0 > asprintf(&prefx, " ")) {
 585             return PMIX_ERR_NOMEM;
 586         }
 587     } else {
 588         prefx = prefix;
 589     }
 590 
 591     /* if src is NULL, just print data type and return */
 592     if (NULL == src) {
 593         if (0 > asprintf(output, "%sData type: PMIX_FLOAT\tValue: NULL pointer", prefx)) {
 594             return PMIX_ERR_NOMEM;
 595         }
 596         if (prefx != prefix) {
 597             free(prefx);
 598         }
 599         return PMIX_SUCCESS;
 600     }
 601 
 602     if (0 > asprintf(output, "%sData type: PMIX_FLOAT\tValue: %f", prefx, *src)) {
 603         return PMIX_ERR_NOMEM;
 604     }
 605     if (prefx != prefix) {
 606         free(prefx);
 607     }
 608 
 609     return PMIX_SUCCESS;
 610 }
 611 
 612 pmix_status_t pmix20_bfrop_print_double(char **output, char *prefix,
 613                                       double *src, pmix_data_type_t type)
 614 {
 615     char *prefx;
 616 
 617     /* deal with NULL prefix */
 618     if (NULL == prefix) {
 619         if (0 > asprintf(&prefx, " ")) {
 620             return PMIX_ERR_NOMEM;
 621         }
 622     } else {
 623         prefx = prefix;
 624     }
 625 
 626     /* if src is NULL, just print data type and return */
 627     if (NULL == src) {
 628         if (0 > asprintf(output, "%sData type: PMIX_DOUBLE\tValue: NULL pointer", prefx)) {
 629             return PMIX_ERR_NOMEM;
 630         }
 631         if (prefx != prefix) {
 632             free(prefx);
 633         }
 634         return PMIX_SUCCESS;
 635     }
 636 
 637     if (0 > asprintf(output, "%sData type: PMIX_DOUBLE\tValue: %f", prefx, *src)) {
 638         return PMIX_ERR_NOMEM;
 639     }
 640     if (prefx != prefix) {
 641         free(prefx);
 642     }
 643 
 644     return PMIX_SUCCESS;
 645 }
 646 
 647 pmix_status_t pmix20_bfrop_print_time(char **output, char *prefix,
 648                                     time_t *src, pmix_data_type_t type)
 649 {
 650     char *prefx;
 651     char *t;
 652 
 653     /* deal with NULL prefix */
 654     if (NULL == prefix) {
 655         if (0 > asprintf(&prefx, " ")) {
 656             return PMIX_ERR_NOMEM;
 657         }
 658     } else {
 659         prefx = prefix;
 660     }
 661 
 662     /* if src is NULL, just print data type and return */
 663     if (NULL == src) {
 664         if (0 > asprintf(output, "%sData type: PMIX_TIME\tValue: NULL pointer", prefx)) {
 665             return PMIX_ERR_NOMEM;
 666         }
 667         if (prefx != prefix) {
 668             free(prefx);
 669         }
 670         return PMIX_SUCCESS;
 671     }
 672 
 673     t = ctime(src);
 674     t[strlen(t)-1] = '\0';  // remove trailing newline
 675 
 676     if (0 > asprintf(output, "%sData type: PMIX_TIME\tValue: %s", prefx, t)) {
 677         return PMIX_ERR_NOMEM;
 678     }
 679     if (prefx != prefix) {
 680         free(prefx);
 681     }
 682 
 683     return PMIX_SUCCESS;
 684 }
 685 
 686 pmix_status_t pmix20_bfrop_print_timeval(char **output, char *prefix,
 687                                        struct timeval *src, pmix_data_type_t type)
 688 {
 689     char *prefx;
 690 
 691     /* deal with NULL prefix */
 692     if (NULL == prefix) {
 693         if (0 > asprintf(&prefx, " ")) {
 694             return PMIX_ERR_NOMEM;
 695         }
 696     } else {
 697         prefx = prefix;
 698     }
 699 
 700     /* if src is NULL, just print data type and return */
 701     if (NULL == src) {
 702         if (0 > asprintf(output, "%sData type: PMIX_TIMEVAL\tValue: NULL pointer", prefx)) {
 703             return PMIX_ERR_NOMEM;
 704         }
 705         if (prefx != prefix) {
 706             free(prefx);
 707         }
 708         return PMIX_SUCCESS;
 709     }
 710 
 711     if (0 > asprintf(output, "%sData type: PMIX_TIMEVAL\tValue: %ld.%06ld", prefx,
 712                      (long)src->tv_sec, (long)src->tv_usec)) {
 713         return PMIX_ERR_NOMEM;
 714 }
 715 if (prefx != prefix) {
 716     free(prefx);
 717 }
 718 
 719 return PMIX_SUCCESS;
 720 }
 721 
 722 pmix_status_t pmix20_bfrop_print_status(char **output, char *prefix,
 723                                       pmix_status_t *src, pmix_data_type_t type)
 724 {
 725     char *prefx;
 726 
 727     /* deal with NULL prefix */
 728     if (NULL == prefix) {
 729         if (0 > asprintf(&prefx, " ")) {
 730             return PMIX_ERR_NOMEM;
 731         }
 732     } else {
 733         prefx = prefix;
 734     }
 735 
 736     /* if src is NULL, just print data type and return */
 737     if (NULL == src) {
 738         if (0 > asprintf(output, "%sData type: PMIX_STATUS\tValue: NULL pointer", prefx)) {
 739             return PMIX_ERR_NOMEM;
 740         }
 741         if (prefx != prefix) {
 742             free(prefx);
 743         }
 744         return PMIX_SUCCESS;
 745     }
 746 
 747     if (0 > asprintf(output, "%sData type: PMIX_STATUS\tValue: %s", prefx, PMIx_Error_string(*src))) {
 748         return PMIX_ERR_NOMEM;
 749     }
 750     if (prefx != prefix) {
 751         free(prefx);
 752     }
 753 
 754     return PMIX_SUCCESS;
 755 }
 756 
 757 
 758 /* PRINT FUNCTIONS FOR GENERIC PMIX TYPES */
 759 
 760 /*
 761  * PMIX_VALUE
 762  */
 763  pmix_status_t pmix20_bfrop_print_value(char **output, char *prefix,
 764                                         pmix_value_t *src, pmix_data_type_t type)
 765  {
 766     char *prefx;
 767     int rc;
 768 
 769     /* deal with NULL prefix */
 770     if (NULL == prefix) {
 771         if (0 > asprintf(&prefx, " ")) {
 772             return PMIX_ERR_NOMEM;
 773         }
 774     } else {
 775         prefx = prefix;
 776     }
 777 
 778     /* if src is NULL, just print data type and return */
 779     if (NULL == src) {
 780         if (0 > asprintf(output, "%sData type: PMIX_VALUE\tValue: NULL pointer", prefx)) {
 781             return PMIX_ERR_NOMEM;
 782         }
 783         if (prefx != prefix) {
 784             free(prefx);
 785         }
 786         return PMIX_SUCCESS;
 787     }
 788 
 789     switch (src->type) {
 790         case PMIX_UNDEF:
 791         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UNDEF", prefx);
 792         break;
 793         case PMIX_BYTE:
 794         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_BYTE\tValue: %x",
 795                       prefx, src->data.byte);
 796         break;
 797         case PMIX_STRING:
 798         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_STRING\tValue: %s",
 799                       prefx, src->data.string);
 800         break;
 801         case PMIX_SIZE:
 802         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_SIZE\tValue: %lu",
 803                       prefx, (unsigned long)src->data.size);
 804         break;
 805         case PMIX_PID:
 806         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_PID\tValue: %lu",
 807                       prefx, (unsigned long)src->data.pid);
 808         break;
 809         case PMIX_INT:
 810         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_INT\tValue: %d",
 811                       prefx, src->data.integer);
 812         break;
 813         case PMIX_INT8:
 814         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_INT8\tValue: %d",
 815                       prefx, (int)src->data.int8);
 816         break;
 817         case PMIX_INT16:
 818         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_INT16\tValue: %d",
 819                       prefx, (int)src->data.int16);
 820         break;
 821         case PMIX_INT32:
 822         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_INT32\tValue: %d",
 823                       prefx, src->data.int32);
 824         break;
 825         case PMIX_INT64:
 826         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_INT64\tValue: %ld",
 827                       prefx, (long)src->data.int64);
 828         break;
 829         case PMIX_UINT:
 830         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UINT\tValue: %u",
 831                       prefx, src->data.uint);
 832         break;
 833         case PMIX_UINT8:
 834         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UINT8\tValue: %u",
 835                       prefx, (unsigned int)src->data.uint8);
 836         break;
 837         case PMIX_UINT16:
 838         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UINT16\tValue: %u",
 839                       prefx, (unsigned int)src->data.uint16);
 840         break;
 841         case PMIX_UINT32:
 842         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UINT32\tValue: %u",
 843                       prefx, src->data.uint32);
 844         break;
 845         case PMIX_UINT64:
 846         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UINT64\tValue: %lu",
 847                       prefx, (unsigned long)src->data.uint64);
 848         break;
 849         case PMIX_FLOAT:
 850         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_FLOAT\tValue: %f",
 851                       prefx, src->data.fval);
 852         break;
 853         case PMIX_DOUBLE:
 854         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_DOUBLE\tValue: %f",
 855                       prefx, src->data.dval);
 856         break;
 857         case PMIX_TIMEVAL:
 858         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_TIMEVAL\tValue: %ld.%06ld", prefx,
 859                       (long)src->data.tv.tv_sec, (long)src->data.tv.tv_usec);
 860         break;
 861         case PMIX_TIME:
 862         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_TIME\tValue: %s", prefx,
 863                       ctime(&src->data.time));
 864         break;
 865         case PMIX_STATUS:
 866         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_STATUS\tValue: %s", prefx,
 867                       PMIx_Error_string(src->data.status));
 868         break;
 869         case PMIX_PROC:
 870         if (NULL == src->data.proc) {
 871             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_PROC\tNULL", prefx);
 872         } else {
 873             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_PROC\t%s:%lu",
 874                           prefx, src->data.proc->nspace, (unsigned long)src->data.proc->rank);
 875         }
 876         break;
 877         case PMIX_BYTE_OBJECT:
 878         rc = asprintf(output, "%sPMIX_VALUE: Data type: BYTE_OBJECT\tSIZE: %ld",
 879                       prefx, (long)src->data.bo.size);
 880         break;
 881         case PMIX_PERSIST:
 882         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_PERSIST\tValue: %s",
 883                       prefx, PMIx_Persistence_string(src->data.persist));
 884         break;
 885         case PMIX_SCOPE:
 886         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_SCOPE\tValue: %s",
 887                       prefx, PMIx_Scope_string(src->data.scope));
 888         break;
 889         case PMIX_DATA_RANGE:
 890         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_DATA_RANGE\tValue: %s",
 891                       prefx, PMIx_Data_range_string(src->data.range));
 892         break;
 893         case PMIX_PROC_STATE:
 894         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_STATE\tValue: %s",
 895                       prefx, PMIx_Proc_state_string(src->data.state));
 896         break;
 897         case PMIX_PROC_INFO:
 898         rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_PROC_INFO\tProc: %s:%lu\n%s\tHost: %s\tExecutable: %s\tPid: %lu",
 899                       prefx, src->data.pinfo->proc.nspace, (unsigned long)src->data.pinfo->proc.rank,
 900                       prefx, src->data.pinfo->hostname, src->data.pinfo->executable_name,
 901                       (unsigned long)src->data.pinfo->pid);
 902         break;
 903         case PMIX_DATA_ARRAY:
 904         rc = asprintf(output, "%sPMIX_VALUE: Data type: DATA_ARRAY\tARRAY SIZE: %ld",
 905                       prefx, (long)src->data.darray->size);
 906         break;
 907         default:
 908         rc = asprintf(output, "%sPMIX_VALUE: Data type: UNKNOWN\tValue: UNPRINTABLE", prefx);
 909         break;
 910     }
 911     if (prefx != prefix) {
 912         free(prefx);
 913     }
 914     if (0 > rc) {
 915         return PMIX_ERR_NOMEM;
 916     }
 917     return PMIX_SUCCESS;
 918 }
 919 
 920 pmix_status_t pmix20_bfrop_print_info(char **output, char *prefix,
 921                                     pmix_info_t *src, pmix_data_type_t type)
 922 {
 923     char *tmp;
 924     int rc;
 925 
 926     pmix20_bfrop_print_value(&tmp, NULL, &src->value, PMIX_VALUE);
 927     rc = asprintf(output, "%sKEY: %s DIRECTIVES: %0x %s", prefix, src->key,
 928                   src->flags, (NULL == tmp) ? "PMIX_VALUE: NULL" : tmp);
 929     if (NULL != tmp) {
 930         free(tmp);
 931     }
 932     if (0 > rc) {
 933         return PMIX_ERR_NOMEM;
 934     }
 935     return PMIX_SUCCESS;
 936 }
 937 
 938 pmix_status_t pmix20_bfrop_print_pdata(char **output, char *prefix,
 939                                      pmix_pdata_t *src, pmix_data_type_t type)
 940 {
 941     char *tmp1, *tmp2;
 942     int rc;
 943 
 944     pmix20_bfrop_print_proc(&tmp1, NULL, &src->proc, PMIX_PROC);
 945     pmix20_bfrop_print_value(&tmp2, NULL, &src->value, PMIX_VALUE);
 946     rc = asprintf(output, "%s  %s  KEY: %s %s", prefix, tmp1, src->key,
 947                   (NULL == tmp2) ? "NULL" : tmp2);
 948     if (NULL != tmp1) {
 949         free(tmp1);
 950     }
 951     if (NULL != tmp2) {
 952         free(tmp2);
 953     }
 954     if (0 > rc) {
 955         return PMIX_ERR_NOMEM;
 956     }
 957     return PMIX_SUCCESS;
 958 }
 959 
 960 pmix_status_t pmix20_bfrop_print_buf(char **output, char *prefix,
 961                                    pmix_buffer_t *src, pmix_data_type_t type)
 962 {
 963     return PMIX_SUCCESS;
 964 }
 965 
 966 pmix_status_t pmix20_bfrop_print_app(char **output, char *prefix,
 967                                    pmix_app_t *src, pmix_data_type_t type)
 968 {
 969     return PMIX_SUCCESS;
 970 }
 971 
 972 pmix_status_t pmix20_bfrop_print_proc(char **output, char *prefix,
 973                                     pmix_proc_t *src, pmix_data_type_t type)
 974 {
 975     char *prefx;
 976     int rc;
 977 
 978     /* deal with NULL prefix */
 979     if (NULL == prefix) {
 980         if (0 > asprintf(&prefx, " ")) {
 981             return PMIX_ERR_NOMEM;
 982         }
 983     } else {
 984         prefx = prefix;
 985     }
 986 
 987     switch(src->rank) {
 988         case PMIX_RANK_UNDEF:
 989             rc = asprintf(output,
 990                           "%sPROC: %s:PMIX_RANK_UNDEF", prefx, src->nspace);
 991             break;
 992         case PMIX_RANK_WILDCARD:
 993             rc = asprintf(output,
 994                           "%sPROC: %s:PMIX_RANK_WILDCARD", prefx, src->nspace);
 995             break;
 996         case PMIX_RANK_LOCAL_NODE:
 997             rc = asprintf(output,
 998                           "%sPROC: %s:PMIX_RANK_LOCAL_NODE", prefx, src->nspace);
 999             break;
1000         default:
1001             rc = asprintf(output,
1002                           "%sPROC: %s:%lu", prefx, src->nspace,
1003                           (unsigned long)(src->rank));
1004     }
1005     if (prefx != prefix) {
1006         free(prefx);
1007     }
1008     if (0 > rc) {
1009         return PMIX_ERR_NOMEM;
1010     }
1011     return PMIX_SUCCESS;
1012 }
1013 
1014 pmix_status_t pmix20_bfrop_print_kval(char **output, char *prefix,
1015                                     pmix_kval_t *src, pmix_data_type_t type)
1016 {
1017     return PMIX_SUCCESS;
1018 }
1019 
1020 pmix_status_t pmix20_bfrop_print_modex(char **output, char *prefix,
1021                                      pmix_modex_data_t *src, pmix_data_type_t type)
1022 {
1023     return PMIX_SUCCESS;
1024 }
1025 
1026 pmix_status_t pmix20_bfrop_print_persist(char **output, char *prefix, pmix_persistence_t *src, pmix_data_type_t type)
1027 {
1028     char *prefx;
1029 
1030     /* deal with NULL prefix */
1031     if (NULL == prefix) {
1032         if (0 > asprintf(&prefx, " ")) {
1033             return PMIX_ERR_NOMEM;
1034         }
1035     } else {
1036         prefx = prefix;
1037     }
1038 
1039     /* if src is NULL, just print data type and return */
1040     if (NULL == src) {
1041         if (0 > asprintf(output, "%sData type: PMIX_PERSIST\tValue: NULL pointer", prefx)) {
1042             return PMIX_ERR_NOMEM;
1043         }
1044         if (prefx != prefix) {
1045             free(prefx);
1046         }
1047         return PMIX_SUCCESS;
1048     }
1049 
1050     if (0 > asprintf(output, "%sData type: PMIX_PERSIST\tValue: %ld", prefx, (long) *src)) {
1051         return PMIX_ERR_NOMEM;
1052     }
1053     if (prefx != prefix) {
1054         free(prefx);
1055     }
1056 
1057     return PMIX_SUCCESS;
1058 }
1059 
1060 pmix_status_t pmix20_bfrop_print_scope(char **output, char *prefix,
1061                                      pmix_scope_t *src,
1062                                      pmix_data_type_t type)
1063 {
1064     char *prefx;
1065 
1066     /* deal with NULL prefix */
1067     if (NULL == prefix) {
1068         if (0 > asprintf(&prefx, " ")) {
1069             return PMIX_ERR_NOMEM;
1070         }
1071     } else {
1072         prefx = prefix;
1073     }
1074 
1075     if (0 > asprintf(output, "%sData type: PMIX_SCOPE\tValue: %s",
1076                      prefx, PMIx_Scope_string(*src))) {
1077         return PMIX_ERR_NOMEM;
1078     }
1079     if (prefx != prefix) {
1080         free(prefx);
1081     }
1082 
1083     return PMIX_SUCCESS;
1084 }
1085 
1086 pmix_status_t pmix20_bfrop_print_range(char **output, char *prefix,
1087                                      pmix_data_range_t *src,
1088                                      pmix_data_type_t type)
1089 {
1090     char *prefx;
1091 
1092     /* deal with NULL prefix */
1093     if (NULL == prefix) {
1094         if (0 > asprintf(&prefx, " ")) {
1095             return PMIX_ERR_NOMEM;
1096         }
1097     } else {
1098         prefx = prefix;
1099     }
1100 
1101     if (0 > asprintf(output, "%sData type: PMIX_DATA_RANGE\tValue: %s",
1102                      prefx, PMIx_Data_range_string(*src))) {
1103         return PMIX_ERR_NOMEM;
1104     }
1105     if (prefx != prefix) {
1106         free(prefx);
1107     }
1108 
1109     return PMIX_SUCCESS;
1110 }
1111 
1112 pmix_status_t pmix20_bfrop_print_cmd(char **output, char *prefix,
1113                                    pmix_cmd_t *src,
1114                                    pmix_data_type_t type)
1115 {
1116     char *prefx;
1117 
1118     /* deal with NULL prefix */
1119     if (NULL == prefix) {
1120         if (0 > asprintf(&prefx, " ")) {
1121             return PMIX_ERR_NOMEM;
1122         }
1123     } else {
1124         prefx = prefix;
1125     }
1126 
1127     if (0 > asprintf(output, "%sData type: PMIX_CMD\tValue: %s",
1128                      prefx, pmix_command_string(*src))) {
1129         return PMIX_ERR_NOMEM;
1130     }
1131     if (prefx != prefix) {
1132         free(prefx);
1133     }
1134 
1135     return PMIX_SUCCESS;
1136 }
1137 
1138 pmix_status_t pmix20_bfrop_print_infodirs(char **output, char *prefix,
1139                                         pmix_info_directives_t *src,
1140                                         pmix_data_type_t type)
1141 {
1142     char *prefx;
1143 
1144     /* deal with NULL prefix */
1145     if (NULL == prefix) {
1146         if (0 > asprintf(&prefx, " ")) {
1147             return PMIX_ERR_NOMEM;
1148         }
1149     } else {
1150         prefx = prefix;
1151     }
1152 
1153     if (0 > asprintf(output, "%sData type: PMIX_INFO_DIRECTIVES\tValue: %s",
1154                      prefx, PMIx_Info_directives_string(*src))) {
1155         return PMIX_ERR_NOMEM;
1156     }
1157     if (prefx != prefix) {
1158         free(prefx);
1159     }
1160 
1161     return PMIX_SUCCESS;
1162 }
1163 
1164 pmix_status_t pmix20_bfrop_print_bo(char **output, char *prefix,
1165                                   pmix_byte_object_t *src, pmix_data_type_t type)
1166 {
1167     char *prefx;
1168 
1169     /* deal with NULL prefix */
1170     if (NULL == prefix) {
1171         if (0 > asprintf(&prefx, " ")) {
1172             return PMIX_ERR_NOMEM;
1173         }
1174     } else {
1175         prefx = prefix;
1176     }
1177 
1178     /* if src is NULL, just print data type and return */
1179     if (NULL == src) {
1180         if (0 > asprintf(output, "%sData type: PMIX_BYTE_OBJECT\tValue: NULL pointer", prefx)) {
1181             return PMIX_ERR_NOMEM;
1182         }
1183         if (prefx != prefix) {
1184             free(prefx);
1185         }
1186         return PMIX_SUCCESS;
1187     }
1188 
1189     if (0 > asprintf(output, "%sData type: PMIX_BYTE_OBJECT\tSize: %ld", prefx, (long)src->size)) {
1190         return PMIX_ERR_NOMEM;
1191     }
1192     if (prefx != prefix) {
1193         free(prefx);
1194     }
1195 
1196     return PMIX_SUCCESS;
1197 }
1198 
1199 pmix_status_t pmix20_bfrop_print_ptr(char **output, char *prefix,
1200                                    void *src, pmix_data_type_t type)
1201 {
1202     char *prefx;
1203 
1204     /* deal with NULL prefix */
1205     if (NULL == prefix) {
1206         if (0 > asprintf(&prefx, " ")) {
1207             return PMIX_ERR_NOMEM;
1208         }
1209     } else {
1210         prefx = prefix;
1211     }
1212 
1213     if (0 > asprintf(output, "%sData type: PMIX_POINTER\tAddress: %p", prefx, src)) {
1214         return PMIX_ERR_NOMEM;
1215     }
1216     if (prefx != prefix) {
1217         free(prefx);
1218     }
1219 
1220     return PMIX_SUCCESS;
1221 }
1222 
1223 pmix_status_t pmix20_bfrop_print_pstate(char **output, char *prefix,
1224                                       pmix_proc_state_t *src, pmix_data_type_t type)
1225 {
1226     char *prefx;
1227 
1228     /* deal with NULL prefix */
1229     if (NULL == prefix) {
1230         if (0 > asprintf(&prefx, " ")) {
1231             return PMIX_ERR_NOMEM;
1232         }
1233     } else {
1234         prefx = prefix;
1235     }
1236 
1237     if (0 > asprintf(output, "%sData type: PMIX_PROC_STATE\tValue: %s",
1238                      prefx, PMIx_Proc_state_string(*src))) {
1239         return PMIX_ERR_NOMEM;
1240     }
1241     if (prefx != prefix) {
1242         free(prefx);
1243     }
1244 
1245     return PMIX_SUCCESS;
1246 }
1247 
1248 pmix_status_t pmix20_bfrop_print_pinfo(char **output, char *prefix,
1249                                      pmix_proc_info_t *src, pmix_data_type_t type)
1250 {
1251     char *prefx;
1252     pmix_status_t rc = PMIX_SUCCESS;
1253     char *p2, *tmp;
1254 
1255     /* deal with NULL prefix */
1256     if (NULL == prefix) {
1257         if (0 > asprintf(&prefx, " ")) {
1258             return PMIX_ERR_NOMEM;
1259         }
1260     } else {
1261         prefx = prefix;
1262     }
1263 
1264     if (0 > asprintf(&p2, "%s\t", prefx)) {
1265         rc = PMIX_ERR_NOMEM;
1266         goto done;
1267     }
1268 
1269     if (PMIX_SUCCESS != (rc = pmix20_bfrop_print_proc(&tmp, p2, &src->proc, PMIX_PROC))) {
1270         free(p2);
1271         goto done;
1272     }
1273 
1274     if (0 > asprintf(output,
1275                      "%sData type: PMIX_PROC_INFO\tValue:\n%s\n%sHostname: %s\tExecutable: %s\n%sPid: %lu\tExit code: %d\tState: %s",
1276                      prefx, tmp, p2, src->hostname, src->executable_name,
1277                      p2, (unsigned long)src->pid, src->exit_code, PMIx_Proc_state_string(src->state))) {
1278         free(p2);
1279         rc = PMIX_ERR_NOMEM;
1280     }
1281 
1282   done:
1283     if (prefx != prefix) {
1284         free(prefx);
1285     }
1286 
1287     return rc;
1288 }
1289 
1290 pmix_status_t pmix20_bfrop_print_darray(char **output, char *prefix,
1291                                       pmix_data_array_t *src, pmix_data_type_t type)
1292 {
1293     char *prefx;
1294 
1295     /* deal with NULL prefix */
1296     if (NULL == prefix) {
1297         if (0 > asprintf(&prefx, " ")) {
1298             return PMIX_ERR_NOMEM;
1299         }
1300     } else {
1301         prefx = prefix;
1302     }
1303 
1304     if (0 > asprintf(output, "%sData type: PMIX_DATA_ARRAY\tSize: %lu",
1305                      prefx, (unsigned long)src->size)) {
1306         return PMIX_ERR_NOMEM;
1307     }
1308     if (prefx != prefix) {
1309         free(prefx);
1310     }
1311 
1312     return PMIX_SUCCESS;
1313 }
1314 
1315 pmix_status_t pmix20_bfrop_print_query(char **output, char *prefix,
1316                                      pmix_query_t *src, pmix_data_type_t type)
1317 {
1318     char *prefx, *p2;
1319     pmix_status_t rc = PMIX_SUCCESS;
1320     char *tmp, *t2, *t3;
1321     size_t n;
1322 
1323     /* deal with NULL prefix */
1324     if (NULL == prefix) {
1325         if (0 > asprintf(&prefx, " ")) {
1326             return PMIX_ERR_NOMEM;
1327         }
1328     } else {
1329         prefx = prefix;
1330     }
1331 
1332     if (0 > asprintf(&p2, "%s\t", prefx)) {
1333         rc = PMIX_ERR_NOMEM;
1334         goto done;
1335     }
1336 
1337     if (0 > asprintf(&tmp,
1338                    "%sData type: PMIX_QUERY\tValue:", prefx)) {
1339         free(p2);
1340         rc = PMIX_ERR_NOMEM;
1341         goto done;
1342     }
1343 
1344     /* print out the keys */
1345     if (NULL != src->keys) {
1346         for (n=0; NULL != src->keys[n]; n++) {
1347             if (0 > asprintf(&t2, "%s\n%sKey: %s", tmp, p2, src->keys[n])) {
1348                 free(p2);
1349                 free(tmp);
1350                 rc = PMIX_ERR_NOMEM;
1351                 goto done;
1352             }
1353             free(tmp);
1354             tmp = t2;
1355         }
1356     }
1357 
1358     /* now print the qualifiers */
1359     if (0 < src->nqual) {
1360         for (n=0; n < src->nqual; n++) {
1361             if (PMIX_SUCCESS != (rc = pmix20_bfrop_print_info(&t2, p2, &src->qualifiers[n], PMIX_PROC))) {
1362                 free(p2);
1363                 goto done;
1364             }
1365             if (0 > asprintf(&t3, "%s\n%s", tmp, t2)) {
1366                 free(p2);
1367                 free(tmp);
1368                 free(t2);
1369                 rc = PMIX_ERR_NOMEM;
1370                 goto done;
1371             }
1372             free(tmp);
1373             free(t2);
1374             tmp = t3;
1375         }
1376     }
1377     *output = tmp;
1378 
1379   done:
1380     if (prefx != prefix) {
1381         free(prefx);
1382     }
1383 
1384     return rc;
1385 }
1386 
1387 pmix_status_t pmix20_bfrop_print_rank(char **output, char *prefix,
1388                                     pmix_rank_t *src, pmix_data_type_t type)
1389 {
1390     char *prefx;
1391     int rc;
1392 
1393     /* deal with NULL prefix */
1394     if (NULL == prefix) {
1395         if (0 > asprintf(&prefx, " ")) {
1396             return PMIX_ERR_NOMEM;
1397         }
1398     } else {
1399         prefx = prefix;
1400     }
1401 
1402     switch(*src) {
1403         case PMIX_RANK_UNDEF:
1404             rc = asprintf(output,
1405                           "%sData type: PMIX_PROC_RANK\tValue: PMIX_RANK_UNDEF",
1406                           prefx);
1407             break;
1408         case PMIX_RANK_WILDCARD:
1409             rc = asprintf(output,
1410                           "%sData type: PMIX_PROC_RANK\tValue: PMIX_RANK_WILDCARD",
1411                           prefx);
1412             break;
1413         case PMIX_RANK_LOCAL_NODE:
1414             rc = asprintf(output,
1415                           "%sData type: PMIX_PROC_RANK\tValue: PMIX_RANK_LOCAL_NODE",
1416                           prefx);
1417             break;
1418         default:
1419             rc = asprintf(output, "%sData type: PMIX_PROC_RANK\tValue: %lu",
1420                           prefx, (unsigned long)(*src));
1421     }
1422     if (prefx != prefix) {
1423         free(prefx);
1424     }
1425     if (0 > rc) {
1426         return PMIX_ERR_NOMEM;
1427     }
1428     return PMIX_SUCCESS;
1429 }
1430 
1431 pmix_status_t pmix20_bfrop_print_alloc_directive(char **output, char *prefix,
1432                                                pmix_alloc_directive_t *src,
1433                                                pmix_data_type_t type)
1434 {
1435     char *prefx;
1436 
1437     /* deal with NULL prefix */
1438     if (NULL == prefix) {
1439         if (0 > asprintf(&prefx, " ")) {
1440             return PMIX_ERR_NOMEM;
1441         }
1442     } else {
1443         prefx = prefix;
1444     }
1445 
1446     if (0 > asprintf(output, "%sData type: PMIX_ALLOC_DIRECTIVE\tValue: %s",
1447                      prefx, PMIx_Alloc_directive_string(*src))) {
1448         return PMIX_ERR_NOMEM;
1449     }
1450     if (prefx != prefix) {
1451         free(prefx);
1452     }
1453 
1454     return PMIX_SUCCESS;
1455 }
1456 
1457 
1458 /**** DEPRECATED ****/
1459 pmix_status_t pmix20_bfrop_print_array(char **output, char *prefix,
1460                                      pmix_info_array_t *src, pmix_data_type_t type)
1461 {
1462     size_t j;
1463     char *tmp, *tmp2, *tmp3, *pfx;
1464     pmix_info_t *s1;
1465 
1466     if (0 > asprintf(&tmp, "%sARRAY SIZE: %ld", prefix, (long)src->size)) {
1467         return PMIX_ERR_NOMEM;
1468     }
1469     if (0 > asprintf(&pfx, "\n%s\t",  (NULL == prefix) ? "" : prefix)) {
1470         free(tmp);
1471         return PMIX_ERR_NOMEM;
1472     }
1473     s1 = (pmix_info_t*)src->array;
1474 
1475     for (j=0; j < src->size; j++) {
1476         pmix20_bfrop_print_info(&tmp2, pfx, &s1[j], PMIX_INFO);
1477         if (0 > asprintf(&tmp3, "%s%s", tmp, tmp2)) {
1478             free(tmp);
1479             free(tmp2);
1480             return PMIX_ERR_NOMEM;
1481         }
1482         free(tmp);
1483         free(tmp2);
1484         tmp = tmp3;
1485     }
1486     *output = tmp;
1487     return PMIX_SUCCESS;
1488 }
1489 /********************/
/* [<][>][^][v][top][bottom][index][help] */
root/opal/mca/pmix/pmix4x/pmix/src/mca/bfrops/v20/print.c

DEFINITIONS
