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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
45 if (NULL == output || NULL == src) {
46 return PMIX_ERR_BAD_PARAM;
47 }
48
49
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
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
68 if (NULL == prefix) {
69 if (0 > asprintf(&prefx, " ")) {
70 return PMIX_ERR_NOMEM;
71 }
72 } else {
73 prefx = prefix;
74 }
75
76
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
109 if (NULL == prefix) {
110 if (0 > asprintf(&prefx, " ")) {
111 return PMIX_ERR_NOMEM;
112 }
113 } else {
114 prefx = prefix;
115 }
116
117
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
149 if (NULL == prefix) {
150 if (0 > asprintf(&prefx, " ")) {
151 return PMIX_ERR_NOMEM;
152 }
153 } else {
154 prefx = prefix;
155 }
156
157
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
189 if (NULL == prefix) {
190 if (0 > asprintf(&prefx, " ")) {
191 return PMIX_ERR_NOMEM;
192 }
193 } else {
194 prefx = prefix;
195 }
196
197
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
229 if (NULL == prefix) {
230 if (0 > asprintf(&prefx, " ")) {
231 return PMIX_ERR_NOMEM;
232 }
233 } else {
234 prefx = prefix;
235 }
236
237
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
268 if (NULL == prefix) {
269 if (0 > asprintf(&prefx, " ")) {
270 return PMIX_ERR_NOMEM;
271 }
272 } else {
273 prefx = prefix;
274 }
275
276
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
308 if (NULL == prefix) {
309 if (0 > asprintf(&prefx, " ")) {
310 return PMIX_ERR_NOMEM;
311 }
312 } else {
313 prefx = prefix;
314 }
315
316
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
348 if (NULL == prefix) {
349 if (0 > asprintf(&prefx, " ")) {
350 return PMIX_ERR_NOMEM;
351 }
352 } else {
353 prefx = prefix;
354 }
355
356
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
388 if (NULL == prefix) {
389 if (0 > asprintf(&prefx, " ")) {
390 return PMIX_ERR_NOMEM;
391 }
392 } else {
393 prefx = prefix;
394 }
395
396
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
428 if (NULL == prefix) {
429 if (0 > asprintf(&prefx, " ")) {
430 return PMIX_ERR_NOMEM;
431 }
432 } else {
433 prefx = prefix;
434 }
435
436
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
468 if (NULL == prefix) {
469 if (0 > asprintf(&prefx, " ")) {
470 return PMIX_ERR_NOMEM;
471 }
472 } else {
473 prefx = prefix;
474 }
475
476
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
508 if (NULL == prefix) {
509 if (0 > asprintf(&prefx, " ")) {
510 return PMIX_ERR_NOMEM;
511 }
512 } else {
513 prefx = prefix;
514 }
515
516
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
548 if (NULL == prefix) {
549 if (0 > asprintf(&prefx, " ")) {
550 return PMIX_ERR_NOMEM;
551 }
552 } else {
553 prefx = prefix;
554 }
555
556
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
588 if (NULL == prefix) {
589 if (0 > asprintf(&prefx, " ")) {
590 return PMIX_ERR_NOMEM;
591 }
592 } else {
593 prefx = prefix;
594 }
595
596
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
629 if (NULL == prefix) {
630 if (0 > asprintf(&prefx, " ")) {
631 return PMIX_ERR_NOMEM;
632 }
633 } else {
634 prefx = prefix;
635 }
636
637
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
669 if (NULL == prefix) {
670 if (0 > asprintf(&prefx, " ")) {
671 return PMIX_ERR_NOMEM;
672 }
673 } else {
674 prefx = prefix;
675 }
676
677
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
709 if (NULL == prefix) {
710 if (0 > asprintf(&prefx, " ")) {
711 return PMIX_ERR_NOMEM;
712 }
713 } else {
714 prefx = prefix;
715 }
716
717
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
750 if (NULL == prefix) {
751 if (0 > asprintf(&prefx, " ")) {
752 return PMIX_ERR_NOMEM;
753 }
754 } else {
755 prefx = prefix;
756 }
757
758
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';
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
793 if (NULL == prefix) {
794 if (0 > asprintf(&prefx, " ")) {
795 return PMIX_ERR_NOMEM;
796 }
797 } else {
798 prefx = prefix;
799 }
800
801
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
834 if (NULL == prefix) {
835 if (0 > asprintf(&prefx, " ")) {
836 return PMIX_ERR_NOMEM;
837 }
838 } else {
839 prefx = prefix;
840 }
841
842
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
869
870
871
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
881 if (NULL == prefix) {
882 if (0 > asprintf(&prefx, " ")) {
883 return PMIX_ERR_NOMEM;
884 }
885 } else {
886 prefx = prefix;
887 }
888
889
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
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
1159 if (NULL == prefix) {
1160 if (0 > asprintf(&prefx, " ")) {
1161 return PMIX_ERR_NOMEM;
1162 }
1163 } else {
1164 prefx = prefix;
1165 }
1166
1167
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
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
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
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
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
1299 if (NULL == prefix) {
1300 if (0 > asprintf(&prefx, " ")) {
1301 return PMIX_ERR_NOMEM;
1302 }
1303 } else {
1304 prefx = prefix;
1305 }
1306
1307
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
1339 if (NULL == prefix) {
1340 if (0 > asprintf(&prefx, " ")) {
1341 return PMIX_ERR_NOMEM;
1342 }
1343 } else {
1344 prefx = prefix;
1345 }
1346
1347
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
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
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
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
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
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
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
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
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
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
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
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
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
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 }