opal/mca/pmix/pmix4x/pmix/src/mca/bfrops/base/bfrop_base

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
pmix_bfrops_base_print
pmix_bfrops_base_print_bool
pmix_bfrops_base_print_byte
pmix_bfrops_base_print_string
pmix_bfrops_base_print_size
pmix_bfrops_base_print_pid
pmix_bfrops_base_print_int
pmix_bfrops_base_print_uint
pmix_bfrops_base_print_uint8
pmix_bfrops_base_print_uint16
pmix_bfrops_base_print_uint32
pmix_bfrops_base_print_int8
pmix_bfrops_base_print_int16
pmix_bfrops_base_print_int32
pmix_bfrops_base_print_uint64
pmix_bfrops_base_print_int64
pmix_bfrops_base_print_float
pmix_bfrops_base_print_double
pmix_bfrops_base_print_time
pmix_bfrops_base_print_timeval
pmix_bfrops_base_print_status
pmix_bfrops_base_print_value
pmix_bfrops_base_print_info
pmix_bfrops_base_print_pdata
pmix_bfrops_base_print_buf
pmix_bfrops_base_print_app
pmix_bfrops_base_print_proc
pmix_bfrops_base_print_kval
pmix_bfrops_base_print_persist
pmix_bfrops_base_print_scope
pmix_bfrops_base_print_range
pmix_bfrops_base_print_cmd
pmix_bfrops_base_print_info_directives
pmix_bfrops_base_print_datatype
pmix_bfrops_base_print_bo
pmix_bfrops_base_print_ptr
pmix_bfrops_base_print_pstate
pmix_bfrops_base_print_pinfo
pmix_bfrops_base_print_darray
pmix_bfrops_base_print_query
pmix_bfrops_base_print_rank
pmix_bfrops_base_print_alloc_directive
pmix_bfrops_base_print_iof_channel
pmix_bfrops_base_print_envar
pmix_bfrops_base_print_coord
pmix_bfrops_base_print_regattr
   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-2019 Intel, Inc.  All rights reserved.
  14  * Copyright (c) 2016      Mellanox Technologies, Inc.
  15  *                         All rights reserved.
  16  *
  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 
  35 #include "src/include/pmix_globals.h"
  36 #include "src/mca/bfrops/base/base.h"
  37 
  38 pmix_status_t pmix_bfrops_base_print(pmix_pointer_array_t *regtypes,
  39                                      char **output, char *prefix,
  40                                      void *src, pmix_data_type_t type)
  41 {
  42     pmix_bfrop_type_info_t *info;
  43 
  44     /* check for error */
  45     if (NULL == output || NULL == src) {
  46         return PMIX_ERR_BAD_PARAM;
  47     }
  48 
  49     /* Lookup the print function for this type and call it */
  50 
  51     if(NULL == (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(regtypes, type))) {
  52         return PMIX_ERR_UNKNOWN_DATA_TYPE;
  53     }
  54 
  55     return info->odti_print_fn(output, prefix, src, type);
  56 }
  57 
  58 /*
  59  * STANDARD PRINT FUNCTIONS FOR SYSTEM TYPES
  60  */
  61 int pmix_bfrops_base_print_bool(char **output, char *prefix,
  62                                 bool *src, pmix_data_type_t type)
  63 {
  64     char *prefx;
  65     int ret;
  66 
  67     /* deal with NULL prefix */
  68     if (NULL == prefix) {
  69         if (0 > asprintf(&prefx, " ")) {
  70             return PMIX_ERR_NOMEM;
  71         }
  72     } else {
  73         prefx = prefix;
  74     }
  75 
  76     /* if src is NULL, just print data type and return */
  77     if (NULL == src) {
  78         ret = asprintf(output, "%sData type: PMIX_BOOL\tValue: NULL pointer", prefx);
  79         if (prefx != prefix) {
  80             free(prefx);
  81         }
  82         if (0 > ret) {
  83             return PMIX_ERR_OUT_OF_RESOURCE;
  84         } else {
  85             return PMIX_SUCCESS;
  86         }
  87     }
  88 
  89     ret = asprintf(output, "%sData type: PMIX_BOOL\tValue: %s", prefix,
  90              (*src) ? "TRUE" : "FALSE");
  91     if (prefx != prefix) {
  92         free(prefx);
  93     }
  94 
  95     if (0 > ret) {
  96         return PMIX_ERR_OUT_OF_RESOURCE;
  97     } else {
  98         return PMIX_SUCCESS;
  99     }
 100 }
 101 
 102 int pmix_bfrops_base_print_byte(char **output, char *prefix,
 103                                 uint8_t *src, pmix_data_type_t type)
 104 {
 105     char *prefx;
 106     int ret;
 107 
 108     /* deal with NULL prefix */
 109     if (NULL == prefix) {
 110         if (0 > asprintf(&prefx, " ")) {
 111             return PMIX_ERR_NOMEM;
 112         }
 113     } else {
 114         prefx = prefix;
 115     }
 116 
 117     /* if src is NULL, just print data type and return */
 118     if (NULL == src) {
 119         ret = asprintf(output, "%sData type: PMIX_BYTE\tValue: NULL pointer", prefx);
 120         if (prefx != prefix) {
 121             free(prefx);
 122         }
 123         if (0 > ret) {
 124             return PMIX_ERR_OUT_OF_RESOURCE;
 125         } else {
 126             return PMIX_SUCCESS;
 127         }
 128     }
 129 
 130     ret = asprintf(output, "%sData type: PMIX_BYTE\tValue: %x", prefix, *src);
 131     if (prefx != prefix) {
 132         free(prefx);
 133     }
 134 
 135     if (0 > ret) {
 136         return PMIX_ERR_OUT_OF_RESOURCE;
 137     } else {
 138         return PMIX_SUCCESS;
 139     }
 140 }
 141 
 142 int pmix_bfrops_base_print_string(char **output, char *prefix,
 143                                   char *src, pmix_data_type_t type)
 144 {
 145     char *prefx;
 146     int ret;
 147 
 148     /* deal with NULL prefix */
 149     if (NULL == prefix) {
 150         if (0 > asprintf(&prefx, " ")) {
 151             return PMIX_ERR_NOMEM;
 152         }
 153     } else {
 154         prefx = prefix;
 155     }
 156 
 157     /* if src is NULL, just print data type and return */
 158     if (NULL == src) {
 159         ret = asprintf(output, "%sData type: PMIX_STRING\tValue: NULL pointer", prefx);
 160         if (prefx != prefix) {
 161             free(prefx);
 162         }
 163         if (0 > ret) {
 164             return PMIX_ERR_OUT_OF_RESOURCE;
 165         } else {
 166             return PMIX_SUCCESS;
 167         }
 168     }
 169 
 170     ret = asprintf(output, "%sData type: PMIX_STRING\tValue: %s", prefx, src);
 171     if (prefx != prefix) {
 172         free(prefx);
 173     }
 174 
 175     if (0 > ret) {
 176         return PMIX_ERR_OUT_OF_RESOURCE;
 177     } else {
 178         return PMIX_SUCCESS;
 179     }
 180 }
 181 
 182 int pmix_bfrops_base_print_size(char **output, char *prefix,
 183                                 size_t *src, pmix_data_type_t type)
 184 {
 185     char *prefx;
 186     int ret;
 187 
 188     /* deal with NULL prefix */
 189     if (NULL == prefix) {
 190         if (0 > asprintf(&prefx, " ")) {
 191             return PMIX_ERR_NOMEM;
 192         }
 193     } else {
 194         prefx = prefix;
 195     }
 196 
 197     /* if src is NULL, just print data type and return */
 198     if (NULL == src) {
 199         ret = asprintf(output, "%sData type: PMIX_SIZE\tValue: NULL pointer", prefx);
 200         if (prefx != prefix) {
 201             free(prefx);
 202         }
 203         if (0 > ret) {
 204             return PMIX_ERR_OUT_OF_RESOURCE;
 205         } else {
 206             return PMIX_SUCCESS;
 207         }
 208     }
 209 
 210     ret = asprintf(output, "%sData type: PMIX_SIZE\tValue: %lu", prefx, (unsigned long) *src);
 211     if (prefx != prefix) {
 212         free(prefx);
 213     }
 214 
 215     if (0 > ret) {
 216         return PMIX_ERR_OUT_OF_RESOURCE;
 217     } else {
 218         return PMIX_SUCCESS;
 219     }
 220 }
 221 
 222 int pmix_bfrops_base_print_pid(char **output, char *prefix,
 223                                pid_t *src, pmix_data_type_t type)
 224 {
 225     char *prefx;
 226     int ret;
 227 
 228     /* deal with NULL prefix */
 229     if (NULL == prefix) {
 230         if (0 > asprintf(&prefx, " ")) {
 231             return PMIX_ERR_NOMEM;
 232         }
 233     } else {
 234         prefx = prefix;
 235     }
 236 
 237     /* if src is NULL, just print data type and return */
 238     if (NULL == src) {
 239         ret = asprintf(output, "%sData type: PMIX_PID\tValue: NULL pointer", prefx);
 240         if (prefx != prefix) {
 241             free(prefx);
 242         }
 243         if (0 > ret) {
 244             return PMIX_ERR_OUT_OF_RESOURCE;
 245         } else {
 246             return PMIX_SUCCESS;
 247         }
 248     }
 249 
 250     ret = asprintf(output, "%sData type: PMIX_PID\tValue: %lu", prefx, (unsigned long) *src);
 251     if (prefx != prefix) {
 252         free(prefx);
 253     }
 254     if (0 > ret) {
 255         return PMIX_ERR_OUT_OF_RESOURCE;
 256     } else {
 257         return PMIX_SUCCESS;
 258     }
 259 }
 260 
 261 int pmix_bfrops_base_print_int(char **output, char *prefix,
 262                                int *src, pmix_data_type_t type)
 263 {
 264     char *prefx;
 265     int ret;
 266 
 267     /* deal with NULL prefix */
 268     if (NULL == prefix) {
 269         if (0 > asprintf(&prefx, " ")) {
 270             return PMIX_ERR_NOMEM;
 271         }
 272     } else {
 273         prefx = prefix;
 274     }
 275 
 276     /* if src is NULL, just print data type and return */
 277     if (NULL == src) {
 278         ret = asprintf(output, "%sData type: PMIX_INT\tValue: NULL pointer", prefx);
 279         if (prefx != prefix) {
 280             free(prefx);
 281         }
 282         if (0 > ret) {
 283             return PMIX_ERR_OUT_OF_RESOURCE;
 284         } else {
 285             return PMIX_SUCCESS;
 286         }
 287     }
 288 
 289     ret = asprintf(output, "%sData type: PMIX_INT\tValue: %ld", prefx, (long) *src);
 290     if (prefx != prefix) {
 291         free(prefx);
 292     }
 293 
 294     if (0 > ret) {
 295         return PMIX_ERR_OUT_OF_RESOURCE;
 296     } else {
 297         return PMIX_SUCCESS;
 298     }
 299 }
 300 
 301 int pmix_bfrops_base_print_uint(char **output, char *prefix,
 302                                 uint *src, pmix_data_type_t type)
 303 {
 304     char *prefx;
 305     int ret;
 306 
 307     /* deal with NULL prefix */
 308     if (NULL == prefix) {
 309         if (0 > asprintf(&prefx, " ")) {
 310             return PMIX_ERR_NOMEM;
 311         }
 312     } else {
 313         prefx = prefix;
 314     }
 315 
 316     /* if src is NULL, just print data type and return */
 317     if (NULL == src) {
 318         ret = asprintf(output, "%sData type: PMIX_UINT\tValue: NULL pointer", prefx);
 319         if (prefx != prefix) {
 320             free(prefx);
 321         }
 322         if (0 > ret) {
 323             return PMIX_ERR_OUT_OF_RESOURCE;
 324         } else {
 325             return PMIX_SUCCESS;
 326         }
 327     }
 328 
 329     ret = asprintf(output, "%sData type: PMIX_UINT\tValue: %lu", prefx, (unsigned long) *src);
 330     if (prefx != prefix) {
 331         free(prefx);
 332     }
 333 
 334     if (0 > ret) {
 335         return PMIX_ERR_OUT_OF_RESOURCE;
 336     } else {
 337         return PMIX_SUCCESS;
 338     }
 339 }
 340 
 341 int pmix_bfrops_base_print_uint8(char **output, char *prefix,
 342                                  uint8_t *src, pmix_data_type_t type)
 343 {
 344     char *prefx;
 345     int ret;
 346 
 347     /* deal with NULL prefix */
 348     if (NULL == prefix) {
 349         if (0 > asprintf(&prefx, " ")) {
 350             return PMIX_ERR_NOMEM;
 351         }
 352     } else {
 353         prefx = prefix;
 354     }
 355 
 356     /* if src is NULL, just print data type and return */
 357     if (NULL == src) {
 358         ret = asprintf(output, "%sData type: PMIX_UINT8\tValue: NULL pointer", prefx);
 359         if (prefx != prefix) {
 360             free(prefx);
 361         }
 362         if (0 > ret) {
 363             return PMIX_ERR_OUT_OF_RESOURCE;
 364         } else {
 365             return PMIX_SUCCESS;
 366         }
 367     }
 368 
 369     ret = asprintf(output, "%sData type: PMIX_UINT8\tValue: %u", prefx, (unsigned int) *src);
 370     if (prefx != prefix) {
 371         free(prefx);
 372     }
 373 
 374     if (0 > ret) {
 375         return PMIX_ERR_OUT_OF_RESOURCE;
 376     } else {
 377         return PMIX_SUCCESS;
 378     }
 379 }
 380 
 381 int pmix_bfrops_base_print_uint16(char **output, char *prefix,
 382                                   uint16_t *src, pmix_data_type_t type)
 383 {
 384     char *prefx;
 385     int ret;
 386 
 387     /* deal with NULL prefix */
 388     if (NULL == prefix) {
 389         if (0 > asprintf(&prefx, " ")) {
 390             return PMIX_ERR_NOMEM;
 391         }
 392     } else {
 393         prefx = prefix;
 394     }
 395 
 396     /* if src is NULL, just print data type and return */
 397     if (NULL == src) {
 398         ret = asprintf(output, "%sData type: PMIX_UINT16\tValue: NULL pointer", prefx);
 399         if (prefx != prefix) {
 400             free(prefx);
 401         }
 402         if (0 > ret) {
 403             return PMIX_ERR_OUT_OF_RESOURCE;
 404         } else {
 405             return PMIX_SUCCESS;
 406         }
 407     }
 408 
 409     ret = asprintf(output, "%sData type: PMIX_UINT16\tValue: %u", prefx, (unsigned int) *src);
 410     if (prefx != prefix) {
 411         free(prefx);
 412     }
 413 
 414     if (0 > ret) {
 415         return PMIX_ERR_OUT_OF_RESOURCE;
 416     } else {
 417         return PMIX_SUCCESS;
 418     }
 419 }
 420 
 421 int pmix_bfrops_base_print_uint32(char **output, char *prefix,
 422                                   uint32_t *src, pmix_data_type_t type)
 423 {
 424     char *prefx;
 425     int ret;
 426 
 427     /* deal with NULL prefix */
 428     if (NULL == prefix) {
 429         if (0 > asprintf(&prefx, " ")) {
 430             return PMIX_ERR_NOMEM;
 431         }
 432     } else {
 433         prefx = prefix;
 434     }
 435 
 436     /* if src is NULL, just print data type and return */
 437     if (NULL == src) {
 438         ret = asprintf(output, "%sData type: PMIX_UINT32\tValue: NULL pointer", prefx);
 439         if (prefx != prefix) {
 440             free(prefx);
 441         }
 442         if (0 > ret) {
 443             return PMIX_ERR_OUT_OF_RESOURCE;
 444         } else {
 445             return PMIX_SUCCESS;
 446         }
 447     }
 448 
 449     ret = asprintf(output, "%sData type: PMIX_UINT32\tValue: %u", prefx, (unsigned int) *src);
 450     if (prefx != prefix) {
 451         free(prefx);
 452     }
 453 
 454     if (0 > ret) {
 455         return PMIX_ERR_OUT_OF_RESOURCE;
 456     } else {
 457         return PMIX_SUCCESS;
 458     }
 459 }
 460 
 461 int pmix_bfrops_base_print_int8(char **output, char *prefix,
 462                                 int8_t *src, pmix_data_type_t type)
 463 {
 464     char *prefx;
 465     int ret;
 466 
 467     /* deal with NULL prefix */
 468     if (NULL == prefix) {
 469         if (0 > asprintf(&prefx, " ")) {
 470             return PMIX_ERR_NOMEM;
 471         }
 472     } else {
 473         prefx = prefix;
 474     }
 475 
 476     /* if src is NULL, just print data type and return */
 477     if (NULL == src) {
 478         ret = asprintf(output, "%sData type: PMIX_INT8\tValue: NULL pointer", prefx);
 479         if (prefx != prefix) {
 480             free(prefx);
 481         }
 482         if (0 > ret) {
 483             return PMIX_ERR_OUT_OF_RESOURCE;
 484         } else {
 485             return PMIX_SUCCESS;
 486         }
 487     }
 488 
 489     ret = asprintf(output, "%sData type: PMIX_INT8\tValue: %d", prefx, (int) *src);
 490     if (prefx != prefix) {
 491         free(prefx);
 492     }
 493 
 494     if (0 > ret) {
 495         return PMIX_ERR_OUT_OF_RESOURCE;
 496     } else {
 497         return PMIX_SUCCESS;
 498     }
 499 }
 500 
 501 int pmix_bfrops_base_print_int16(char **output, char *prefix,
 502                                  int16_t *src, pmix_data_type_t type)
 503 {
 504     char *prefx;
 505     int ret;
 506 
 507     /* deal with NULL prefix */
 508     if (NULL == prefix) {
 509         if (0 > asprintf(&prefx, " ")) {
 510             return PMIX_ERR_NOMEM;
 511         }
 512     } else {
 513         prefx = prefix;
 514     }
 515 
 516     /* if src is NULL, just print data type and return */
 517     if (NULL == src) {
 518         ret = asprintf(output, "%sData type: PMIX_INT16\tValue: NULL pointer", prefx);
 519         if (prefx != prefix) {
 520             free(prefx);
 521         }
 522         if (0 > ret) {
 523             return PMIX_ERR_OUT_OF_RESOURCE;
 524         } else {
 525             return PMIX_SUCCESS;
 526         }
 527     }
 528 
 529     ret = asprintf(output, "%sData type: PMIX_INT16\tValue: %d", prefx, (int) *src);
 530     if (prefx != prefix) {
 531         free(prefx);
 532     }
 533 
 534     if (0 > ret) {
 535         return PMIX_ERR_OUT_OF_RESOURCE;
 536     } else {
 537         return PMIX_SUCCESS;
 538     }
 539 }
 540 
 541 int pmix_bfrops_base_print_int32(char **output, char *prefix,
 542                                  int32_t *src, pmix_data_type_t type)
 543 {
 544     char *prefx;
 545     int ret;
 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         ret = asprintf(output, "%sData type: PMIX_INT32\tValue: NULL pointer", prefx);
 559         if (prefx != prefix) {
 560             free(prefx);
 561         }
 562         if (0 > ret) {
 563             return PMIX_ERR_OUT_OF_RESOURCE;
 564         } else {
 565             return PMIX_SUCCESS;
 566         }
 567     }
 568 
 569     ret = asprintf(output, "%sData type: PMIX_INT32\tValue: %d", prefx, (int) *src);
 570     if (prefx != prefix) {
 571         free(prefx);
 572     }
 573 
 574     if (0 > ret) {
 575         return PMIX_ERR_OUT_OF_RESOURCE;
 576     } else {
 577         return PMIX_SUCCESS;
 578     }
 579 }
 580 int pmix_bfrops_base_print_uint64(char **output, char *prefix,
 581                                   uint64_t *src,
 582                                   pmix_data_type_t type)
 583 {
 584     char *prefx;
 585     int ret;
 586 
 587     /* deal with NULL prefix */
 588     if (NULL == prefix) {
 589         if (0 > asprintf(&prefx, " ")) {
 590             return PMIX_ERR_NOMEM;
 591         }
 592     } else {
 593         prefx = prefix;
 594     }
 595 
 596     /* if src is NULL, just print data type and return */
 597     if (NULL == src) {
 598         ret = asprintf(output, "%sData type: PMIX_UINT64\tValue: NULL pointer", prefx);
 599         if (prefx != prefix) {
 600             free(prefx);
 601         }
 602         if (0 > ret) {
 603             return PMIX_ERR_OUT_OF_RESOURCE;
 604         } else {
 605             return PMIX_SUCCESS;
 606         }
 607     }
 608 
 609     ret = asprintf(output, "%sData type: PMIX_UINT64\tValue: %lu", prefx, (unsigned long) *src);
 610     if (prefx != prefix) {
 611         free(prefx);
 612     }
 613 
 614     if (0 > ret) {
 615         return PMIX_ERR_OUT_OF_RESOURCE;
 616     } else {
 617         return PMIX_SUCCESS;
 618     }
 619 }
 620 
 621 int pmix_bfrops_base_print_int64(char **output, char *prefix,
 622                                  int64_t *src,
 623                                  pmix_data_type_t type)
 624 {
 625     char *prefx;
 626     int ret;
 627 
 628     /* deal with NULL prefix */
 629     if (NULL == prefix) {
 630         if (0 > asprintf(&prefx, " ")) {
 631             return PMIX_ERR_NOMEM;
 632         }
 633     } else {
 634         prefx = prefix;
 635     }
 636 
 637     /* if src is NULL, just print data type and return */
 638     if (NULL == src) {
 639         ret = asprintf(output, "%sData type: PMIX_INT64\tValue: NULL pointer", prefx);
 640         if (prefx != prefix) {
 641             free(prefx);
 642         }
 643         if (0 > ret) {
 644             return PMIX_ERR_OUT_OF_RESOURCE;
 645         } else {
 646             return PMIX_SUCCESS;
 647         }
 648     }
 649 
 650     ret = asprintf(output, "%sData type: PMIX_INT64\tValue: %ld", prefx, (long) *src);
 651     if (prefx != prefix) {
 652         free(prefx);
 653     }
 654 
 655     if (0 > ret) {
 656         return PMIX_ERR_OUT_OF_RESOURCE;
 657     } else {
 658         return PMIX_SUCCESS;
 659     }
 660 }
 661 
 662 int pmix_bfrops_base_print_float(char **output, char *prefix,
 663                                  float *src, pmix_data_type_t type)
 664 {
 665     char *prefx;
 666     int ret;
 667 
 668     /* deal with NULL prefix */
 669     if (NULL == prefix) {
 670         if (0 > asprintf(&prefx, " ")) {
 671             return PMIX_ERR_NOMEM;
 672         }
 673     } else {
 674         prefx = prefix;
 675     }
 676 
 677     /* if src is NULL, just print data type and return */
 678     if (NULL == src) {
 679         ret = asprintf(output, "%sData type: PMIX_FLOAT\tValue: NULL pointer", prefx);
 680         if (prefx != prefix) {
 681             free(prefx);
 682         }
 683         if (0 > ret) {
 684             return PMIX_ERR_OUT_OF_RESOURCE;
 685         } else {
 686             return PMIX_SUCCESS;
 687         }
 688     }
 689 
 690     ret = asprintf(output, "%sData type: PMIX_FLOAT\tValue: %f", prefx, *src);
 691     if (prefx != prefix) {
 692         free(prefx);
 693     }
 694 
 695     if (0 > ret) {
 696         return PMIX_ERR_OUT_OF_RESOURCE;
 697     } else {
 698         return PMIX_SUCCESS;
 699     }
 700 }
 701 
 702 int pmix_bfrops_base_print_double(char **output, char *prefix,
 703                                   double *src, pmix_data_type_t type)
 704 {
 705     char *prefx;
 706     int ret;
 707 
 708     /* deal with NULL prefix */
 709     if (NULL == prefix) {
 710         if (0 > asprintf(&prefx, " ")) {
 711             return PMIX_ERR_NOMEM;
 712         }
 713     } else {
 714         prefx = prefix;
 715     }
 716 
 717     /* if src is NULL, just print data type and return */
 718     if (NULL == src) {
 719         ret = asprintf(output, "%sData type: PMIX_DOUBLE\tValue: NULL pointer", prefx);
 720         if (prefx != prefix) {
 721             free(prefx);
 722         }
 723         if (0 > ret) {
 724             return PMIX_ERR_OUT_OF_RESOURCE;
 725         } else {
 726             return PMIX_SUCCESS;
 727         }
 728     }
 729 
 730     ret = asprintf(output, "%sData type: PMIX_DOUBLE\tValue: %f", prefx, *src);
 731     if (prefx != prefix) {
 732         free(prefx);
 733     }
 734 
 735     if (0 > ret) {
 736         return PMIX_ERR_OUT_OF_RESOURCE;
 737     } else {
 738         return PMIX_SUCCESS;
 739     }
 740 }
 741 
 742 int pmix_bfrops_base_print_time(char **output, char *prefix,
 743                                 time_t *src, pmix_data_type_t type)
 744 {
 745     char *prefx;
 746     char *t;
 747     int ret;
 748 
 749     /* deal with NULL prefix */
 750     if (NULL == prefix) {
 751         if (0 > asprintf(&prefx, " ")) {
 752             return PMIX_ERR_NOMEM;
 753         }
 754     } else {
 755         prefx = prefix;
 756     }
 757 
 758     /* if src is NULL, just print data type and return */
 759     if (NULL == src) {
 760         ret = asprintf(output, "%sData type: PMIX_TIME\tValue: NULL pointer", prefx);
 761         if (prefx != prefix) {
 762             free(prefx);
 763         }
 764         if (0 > ret) {
 765             return PMIX_ERR_OUT_OF_RESOURCE;
 766         } else {
 767             return PMIX_SUCCESS;
 768         }
 769     }
 770 
 771     t = ctime(src);
 772     t[strlen(t)-1] = '\0';  // remove trailing newline
 773 
 774     ret = asprintf(output, "%sData type: PMIX_TIME\tValue: %s", prefx, t);
 775     if (prefx != prefix) {
 776         free(prefx);
 777     }
 778 
 779     if (0 > ret) {
 780         return PMIX_ERR_OUT_OF_RESOURCE;
 781     } else {
 782         return PMIX_SUCCESS;
 783     }
 784 }
 785 
 786 int pmix_bfrops_base_print_timeval(char **output, char *prefix,
 787                                    struct timeval *src, pmix_data_type_t type)
 788 {
 789     char *prefx;
 790     int ret;
 791 
 792     /* deal with NULL prefix */
 793     if (NULL == prefix) {
 794         if (0 > asprintf(&prefx, " ")) {
 795             return PMIX_ERR_NOMEM;
 796         }
 797     } else {
 798         prefx = prefix;
 799     }
 800 
 801     /* if src is NULL, just print data type and return */
 802     if (NULL == src) {
 803         ret = asprintf(output, "%sData type: PMIX_TIMEVAL\tValue: NULL pointer", prefx);
 804         if (prefx != prefix) {
 805             free(prefx);
 806         }
 807         if (0 > ret) {
 808             return PMIX_ERR_OUT_OF_RESOURCE;
 809         } else {
 810             return PMIX_SUCCESS;
 811         }
 812     }
 813 
 814     ret = asprintf(output, "%sData type: PMIX_TIMEVAL\tValue: %ld.%06ld", prefx,
 815                    (long)src->tv_sec, (long)src->tv_usec);
 816     if (prefx != prefix) {
 817         free(prefx);
 818     }
 819 
 820     if (0 > ret) {
 821         return PMIX_ERR_OUT_OF_RESOURCE;
 822     } else {
 823         return PMIX_SUCCESS;
 824     }
 825 }
 826 
 827 int pmix_bfrops_base_print_status(char **output, char *prefix,
 828                                   pmix_status_t *src, pmix_data_type_t type)
 829 {
 830     char *prefx;
 831     int ret;
 832 
 833     /* deal with NULL prefix */
 834     if (NULL == prefix) {
 835         if (0 > asprintf(&prefx, " ")) {
 836             return PMIX_ERR_NOMEM;
 837         }
 838     } else {
 839         prefx = prefix;
 840     }
 841 
 842     /* if src is NULL, just print data type and return */
 843     if (NULL == src) {
 844         ret = asprintf(output, "%sData type: PMIX_STATUS\tValue: NULL pointer", prefx);
 845         if (prefx != prefix) {
 846             free(prefx);
 847         }
 848         if (0 > ret) {
 849             return PMIX_ERR_OUT_OF_RESOURCE;
 850         } else {
 851             return PMIX_SUCCESS;
 852         }
 853     }
 854 
 855     ret = asprintf(output, "%sData type: PMIX_STATUS\tValue: %s", prefx, PMIx_Error_string(*src));
 856     if (prefx != prefix) {
 857         free(prefx);
 858     }
 859 
 860     if (0 > ret) {
 861         return PMIX_ERR_OUT_OF_RESOURCE;
 862     } else {
 863         return PMIX_SUCCESS;
 864     }
 865 }
 866 
 867 
 868 /* PRINT FUNCTIONS FOR GENERIC PMIX TYPES */
 869 
 870 /*
 871  * PMIX_VALUE
 872  */
 873  int pmix_bfrops_base_print_value(char **output, char *prefix,
 874                                   pmix_value_t *src, pmix_data_type_t type)
 875  {
 876     char *prefx;
 877     int rc;
 878     pmix_regattr_t *r;
 879 
 880     /* deal with NULL prefix */
 881     if (NULL == prefix) {
 882         if (0 > asprintf(&prefx, " ")) {
 883             return PMIX_ERR_NOMEM;
 884         }
 885     } else {
 886         prefx = prefix;
 887     }
 888 
 889     /* if src is NULL, just print data type and return */
 890     if (NULL == src) {
 891         rc = asprintf(output, "%sData type: PMIX_VALUE\tValue: NULL pointer", prefx);
 892         if (prefx != prefix) {
 893             free(prefx);
 894         }
 895         if (0 > rc) {
 896             return PMIX_ERR_OUT_OF_RESOURCE;
 897         } else {
 898             return PMIX_SUCCESS;
 899         }
 900     }
 901 
 902     switch (src->type) {
 903         case PMIX_UNDEF:
 904             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UNDEF", prefx);
 905             break;
 906         case PMIX_BYTE:
 907             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_BYTE\tValue: %x",
 908                           prefx, src->data.byte);
 909             break;
 910         case PMIX_STRING:
 911             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_STRING\tValue: %s",
 912                           prefx, src->data.string);
 913             break;
 914         case PMIX_SIZE:
 915             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_SIZE\tValue: %lu",
 916                           prefx, (unsigned long)src->data.size);
 917             break;
 918         case PMIX_PID:
 919             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_PID\tValue: %lu",
 920                           prefx, (unsigned long)src->data.pid);
 921             break;
 922         case PMIX_INT:
 923             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_INT\tValue: %d",
 924                           prefx, src->data.integer);
 925             break;
 926         case PMIX_INT8:
 927             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_INT8\tValue: %d",
 928                           prefx, (int)src->data.int8);
 929             break;
 930         case PMIX_INT16:
 931             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_INT16\tValue: %d",
 932                           prefx, (int)src->data.int16);
 933             break;
 934         case PMIX_INT32:
 935             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_INT32\tValue: %d",
 936                           prefx, src->data.int32);
 937             break;
 938         case PMIX_INT64:
 939             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_INT64\tValue: %ld",
 940                           prefx, (long)src->data.int64);
 941             break;
 942         case PMIX_UINT:
 943             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UINT\tValue: %u",
 944                           prefx, src->data.uint);
 945             break;
 946         case PMIX_UINT8:
 947             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UINT8\tValue: %u",
 948                           prefx, (unsigned int)src->data.uint8);
 949             break;
 950         case PMIX_UINT16:
 951             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UINT16\tValue: %u",
 952                           prefx, (unsigned int)src->data.uint16);
 953             break;
 954         case PMIX_UINT32:
 955             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UINT32\tValue: %u",
 956                           prefx, src->data.uint32);
 957             break;
 958         case PMIX_UINT64:
 959             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_UINT64\tValue: %lu",
 960                           prefx, (unsigned long)src->data.uint64);
 961             break;
 962         case PMIX_FLOAT:
 963             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_FLOAT\tValue: %f",
 964                           prefx, src->data.fval);
 965             break;
 966         case PMIX_DOUBLE:
 967             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_DOUBLE\tValue: %f",
 968                           prefx, src->data.dval);
 969             break;
 970         case PMIX_TIMEVAL:
 971             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_TIMEVAL\tValue: %ld.%06ld", prefx,
 972                           (long)src->data.tv.tv_sec, (long)src->data.tv.tv_usec);
 973             break;
 974         case PMIX_TIME:
 975             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_TIME\tValue: %ld", prefx,
 976                           (long)src->data.time);
 977             break;
 978         case PMIX_STATUS:
 979             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_STATUS\tValue: %s", prefx,
 980                           PMIx_Error_string(src->data.status));
 981             break;
 982         case PMIX_PROC:
 983             if (NULL == src->data.proc) {
 984                 rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_PROC\tNULL", prefx);
 985             } else {
 986                 rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_PROC\t%s:%lu",
 987                               prefx, src->data.proc->nspace, (unsigned long)src->data.proc->rank);
 988             }
 989             break;
 990         case PMIX_BYTE_OBJECT:
 991             rc = asprintf(output, "%sPMIX_VALUE: Data type: BYTE_OBJECT\tSIZE: %ld",
 992                           prefx, (long)src->data.bo.size);
 993             break;
 994         case PMIX_PERSIST:
 995             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_PERSIST\tValue: %d",
 996                           prefx, (int)src->data.persist);
 997             break;
 998         case PMIX_SCOPE:
 999             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_SCOPE\tValue: %d",
1000                           prefx, (int)src->data.scope);
1001             break;
1002         case PMIX_DATA_RANGE:
1003             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_DATA_RANGE\tValue: %d",
1004                           prefx, (int)src->data.range);
1005             break;
1006         case PMIX_PROC_STATE:
1007             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_STATE\tValue: %d",
1008                           prefx, (int)src->data.state);
1009             break;
1010         case PMIX_PROC_INFO:
1011             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_PROC_INFO\tValue: %s:%lu",
1012                           prefx, src->data.proc->nspace, (unsigned long)src->data.proc->rank);
1013             break;
1014         case PMIX_DATA_ARRAY:
1015             rc = asprintf(output, "%sPMIX_VALUE: Data type: DATA_ARRAY\tARRAY SIZE: %ld",
1016                           prefx, (long)src->data.darray->size);
1017             break;
1018         case PMIX_ENVAR:
1019             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_ENVAR\tName: %s\tValue: %s\tSeparator: %c",
1020                           prefx, (NULL == src->data.envar.envar) ? "NULL" : src->data.envar.envar,
1021                           (NULL == src->data.envar.value) ? "NULL" : src->data.envar.value,
1022                           src->data.envar.separator);
1023             break;
1024 
1025         case PMIX_COORD:
1026             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_COORD\tx-axis: %d\ty-axis: %d\tz-axis: %d",
1027                           prefx, src->data.coord->x, src->data.coord->y, src->data.coord->z);
1028             break;
1029 
1030         case PMIX_REGATTR:
1031             r = (pmix_regattr_t*)src->data.ptr;
1032             rc = asprintf(output, "%sPMIX_VALUE: Data type: PMIX_REGATTR\tName: %s\tString: %s",
1033                           prefx, (NULL == r->name) ? "NULL" : r->name,
1034                           (0 == strlen(r->string)) ? "NULL" : r->string);
1035             break;
1036 
1037         default:
1038             rc = asprintf(output, "%sPMIX_VALUE: Data type: UNKNOWN\tValue: UNPRINTABLE", prefx);
1039             break;
1040     }
1041     if (prefx != prefix) {
1042         free(prefx);
1043     }
1044     if (0 > rc) {
1045         return PMIX_ERR_OUT_OF_RESOURCE;
1046     } else {
1047         return PMIX_SUCCESS;
1048     }
1049 }
1050 
1051 int pmix_bfrops_base_print_info(char **output, char *prefix,
1052                                 pmix_info_t *src, pmix_data_type_t type)
1053 {
1054     char *tmp=NULL, *tmp2=NULL;
1055     int ret;
1056 
1057     pmix_bfrops_base_print_value(&tmp, NULL, &src->value, PMIX_VALUE);
1058     pmix_bfrops_base_print_info_directives(&tmp2, NULL, &src->flags, PMIX_INFO_DIRECTIVES);
1059     ret = asprintf(output, "%sKEY: %s\n%s\t%s\n%s\t%s", prefix, src->key,
1060                    prefix, tmp2, prefix, tmp);
1061     free(tmp);
1062     free(tmp2);
1063     if (0 > ret) {
1064         return PMIX_ERR_OUT_OF_RESOURCE;
1065     } else {
1066         return PMIX_SUCCESS;
1067     }
1068 }
1069 
1070 int pmix_bfrops_base_print_pdata(char **output, char *prefix,
1071                                  pmix_pdata_t *src, pmix_data_type_t type)
1072 {
1073     char *tmp1, *tmp2;
1074     int ret;
1075 
1076     pmix_bfrops_base_print_proc(&tmp1, NULL, &src->proc, PMIX_PROC);
1077     pmix_bfrops_base_print_value(&tmp2, NULL, &src->value, PMIX_VALUE);
1078     ret = asprintf(output, "%s  %s  KEY: %s %s", prefix, tmp1, src->key,
1079                    (NULL == tmp2) ? "NULL" : tmp2);
1080     if (NULL != tmp1) {
1081         free(tmp1);
1082     }
1083     if (NULL != tmp2) {
1084         free(tmp2);
1085     }
1086     if (0 > ret) {
1087         return PMIX_ERR_OUT_OF_RESOURCE;
1088     } else {
1089         return PMIX_SUCCESS;
1090     }
1091 }
1092 
1093 int pmix_bfrops_base_print_buf(char **output, char *prefix,
1094                                pmix_buffer_t *src, pmix_data_type_t type)
1095 {
1096     return PMIX_SUCCESS;
1097 }
1098 
1099 int pmix_bfrops_base_print_app(char **output, char *prefix,
1100                                pmix_app_t *src, pmix_data_type_t type)
1101 {
1102     return PMIX_SUCCESS;
1103 }
1104 
1105 int pmix_bfrops_base_print_proc(char **output, char *prefix,
1106                                 pmix_proc_t *src, pmix_data_type_t type)
1107 {
1108     char *prefx;
1109     int rc;
1110 
1111     /* deal with NULL prefix */
1112     if (NULL == prefix) {
1113         if (0 > asprintf(&prefx, " ")) {
1114             return PMIX_ERR_NOMEM;
1115         }
1116     } else {
1117         prefx = prefix;
1118     }
1119 
1120     switch(src->rank) {
1121         case PMIX_RANK_UNDEF:
1122             rc = asprintf(output,
1123                           "%sPROC: %s:PMIX_RANK_UNDEF", prefx, src->nspace);
1124             break;
1125         case PMIX_RANK_WILDCARD:
1126             rc = asprintf(output,
1127                           "%sPROC: %s:PMIX_RANK_WILDCARD", prefx, src->nspace);
1128             break;
1129         case PMIX_RANK_LOCAL_NODE:
1130             rc = asprintf(output,
1131                           "%sPROC: %s:PMIX_RANK_LOCAL_NODE", prefx, src->nspace);
1132             break;
1133         default:
1134             rc = asprintf(output,
1135                           "%sPROC: %s:%lu", prefx, src->nspace,
1136                           (unsigned long)(src->rank));
1137     }
1138     if (prefx != prefix) {
1139         free(prefx);
1140     }
1141     if (0 > rc) {
1142         return PMIX_ERR_NOMEM;
1143     }
1144     return PMIX_SUCCESS;
1145 }
1146 
1147 int pmix_bfrops_base_print_kval(char **output, char *prefix,
1148                                 pmix_kval_t *src, pmix_data_type_t type)
1149 {
1150     return PMIX_SUCCESS;
1151 }
1152 
1153 int pmix_bfrops_base_print_persist(char **output, char *prefix,
1154                                    pmix_persistence_t *src, pmix_data_type_t type)
1155 {
1156     char *prefx;
1157 
1158     /* deal with NULL prefix */
1159     if (NULL == prefix) {
1160         if (0 > asprintf(&prefx, " ")) {
1161             return PMIX_ERR_NOMEM;
1162         }
1163     } else {
1164         prefx = prefix;
1165     }
1166 
1167     /* if src is NULL, just print data type and return */
1168     if (NULL == src) {
1169         if (0 > asprintf(output, "%sData type: PMIX_PERSIST\tValue: NULL pointer", prefx)) {
1170             return PMIX_ERR_NOMEM;
1171         }
1172         if (prefx != prefix) {
1173             free(prefx);
1174         }
1175         return PMIX_SUCCESS;
1176     }
1177 
1178     if (0 > asprintf(output, "%sData type: PMIX_PERSIST\tValue: %ld", prefx, (long) *src)) {
1179         return PMIX_ERR_NOMEM;
1180     }
1181     if (prefx != prefix) {
1182         free(prefx);
1183     }
1184 
1185     return PMIX_SUCCESS;
1186 }
1187 
1188 pmix_status_t pmix_bfrops_base_print_scope(char **output, char *prefix,
1189                                            pmix_scope_t *src,
1190                                            pmix_data_type_t type)
1191 {
1192     char *prefx;
1193 
1194     /* deal with NULL prefix */
1195     if (NULL == prefix) {
1196         if (0 > asprintf(&prefx, " ")) {
1197             return PMIX_ERR_NOMEM;
1198         }
1199     } else {
1200         prefx = prefix;
1201     }
1202 
1203     if (0 > asprintf(output, "%sData type: PMIX_SCOPE\tValue: %s",
1204                      prefx, PMIx_Scope_string(*src))) {
1205         return PMIX_ERR_NOMEM;
1206     }
1207     if (prefx != prefix) {
1208         free(prefx);
1209     }
1210 
1211     return PMIX_SUCCESS;
1212 }
1213 
1214 pmix_status_t pmix_bfrops_base_print_range(char **output, char *prefix,
1215                                            pmix_data_range_t *src,
1216                                            pmix_data_type_t type)
1217 {
1218     char *prefx;
1219 
1220     /* deal with NULL prefix */
1221     if (NULL == prefix) {
1222         if (0 > asprintf(&prefx, " ")) {
1223             return PMIX_ERR_NOMEM;
1224         }
1225     } else {
1226         prefx = prefix;
1227     }
1228 
1229     if (0 > asprintf(output, "%sData type: PMIX_DATA_RANGE\tValue: %s",
1230                      prefx, PMIx_Data_range_string(*src))) {
1231         return PMIX_ERR_NOMEM;
1232     }
1233     if (prefx != prefix) {
1234         free(prefx);
1235     }
1236 
1237     return PMIX_SUCCESS;
1238 }
1239 pmix_status_t pmix_bfrops_base_print_cmd(char **output, char *prefix,
1240                                          pmix_cmd_t *src,
1241                                          pmix_data_type_t type)
1242 {
1243     char *prefx;
1244 
1245     /* deal with NULL prefix */
1246     if (NULL == prefix) {
1247         if (0 > asprintf(&prefx, " ")) {
1248             return PMIX_ERR_NOMEM;
1249         }
1250     } else {
1251         prefx = prefix;
1252     }
1253 
1254     if (0 > asprintf(output, "%sData type: PMIX_COMMAND\tValue: %s",
1255                      prefx, pmix_command_string(*src))) {
1256         return PMIX_ERR_NOMEM;
1257     }
1258     if (prefx != prefix) {
1259         free(prefx);
1260     }
1261 
1262     return PMIX_SUCCESS;
1263 }
1264 
1265 pmix_status_t pmix_bfrops_base_print_info_directives(char **output, char *prefix,
1266                                                      pmix_info_directives_t *src,
1267                                                      pmix_data_type_t type)
1268 {
1269     char *prefx;
1270 
1271     /* deal with NULL prefix */
1272     if (NULL == prefix) {
1273         if (0 > asprintf(&prefx, " ")) {
1274             return PMIX_ERR_NOMEM;
1275         }
1276     } else {
1277         prefx = prefix;
1278     }
1279 
1280     if (0 > asprintf(output, "%sData type: PMIX_INFO_DIRECTIVES\tValue: %s",
1281                      prefx, PMIx_Info_directives_string(*src))) {
1282         return PMIX_ERR_NOMEM;
1283     }
1284     if (prefx != prefix) {
1285         free(prefx);
1286     }
1287 
1288     return PMIX_SUCCESS;
1289 }
1290 
1291 pmix_status_t pmix_bfrops_base_print_datatype(char **output, char *prefix,
1292                                               pmix_data_type_t *src,
1293                                               pmix_data_type_t type)
1294 {
1295     char *prefx;
1296     int ret;
1297 
1298     /* deal with NULL prefix */
1299     if (NULL == prefix) {
1300         if (0 > asprintf(&prefx, " ")) {
1301             return PMIX_ERR_NOMEM;
1302         }
1303     } else {
1304         prefx = prefix;
1305     }
1306 
1307     /* if src is NULL, just print data type and return */
1308     if (NULL == src) {
1309         ret = asprintf(output, "%sData type: PMIX_DATA_TYPE\tValue: NULL pointer", prefx);
1310         if (prefx != prefix) {
1311             free(prefx);
1312         }
1313         if (0 > ret) {
1314             return PMIX_ERR_OUT_OF_RESOURCE;
1315         } else {
1316             return PMIX_SUCCESS;
1317         }
1318     }
1319 
1320     ret = asprintf(output, "%sData type: PMIX_DATA_TYPE\tValue: %s", prefx, PMIx_Data_type_string(*src));
1321     if (prefx != prefix) {
1322         free(prefx);
1323     }
1324 
1325     if (0 > ret) {
1326         return PMIX_ERR_OUT_OF_RESOURCE;
1327     } else {
1328         return PMIX_SUCCESS;
1329     }
1330 }
1331 
1332 int pmix_bfrops_base_print_bo(char **output, char *prefix,
1333                               pmix_byte_object_t *src, pmix_data_type_t type)
1334 {
1335     char *prefx;
1336     int ret;
1337 
1338     /* deal with NULL prefix */
1339     if (NULL == prefix) {
1340         if (0 > asprintf(&prefx, " ")) {
1341             return PMIX_ERR_NOMEM;
1342         }
1343     } else {
1344         prefx = prefix;
1345     }
1346 
1347     /* if src is NULL, just print data type and return */
1348     if (NULL == src) {
1349         ret = asprintf(output, "%sData type: PMIX_BYTE_OBJECT\tValue: NULL pointer", prefx);
1350         if (prefx != prefix) {
1351             free(prefx);
1352         }
1353         if (0 > ret) {
1354             return PMIX_ERR_OUT_OF_RESOURCE;
1355         } else {
1356             return PMIX_SUCCESS;
1357         }
1358     }
1359 
1360     ret = asprintf(output, "%sData type: PMIX_BYTE_OBJECT\tSize: %ld", prefx, (long)src->size);
1361     if (prefx != prefix) {
1362         free(prefx);
1363     }
1364 
1365     if (0 > ret) {
1366         return PMIX_ERR_OUT_OF_RESOURCE;
1367     } else {
1368         return PMIX_SUCCESS;
1369     }
1370 }
1371 
1372 int pmix_bfrops_base_print_ptr(char **output, char *prefix,
1373                                void *src, pmix_data_type_t type)
1374 {
1375     char *prefx;
1376     int ret;
1377 
1378     /* deal with NULL prefix */
1379     if (NULL == prefix) {
1380         if (0 > asprintf(&prefx, " ")) {
1381             return PMIX_ERR_NOMEM;
1382         }
1383     } else {
1384         prefx = prefix;
1385     }
1386 
1387     ret = asprintf(output, "%sData type: PMIX_POINTER\tAddress: %p", prefx, src);
1388     if (prefx != prefix) {
1389         free(prefx);
1390     }
1391 
1392     if (0 > ret) {
1393         return PMIX_ERR_OUT_OF_RESOURCE;
1394     } else {
1395         return PMIX_SUCCESS;
1396     }
1397 }
1398 
1399 pmix_status_t pmix_bfrops_base_print_pstate(char **output, char *prefix,
1400                                             pmix_proc_state_t *src,
1401                                             pmix_data_type_t type)
1402 {
1403     char *prefx;
1404     int ret;
1405 
1406     /* deal with NULL prefix */
1407     if (NULL == prefix) {
1408         if (0 > asprintf(&prefx, " ")) {
1409             return PMIX_ERR_NOMEM;
1410         }
1411     } else {
1412         prefx = prefix;
1413     }
1414 
1415     ret = asprintf(output, "%sData type: PMIX_PROC_STATE\tValue: %s",
1416                    prefx, PMIx_Proc_state_string(*src));
1417     if (prefx != prefix) {
1418         free(prefx);
1419     }
1420 
1421     if (0 > ret) {
1422         return PMIX_ERR_OUT_OF_RESOURCE;
1423     } else {
1424         return PMIX_SUCCESS;
1425     }
1426 }
1427 
1428 pmix_status_t pmix_bfrops_base_print_pinfo(char **output, char *prefix,
1429                                            pmix_proc_info_t *src,
1430                                            pmix_data_type_t type)
1431 {
1432     char *prefx;
1433     pmix_status_t rc = PMIX_SUCCESS;
1434     char *p2, *tmp;
1435 
1436     /* deal with NULL prefix */
1437     if (NULL == prefix) {
1438         if (0 > asprintf(&prefx, " ")) {
1439             return PMIX_ERR_NOMEM;
1440         }
1441     } else {
1442         prefx = prefix;
1443     }
1444 
1445     if (0 > asprintf(&p2, "%s\t", prefx)) {
1446         rc = PMIX_ERR_NOMEM;
1447         goto done;
1448     }
1449 
1450     if (PMIX_SUCCESS != (rc = pmix_bfrops_base_print_proc(&tmp, p2, &src->proc, PMIX_PROC))) {
1451         free(p2);
1452         goto done;
1453     }
1454 
1455     if (0 > asprintf(output,
1456                      "%sData type: PMIX_PROC_INFO\tValue:\n%s\n%sHostname: %s\tExecutable: %s\n%sPid: %lu\tExit code: %d\tState: %s",
1457                      prefx, tmp, p2, src->hostname, src->executable_name,
1458                      p2, (unsigned long)src->pid, src->exit_code, PMIx_Proc_state_string(src->state))) {
1459         free(p2);
1460         rc = PMIX_ERR_NOMEM;
1461     }
1462 
1463   done:
1464     if (prefx != prefix) {
1465         free(prefx);
1466     }
1467 
1468     return rc;
1469 }
1470 
1471 pmix_status_t pmix_bfrops_base_print_darray(char **output, char *prefix,
1472                                             pmix_data_array_t *src,
1473                                             pmix_data_type_t type)
1474 {
1475     char *prefx;
1476     int ret;
1477 
1478     /* deal with NULL prefix */
1479     if (NULL == prefix) {
1480         if (0 > asprintf(&prefx, " ")) {
1481             return PMIX_ERR_NOMEM;
1482         }
1483     } else {
1484         prefx = prefix;
1485     }
1486 
1487     ret = asprintf(output, "%sData type: PMIX_DATA_ARRAY\tSize: %lu",
1488                    prefx, (unsigned long)src->size);
1489     if (prefx != prefix) {
1490         free(prefx);
1491     }
1492 
1493     if (0 > ret) {
1494         return PMIX_ERR_OUT_OF_RESOURCE;
1495     } else {
1496         return PMIX_SUCCESS;
1497     }
1498 }
1499 
1500 pmix_status_t pmix_bfrops_base_print_query(char **output, char *prefix,
1501                                            pmix_query_t *src,
1502                                            pmix_data_type_t type)
1503 {
1504     char *prefx, *p2;
1505     pmix_status_t rc = PMIX_SUCCESS;
1506     char *tmp, *t2, *t3;
1507     size_t n;
1508 
1509     /* deal with NULL prefix */
1510     if (NULL == prefix) {
1511         if (0 > asprintf(&prefx, " ")) {
1512             return PMIX_ERR_NOMEM;
1513         }
1514     } else {
1515         prefx = prefix;
1516     }
1517 
1518     if (0 > asprintf(&p2, "%s\t", prefx)) {
1519         rc = PMIX_ERR_NOMEM;
1520         goto done;
1521     }
1522 
1523     if (0 > asprintf(&tmp,
1524                    "%sData type: PMIX_QUERY\tValue:", prefx)) {
1525         free(p2);
1526         rc = PMIX_ERR_NOMEM;
1527         goto done;
1528     }
1529 
1530     /* print out the keys */
1531     if (NULL != src->keys) {
1532         for (n=0; NULL != src->keys[n]; n++) {
1533             if (0 > asprintf(&t2, "%s\n%sKey: %s", tmp, p2, src->keys[n])) {
1534                 free(p2);
1535                 free(tmp);
1536                 rc = PMIX_ERR_NOMEM;
1537                 goto done;
1538             }
1539             free(tmp);
1540             tmp = t2;
1541         }
1542     }
1543 
1544     /* now print the qualifiers */
1545     if (0 < src->nqual) {
1546         for (n=0; n < src->nqual; n++) {
1547             if (PMIX_SUCCESS != (rc = pmix_bfrops_base_print_info(&t2, p2, &src->qualifiers[n], PMIX_PROC))) {
1548                 free(p2);
1549                 goto done;
1550             }
1551             if (0 > asprintf(&t3, "%s\n%s", tmp, t2)) {
1552                 free(p2);
1553                 free(tmp);
1554                 free(t2);
1555                 rc = PMIX_ERR_NOMEM;
1556                 goto done;
1557             }
1558             free(tmp);
1559             free(t2);
1560             tmp = t3;
1561         }
1562     }
1563     *output = tmp;
1564 
1565   done:
1566     if (prefx != prefix) {
1567         free(prefx);
1568     }
1569 
1570     return rc;
1571 }
1572 
1573 pmix_status_t pmix_bfrops_base_print_rank(char **output, char *prefix,
1574                                           pmix_rank_t *src,
1575                                           pmix_data_type_t type)
1576 {
1577     char *prefx;
1578     int rc;
1579 
1580     /* deal with NULL prefix */
1581     if (NULL == prefix) {
1582         if (0 > asprintf(&prefx, " ")) {
1583             return PMIX_ERR_NOMEM;
1584         }
1585     } else {
1586         prefx = prefix;
1587     }
1588 
1589     switch(*src) {
1590         case PMIX_RANK_UNDEF:
1591             rc = asprintf(output,
1592                           "%sData type: PMIX_PROC_RANK\tValue: PMIX_RANK_UNDEF",
1593                           prefx);
1594             break;
1595         case PMIX_RANK_WILDCARD:
1596             rc = asprintf(output,
1597                           "%sData type: PMIX_PROC_RANK\tValue: PMIX_RANK_WILDCARD",
1598                           prefx);
1599             break;
1600         case PMIX_RANK_LOCAL_NODE:
1601             rc = asprintf(output,
1602                           "%sData type: PMIX_PROC_RANK\tValue: PMIX_RANK_LOCAL_NODE",
1603                           prefx);
1604             break;
1605         default:
1606             rc = asprintf(output, "%sData type: PMIX_PROC_RANK\tValue: %lu",
1607                           prefx, (unsigned long)(*src));
1608     }
1609     if (prefx != prefix) {
1610         free(prefx);
1611     }
1612     if (0 > rc) {
1613         return PMIX_ERR_NOMEM;
1614     }
1615     return PMIX_SUCCESS;
1616 }
1617 
1618 pmix_status_t pmix_bfrops_base_print_alloc_directive(char **output, char *prefix,
1619                                                      pmix_alloc_directive_t *src,
1620                                                      pmix_data_type_t type)
1621 {
1622     char *prefx;
1623     int ret;
1624 
1625     /* deal with NULL prefix */
1626     if (NULL == prefix) {
1627         if (0 > asprintf(&prefx, " ")) {
1628             return PMIX_ERR_NOMEM;
1629         }
1630     } else {
1631         prefx = prefix;
1632     }
1633 
1634     ret = asprintf(output, "%sData type: PMIX_ALLOC_DIRECTIVE\tValue: %s",
1635                    prefx, PMIx_Alloc_directive_string(*src));
1636     if (prefx != prefix) {
1637         free(prefx);
1638     }
1639 
1640     if (0 > ret) {
1641         return PMIX_ERR_OUT_OF_RESOURCE;
1642     } else {
1643         return PMIX_SUCCESS;
1644     }
1645 }
1646 
1647 pmix_status_t pmix_bfrops_base_print_iof_channel(char **output, char *prefix,
1648                                                  pmix_iof_channel_t *src,
1649                                                  pmix_data_type_t type)
1650 {
1651     char *prefx;
1652     int ret;
1653 
1654     /* deal with NULL prefix */
1655     if (NULL == prefix) {
1656         if (0 > asprintf(&prefx, " ")) {
1657             return PMIX_ERR_NOMEM;
1658         }
1659     } else {
1660         prefx = prefix;
1661     }
1662 
1663     ret = asprintf(output, "%sData type: PMIX_IOF_CHANNEL\tValue: %s",
1664                    prefx, PMIx_IOF_channel_string(*src));
1665     if (prefx != prefix) {
1666         free(prefx);
1667     }
1668 
1669     if (0 > ret) {
1670         return PMIX_ERR_OUT_OF_RESOURCE;
1671     } else {
1672         return PMIX_SUCCESS;
1673     }
1674 }
1675 
1676 pmix_status_t pmix_bfrops_base_print_envar(char **output, char *prefix,
1677                                            pmix_envar_t *src,
1678                                            pmix_data_type_t type)
1679 {
1680     char *prefx;
1681     int ret;
1682 
1683     /* deal with NULL prefix */
1684     if (NULL == prefix) {
1685         if (0 > asprintf(&prefx, " ")) {
1686             return PMIX_ERR_NOMEM;
1687         }
1688     } else {
1689         prefx = prefix;
1690     }
1691 
1692     ret = asprintf(output, "%sData type: PMIX_ENVAR\tName: %s\tValue: %s\tSeparator: %c",
1693                    prefx, (NULL == src->envar) ? "NULL" : src->envar,
1694                    (NULL == src->value) ? "NULL" : src->value,
1695                    ('\0' == src->separator) ? ' ' : src->separator);
1696     if (prefx != prefix) {
1697         free(prefx);
1698     }
1699 
1700     if (0 > ret) {
1701         return PMIX_ERR_OUT_OF_RESOURCE;
1702     } else {
1703         return PMIX_SUCCESS;
1704     }
1705 }
1706 
1707 pmix_status_t pmix_bfrops_base_print_coord(char **output, char *prefix,
1708                                            pmix_coord_t *src,
1709                                            pmix_data_type_t type)
1710 {
1711     char *prefx;
1712     int ret;
1713 
1714     /* deal with NULL prefix */
1715     if (NULL == prefix) {
1716         if (0 > asprintf(&prefx, " ")) {
1717             return PMIX_ERR_NOMEM;
1718         }
1719     } else {
1720         prefx = prefix;
1721     }
1722 
1723     ret = asprintf(output, "%sData type: PMIX_COORD\tx-axis: %d\ty-axis: %d\tz-axis: %d",
1724                    prefx, src->x, src->y, src->z);
1725     if (prefx != prefix) {
1726         free(prefx);
1727     }
1728 
1729     if (0 > ret) {
1730         return PMIX_ERR_OUT_OF_RESOURCE;
1731     } else {
1732         return PMIX_SUCCESS;
1733     }
1734 }
1735 
1736 pmix_status_t pmix_bfrops_base_print_regattr(char **output, char *prefix,
1737                                              pmix_regattr_t *src,
1738                                              pmix_data_type_t type)
1739 {
1740     char *prefx;
1741     int ret;
1742 
1743     /* deal with NULL prefix */
1744     if (NULL == prefix) {
1745         if (0 > asprintf(&prefx, " ")) {
1746             return PMIX_ERR_NOMEM;
1747         }
1748     } else {
1749         prefx = prefix;
1750     }
1751 
1752     ret = asprintf(output, "%sData type: PMIX_REGATTR\tName: %s\tString: %s",
1753                    prefx, (NULL == src->name) ? "NULL" : src->name,
1754                    (0 == strlen(src->string)) ? "NULL" : src->string);
1755 
1756     if (prefx != prefix) {
1757         free(prefx);
1758     }
1759 
1760     if (0 > ret) {
1761         return PMIX_ERR_OUT_OF_RESOURCE;
1762     } else {
1763         return PMIX_SUCCESS;
1764     }
1765 }
/* [<][>][^][v][top][bottom][index][help] */
root/opal/mca/pmix/pmix4x/pmix/src/mca/bfrops/base/bfrop_base_print.c

DEFINITIONS
