projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
callsite: support instruction pointer field
[babeltrace.git] / formats / ctf / metadata / ctf-visitor-xml.c
CommitLineData
7de8808c
MD		 1/*
2 * ctf-visitor-xml.c
3 *
4 * Common Trace Format Metadata Visitor (XML dump).
5 *
6 * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
17 */
18
19#include <stdio.h>
20#include <unistd.h>
21#include <string.h>
22#include <stdlib.h>
23#include <assert.h>
7de8808c 24#include <glib.h>
380d60b1 25#include <inttypes.h>
7de8808c 26#include <errno.h>
70bd0a12 27#include <babeltrace/babeltrace-internal.h>
fe41395a 28#include <babeltrace/list.h>
7de8808c
MD		 29#include "ctf-scanner.h"
30#include "ctf-parser.h"
31#include "ctf-ast.h"
32
34f7b02c 33#define fprintf_dbg(fd, fmt, args...) fprintf(fd, "%s: " fmt, __func__, ## args)
7de8808c 34
67905e42
MD		 35static
36void print_tabs(FILE *fd, int depth)
7de8808c
MD		 37{
38 int i;
39
40 for (i = 0; i < depth; i++)
41 fprintf(fd, "\t");
42}
43
67905e42 44static
7de8808c
MD		 45int ctf_visitor_print_unary_expression(FILE *fd, int depth, struct ctf_node *node)
46{
47 int ret = 0;
48
48a01768
MD		 49 switch (node->u.unary_expression.link) {
50 case UNARY_LINK_UNKNOWN:
51 break;
52 case UNARY_DOTLINK:
53 print_tabs(fd, depth);
54 fprintf(fd, "<dotlink/>\n");
55 break;
56 case UNARY_ARROWLINK:
57 print_tabs(fd, depth);
58 fprintf(fd, "<arrowlink/>\n");
59 break;
60 case UNARY_DOTDOTDOT:
61 print_tabs(fd, depth);
62 fprintf(fd, "<dotdotdot/>\n");
63 break;
64 default:
65 fprintf(stderr, "[error] %s: unknown expression link type %d\n", __func__,
66 (int) node->u.unary_expression.link);
67 return -EINVAL;
68 }
69
7de8808c
MD		 70 switch (node->u.unary_expression.type) {
71 case UNARY_STRING:
72 print_tabs(fd, depth);
73 fprintf(fd, "<unary_expression value=");
74 fprintf(fd, "\"%s\"", node->u.unary_expression.u.string);
48a01768 75 fprintf(fd, " />\n");
7de8808c
MD		 76 break;
77 case UNARY_SIGNED_CONSTANT:
78 print_tabs(fd, depth);
a10a7e5b 79 fprintf(fd, "<unary_expression value=\"");
380d60b1 80 fprintf(fd, "%" PRId64, node->u.unary_expression.u.signed_constant);
a10a7e5b 81 fprintf(fd, "\" />\n");
7de8808c
MD		 82 break;
83 case UNARY_UNSIGNED_CONSTANT:
84 print_tabs(fd, depth);
a10a7e5b 85 fprintf(fd, "<unary_expression value=\"");
380d60b1 86 fprintf(fd, "%" PRIu64, node->u.unary_expression.u.signed_constant);
a10a7e5b 87 fprintf(fd, "\" />\n");
7de8808c
MD		 88 break;
89 case UNARY_SBRAC:
90 print_tabs(fd, depth);
4759bcf5 91 fprintf(fd, "<unary_expression_sbrac>\n");
7de8808c
MD		 92 ret = ctf_visitor_print_unary_expression(fd, depth + 1,
93 node->u.unary_expression.u.sbrac_exp);
94 if (ret)
95 return ret;
96 print_tabs(fd, depth);
4759bcf5 97 fprintf(fd, "</unary_expression_sbrac>\n");
7de8808c 98 break;
48a01768
MD		 99 case UNARY_NESTED:
100 print_tabs(fd, depth);
4759bcf5 101 fprintf(fd, "<unary_expression_nested>\n");
48a01768
MD		 102 ret = ctf_visitor_print_unary_expression(fd, depth + 1,
103 node->u.unary_expression.u.nested_exp);
104 if (ret)
105 return ret;
106 print_tabs(fd, depth);
4759bcf5 107 fprintf(fd, "</unary_expression_nested>\n");
48a01768 108 break;
7de8808c
MD		 109
110 case UNARY_UNKNOWN:
111 default:
112 fprintf(stderr, "[error] %s: unknown expression type %d\n", __func__,
113 (int) node->u.unary_expression.type);
114 return -EINVAL;
115 }
7de8808c
MD		 116 return 0;
117}
118
3e11b713
MD		 119static
120int ctf_visitor_print_type_specifier_list(FILE *fd, int depth, struct ctf_node *node)
121{
122 struct ctf_node *iter;
123 int ret;
124
125 print_tabs(fd, depth);
126 fprintf(fd, "<type_specifier_list>\n");
3122e6f0 127 bt_list_for_each_entry(iter, &node->u.type_specifier_list.head, siblings) {
3e11b713
MD		 128 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
129 if (ret)
130 return ret;
131 }
132 print_tabs(fd, depth);
133 fprintf(fd, "</type_specifier_list>\n");
134 return 0;
135}
136
67905e42 137static
7de8808c
MD		 138int ctf_visitor_print_type_specifier(FILE *fd, int depth, struct ctf_node *node)
139{
a10a7e5b 140 int ret;
7de8808c 141 print_tabs(fd, depth);
3e11b713
MD		 142
143 switch (node->u.type_specifier.type) {
144 case TYPESPEC_VOID:
145 case TYPESPEC_CHAR:
146 case TYPESPEC_SHORT:
147 case TYPESPEC_INT:
148 case TYPESPEC_LONG:
149 case TYPESPEC_FLOAT:
150 case TYPESPEC_DOUBLE:
151 case TYPESPEC_SIGNED:
152 case TYPESPEC_UNSIGNED:
153 case TYPESPEC_BOOL:
154 case TYPESPEC_COMPLEX:
155 case TYPESPEC_IMAGINARY:
156 case TYPESPEC_CONST:
157 case TYPESPEC_ID_TYPE:
a10a7e5b 158 fprintf(fd, "<type_specifier type=\"");
3e11b713
MD		 159 break;
160 case TYPESPEC_FLOATING_POINT:
161 case TYPESPEC_INTEGER:
162 case TYPESPEC_STRING:
163 case TYPESPEC_STRUCT:
164 case TYPESPEC_VARIANT:
165 case TYPESPEC_ENUM:
166 fprintf(fd, "<type_specifier>\n");
167 depth++;
168 break;
169 case TYPESPEC_UNKNOWN:
170 default:
171 fprintf(stderr, "[error] %s: unknown type specifier %d\n", __func__,
172 (int) node->u.type_specifier.type);
173 return -EINVAL;
174 }
7de8808c
MD		 175
176 switch (node->u.type_specifier.type) {
177 case TYPESPEC_VOID:
178 fprintf(fd, "void");
179 break;
180 case TYPESPEC_CHAR:
181 fprintf(fd, "char");
182 break;
183 case TYPESPEC_SHORT:
184 fprintf(fd, "short");
185 break;
186 case TYPESPEC_INT:
187 fprintf(fd, "int");
188 break;
189 case TYPESPEC_LONG:
190 fprintf(fd, "long");
191 break;
192 case TYPESPEC_FLOAT:
193 fprintf(fd, "float");
194 break;
195 case TYPESPEC_DOUBLE:
196 fprintf(fd, "double");
197 break;
198 case TYPESPEC_SIGNED:
199 fprintf(fd, "signed");
200 break;
201 case TYPESPEC_UNSIGNED:
202 fprintf(fd, "unsigned");
203 break;
204 case TYPESPEC_BOOL:
205 fprintf(fd, "bool");
206 break;
207 case TYPESPEC_COMPLEX:
3888a159
MD		 208 fprintf(fd, "_Complex");
209 break;
210 case TYPESPEC_IMAGINARY:
211 fprintf(fd, "_Imaginary");
7de8808c
MD		 212 break;
213 case TYPESPEC_CONST:
214 fprintf(fd, "const");
215 break;
216 case TYPESPEC_ID_TYPE:
217 fprintf(fd, "%s", node->u.type_specifier.id_type);
218 break;
3e11b713
MD		 219 case TYPESPEC_FLOATING_POINT:
220 case TYPESPEC_INTEGER:
221 case TYPESPEC_STRING:
222 case TYPESPEC_STRUCT:
223 case TYPESPEC_VARIANT:
224 case TYPESPEC_ENUM:
a10a7e5b
SM		 225 ret = ctf_visitor_print_xml(fd, depth, node->u.type_specifier.node);
226 if (ret)
227 return ret;
228 break;
3e11b713
MD		 229 case TYPESPEC_UNKNOWN:
230 default:
231 fprintf(stderr, "[error] %s: unknown type specifier %d\n", __func__,
232 (int) node->u.type_specifier.type);
233 return -EINVAL;
234 }
7de8808c 235
3e11b713
MD		 236 switch (node->u.type_specifier.type) {
237 case TYPESPEC_VOID:
238 case TYPESPEC_CHAR:
239 case TYPESPEC_SHORT:
240 case TYPESPEC_INT:
241 case TYPESPEC_LONG:
242 case TYPESPEC_FLOAT:
243 case TYPESPEC_DOUBLE:
244 case TYPESPEC_SIGNED:
245 case TYPESPEC_UNSIGNED:
246 case TYPESPEC_BOOL:
247 case TYPESPEC_COMPLEX:
248 case TYPESPEC_IMAGINARY:
249 case TYPESPEC_CONST:
250 case TYPESPEC_ID_TYPE:
251 fprintf(fd, "\"/>\n");
252 break;
253 case TYPESPEC_FLOATING_POINT:
254 case TYPESPEC_INTEGER:
255 case TYPESPEC_STRING:
256 case TYPESPEC_STRUCT:
257 case TYPESPEC_VARIANT:
258 case TYPESPEC_ENUM:
a10a7e5b 259 depth--;
3e11b713
MD		 260 print_tabs(fd, depth);
261 fprintf(fd, "</type_specifier>\n");
3e11b713 262 break;
7de8808c
MD		 263 case TYPESPEC_UNKNOWN:
264 default:
265 fprintf(stderr, "[error] %s: unknown type specifier %d\n", __func__,
266 (int) node->u.type_specifier.type);
267 return -EINVAL;
268 }
3e11b713 269
7de8808c
MD		 270 return 0;
271}
272
67905e42 273static
7de8808c
MD		 274int ctf_visitor_print_type_declarator(FILE *fd, int depth, struct ctf_node *node)
275{
276 int ret = 0;
277 struct ctf_node *iter;
278
279 print_tabs(fd, depth);
280 fprintf(fd, "<type_declarator>\n");
281 depth++;
282
3122e6f0 283 if (!bt_list_empty(&node->u.type_declarator.pointers)) {
48a01768
MD		 284 print_tabs(fd, depth);
285 fprintf(fd, "<pointers>\n");
3122e6f0 286 bt_list_for_each_entry(iter, &node->u.type_declarator.pointers,
48a01768
MD		 287 siblings) {
288 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
289 if (ret)
290 return ret;
291 }
292 print_tabs(fd, depth);
293 fprintf(fd, "</pointers>\n");
7de8808c 294 }
7de8808c
MD		 295
296 switch (node->u.type_declarator.type) {
297 case TYPEDEC_ID:
0009a725
MD		 298 if (node->u.type_declarator.u.id) {
299 print_tabs(fd, depth);
a10a7e5b 300 fprintf(fd, "<id name=\"");
0009a725
MD		 301 fprintf(fd, "%s", node->u.type_declarator.u.id);
302 fprintf(fd, "\" />\n");
303 }
7de8808c
MD		 304 break;
305 case TYPEDEC_NESTED:
306 if (node->u.type_declarator.u.nested.type_declarator) {
307 print_tabs(fd, depth);
308 fprintf(fd, "<type_declarator>\n");
309 ret = ctf_visitor_print_xml(fd, depth + 1,
310 node->u.type_declarator.u.nested.type_declarator);
311 if (ret)
312 return ret;
313 print_tabs(fd, depth);
314 fprintf(fd, "</type_declarator>\n");
315 }
7c7835b0
MD		 316 if (node->u.type_declarator.u.nested.abstract_array) {
317 print_tabs(fd, depth);
318 fprintf(fd, "<length>\n");
319 print_tabs(fd, depth);
320 fprintf(fd, "</length>\n");
3122e6f0 321 } else if (!bt_list_empty(&node->u.type_declarator.u.nested.length)) {
7de8808c
MD		 322 print_tabs(fd, depth);
323 fprintf(fd, "<length>\n");
3122e6f0 324 bt_list_for_each_entry(iter, &node->u.type_declarator.u.nested.length,
98df1c9f
MD		 325 siblings) {
326 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
327 if (ret)
328 return ret;
329 }
7de8808c
MD		 330 print_tabs(fd, depth);
331 fprintf(fd, "</length>\n");
332 }
7de8808c
MD		 333 if (node->u.type_declarator.bitfield_len) {
334 print_tabs(fd, depth);
335 fprintf(fd, "<bitfield_len>\n");
336 ret = ctf_visitor_print_xml(fd, depth + 1,
337 node->u.type_declarator.bitfield_len);
338 if (ret)
339 return ret;
340 print_tabs(fd, depth);
341 fprintf(fd, "</bitfield_len>\n");
342 }
343 break;
344 case TYPEDEC_UNKNOWN:
345 default:
346 fprintf(stderr, "[error] %s: unknown type declarator %d\n", __func__,
347 (int) node->u.type_declarator.type);
348 return -EINVAL;
349 }
350
351 depth--;
352 print_tabs(fd, depth);
353 fprintf(fd, "</type_declarator>\n");
354 return 0;
355}
356
357int ctf_visitor_print_xml(FILE *fd, int depth, struct ctf_node *node)
358{
359 int ret = 0;
360 struct ctf_node *iter;
361
362 switch (node->type) {
363 case NODE_ROOT:
364 print_tabs(fd, depth);
365 fprintf(fd, "<root>\n");
3122e6f0 366 bt_list_for_each_entry(iter, &node->u.root.declaration_list,
7de8808c
MD		 367 siblings) {
368 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
369 if (ret)
370 return ret;
371 }
3122e6f0 372 bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
7de8808c
MD		 373 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
374 if (ret)
375 return ret;
376 }
3122e6f0 377 bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
7de8808c
MD		 378 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
379 if (ret)
380 return ret;
381 }
3122e6f0 382 bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
7de8808c
MD		 383 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
384 if (ret)
385 return ret;
386 }
387 print_tabs(fd, depth);
388 fprintf(fd, "</root>\n");
389 break;
390
391 case NODE_EVENT:
392 print_tabs(fd, depth);
393 fprintf(fd, "<event>\n");
3122e6f0 394 bt_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
7de8808c
MD		 395 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
396 if (ret)
397 return ret;
398 }
399 print_tabs(fd, depth);
400 fprintf(fd, "</event>\n");
401 break;
402 case NODE_STREAM:
403 print_tabs(fd, depth);
404 fprintf(fd, "<stream>\n");
3122e6f0 405 bt_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
7de8808c
MD		 406 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
407 if (ret)
408 return ret;
409 }
410 print_tabs(fd, depth);
411 fprintf(fd, "</stream>\n");
412 break;
e2c76a4d
MD		 413 case NODE_ENV:
414 print_tabs(fd, depth);
415 fprintf(fd, "<env>\n");
3122e6f0 416 bt_list_for_each_entry(iter, &node->u.env.declaration_list, siblings) {
e2c76a4d
MD		 417 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
418 if (ret)
419 return ret;
420 }
421 print_tabs(fd, depth);
422 fprintf(fd, "</env>\n");
423 break;
7de8808c
MD		 424 case NODE_TRACE:
425 print_tabs(fd, depth);
426 fprintf(fd, "<trace>\n");
3122e6f0 427 bt_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
7de8808c
MD		 428 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
429 if (ret)
430 return ret;
431 }
432 print_tabs(fd, depth);
433 fprintf(fd, "</trace>\n");
434 break;
e2c76a4d
MD		 435 case NODE_CLOCK:
436 print_tabs(fd, depth);
437 fprintf(fd, "<clock>\n");
3122e6f0 438 bt_list_for_each_entry(iter, &node->u.clock.declaration_list, siblings) {
e2c76a4d
MD		 439 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
440 if (ret)
441 return ret;
442 }
443 print_tabs(fd, depth);
444 fprintf(fd, "</clock>\n");
445 break;
f133896d
MD		 446 case NODE_CALLSITE:
447 print_tabs(fd, depth);
448 fprintf(fd, "<callsite>\n");
449 bt_list_for_each_entry(iter, &node->u.callsite.declaration_list, siblings) {
450 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
451 if (ret)
452 return ret;
453 }
454 print_tabs(fd, depth);
455 fprintf(fd, "</callsite>\n");
456 break;
e2c76a4d 457
7de8808c
MD		 458
459 case NODE_CTF_EXPRESSION:
460 print_tabs(fd, depth);
461 fprintf(fd, "<ctf_expression>\n");
462 depth++;
463 print_tabs(fd, depth);
464 fprintf(fd, "<left>\n");
3122e6f0 465 bt_list_for_each_entry(iter, &node->u.ctf_expression.left, siblings) {
48a01768
MD		 466 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
467 if (ret)
468 return ret;
469 }
470
7de8808c
MD		 471 print_tabs(fd, depth);
472 fprintf(fd, "</left>\n");
473
474 print_tabs(fd, depth);
475 fprintf(fd, "<right>\n");
3122e6f0 476 bt_list_for_each_entry(iter, &node->u.ctf_expression.right, siblings) {
48a01768
MD		 477 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
478 if (ret)
479 return ret;
480 }
7de8808c
MD		 481 print_tabs(fd, depth);
482 fprintf(fd, "</right>\n");
483 depth--;
484 print_tabs(fd, depth);
485 fprintf(fd, "</ctf_expression>\n");
486 break;
487 case NODE_UNARY_EXPRESSION:
488 return ctf_visitor_print_unary_expression(fd, depth, node);
489
490 case NODE_TYPEDEF:
491 print_tabs(fd, depth);
492 fprintf(fd, "<typedef>\n");
493 depth++;
3e11b713
MD		 494 ret = ctf_visitor_print_xml(fd, depth + 1, node->u._typedef.type_specifier_list);
495 if (ret)
496 return ret;
7de8808c
MD		 497
498 print_tabs(fd, depth);
3e11b713 499 fprintf(fd, "<type_declarator_list>\n");
3122e6f0 500 bt_list_for_each_entry(iter, &node->u._typedef.type_declarators, siblings) {
7de8808c
MD		 501 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
502 if (ret)
503 return ret;
504 }
505 print_tabs(fd, depth);
3e11b713 506 fprintf(fd, "</type_declarator_list>\n");
7de8808c
MD		 507 depth--;
508 print_tabs(fd, depth);
509 fprintf(fd, "</typedef>\n");
510 break;
511 case NODE_TYPEALIAS_TARGET:
512 print_tabs(fd, depth);
513 fprintf(fd, "<target>\n");
514 depth++;
515
3e11b713
MD		 516 ret = ctf_visitor_print_xml(fd, depth, node->u.typealias_target.type_specifier_list);
517 if (ret)
518 return ret;
7de8808c
MD		 519
520 print_tabs(fd, depth);
3e11b713 521 fprintf(fd, "<type_declarator_list>\n");
3122e6f0 522 bt_list_for_each_entry(iter, &node->u.typealias_target.type_declarators, siblings) {
7de8808c
MD		 523 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
524 if (ret)
525 return ret;
526 }
527 print_tabs(fd, depth);
3e11b713 528 fprintf(fd, "</type_declarator_list>\n");
7de8808c
MD		 529
530 depth--;
531 print_tabs(fd, depth);
532 fprintf(fd, "</target>\n");
533 break;
534 case NODE_TYPEALIAS_ALIAS:
535 print_tabs(fd, depth);
536 fprintf(fd, "<alias>\n");
537 depth++;
538
3e11b713
MD		 539 ret = ctf_visitor_print_xml(fd, depth, node->u.typealias_alias.type_specifier_list);
540 if (ret)
541 return ret;
7de8808c
MD		 542
543 print_tabs(fd, depth);
3e11b713 544 fprintf(fd, "<type_declarator_list>\n");
3122e6f0 545 bt_list_for_each_entry(iter, &node->u.typealias_alias.type_declarators, siblings) {
7de8808c
MD		 546 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
547 if (ret)
548 return ret;
549 }
550 print_tabs(fd, depth);
3e11b713 551 fprintf(fd, "</type_declarator_list>\n");
7de8808c
MD		 552
553 depth--;
554 print_tabs(fd, depth);
555 fprintf(fd, "</alias>\n");
556 break;
557 case NODE_TYPEALIAS:
558 print_tabs(fd, depth);
559 fprintf(fd, "<typealias>\n");
560 ret = ctf_visitor_print_xml(fd, depth + 1, node->u.typealias.target);
561 if (ret)
562 return ret;
563 ret = ctf_visitor_print_xml(fd, depth + 1, node->u.typealias.alias);
564 if (ret)
565 return ret;
566 print_tabs(fd, depth);
567 fprintf(fd, "</typealias>\n");
568 break;
569
3e11b713
MD		 570 case NODE_TYPE_SPECIFIER_LIST:
571 ret = ctf_visitor_print_type_specifier_list(fd, depth, node);
572 if (ret)
573 return ret;
574 break;
575
7de8808c
MD		 576 case NODE_TYPE_SPECIFIER:
577 ret = ctf_visitor_print_type_specifier(fd, depth, node);
578 if (ret)
579 return ret;
580 break;
581 case NODE_POINTER:
582 print_tabs(fd, depth);
583 if (node->u.pointer.const_qualifier)
584 fprintf(fd, "<const_pointer />\n");
585 else
586 fprintf(fd, "<pointer />\n");
587 break;
588 case NODE_TYPE_DECLARATOR:
589 ret = ctf_visitor_print_type_declarator(fd, depth, node);
590 if (ret)
591 return ret;
592 break;
593
594 case NODE_FLOATING_POINT:
595 print_tabs(fd, depth);
596 fprintf(fd, "<floating_point>\n");
3122e6f0 597 bt_list_for_each_entry(iter, &node->u.floating_point.expressions, siblings) {
7de8808c
MD		 598 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
599 if (ret)
600 return ret;
601 }
602 print_tabs(fd, depth);
603 fprintf(fd, "</floating_point>\n");
604 break;
605 case NODE_INTEGER:
606 print_tabs(fd, depth);
607 fprintf(fd, "<integer>\n");
3122e6f0 608 bt_list_for_each_entry(iter, &node->u.integer.expressions, siblings) {
7de8808c
MD		 609 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
610 if (ret)
611 return ret;
612 }
613 print_tabs(fd, depth);
614 fprintf(fd, "</integer>\n");
615 break;
616 case NODE_STRING:
617 print_tabs(fd, depth);
618 fprintf(fd, "<string>\n");
3122e6f0 619 bt_list_for_each_entry(iter, &node->u.string.expressions, siblings) {
7de8808c
MD		 620 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
621 if (ret)
622 return ret;
623 }
624 print_tabs(fd, depth);
625 fprintf(fd, "</string>\n");
626 break;
627 case NODE_ENUMERATOR:
628 print_tabs(fd, depth);
629 fprintf(fd, "<enumerator");
630 if (node->u.enumerator.id)
631 fprintf(fd, " id=\"%s\"", node->u.enumerator.id);
632 fprintf(fd, ">\n");
3122e6f0 633 bt_list_for_each_entry(iter, &node->u.enumerator.values, siblings) {
48a01768 634 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
7de8808c
MD		 635 if (ret)
636 return ret;
637 }
638 print_tabs(fd, depth);
48a01768 639 fprintf(fd, "</enumerator>\n");
7de8808c
MD		 640 break;
641 case NODE_ENUM:
642 print_tabs(fd, depth);
643 if (node->u._struct.name)
644 fprintf(fd, "<enum name=\"%s\">\n",
645 node->u._enum.enum_id);
646 else
647 fprintf(fd, "<enum >\n");
648 depth++;
649
3e11b713 650 if (node->u._enum.container_type) {
7de8808c 651 print_tabs(fd, depth);
48a01768 652 fprintf(fd, "<container_type>\n");
6743829a
MD		 653 ret = ctf_visitor_print_xml(fd, depth + 1, node->u._enum.container_type);
654 if (ret)
655 return ret;
7de8808c 656 print_tabs(fd, depth);
48a01768 657 fprintf(fd, "</container_type>\n");
7de8808c
MD		 658 }
659
660 print_tabs(fd, depth);
48a01768 661 fprintf(fd, "<enumerator_list>\n");
3122e6f0 662 bt_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) {
7de8808c
MD		 663 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
664 if (ret)
665 return ret;
666 }
667 print_tabs(fd, depth);
48a01768 668 fprintf(fd, "</enumerator_list>\n");
7de8808c
MD		 669
670 depth--;
671 print_tabs(fd, depth);
672 fprintf(fd, "</enum>\n");
673 break;
674 case NODE_STRUCT_OR_VARIANT_DECLARATION:
3e11b713
MD		 675 ret = ctf_visitor_print_xml(fd, depth,
676 node->u.struct_or_variant_declaration.type_specifier_list);
677 if (ret)
678 return ret;
7de8808c
MD		 679
680 print_tabs(fd, depth);
3e11b713 681 fprintf(fd, "<type_declarator_list>\n");
3122e6f0 682 bt_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.type_declarators, siblings) {
7de8808c
MD		 683 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
684 if (ret)
685 return ret;
686 }
687 print_tabs(fd, depth);
3e11b713 688 fprintf(fd, "</type_declarator_list>\n");
7de8808c
MD		 689 break;
690 case NODE_VARIANT:
691 print_tabs(fd, depth);
692 fprintf(fd, "<variant");
693 if (node->u.variant.name)
694 fprintf(fd, " name=\"%s\"", node->u.variant.name);
695 if (node->u.variant.choice)
696 fprintf(fd, " choice=\"%s\"", node->u.variant.choice);
697 fprintf(fd, ">\n");
3122e6f0 698 bt_list_for_each_entry(iter, &node->u.variant.declaration_list, siblings) {
7de8808c
MD		 699 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
700 if (ret)
701 return ret;
702 }
703 print_tabs(fd, depth);
704 fprintf(fd, "</variant>\n");
705 break;
706 case NODE_STRUCT:
707 print_tabs(fd, depth);
708 if (node->u._struct.name)
709 fprintf(fd, "<struct name=\"%s\">\n",
710 node->u._struct.name);
711 else
712 fprintf(fd, "<struct>\n");
3122e6f0 713 bt_list_for_each_entry(iter, &node->u._struct.declaration_list, siblings) {
7de8808c
MD		 714 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
715 if (ret)
716 return ret;
717 }
718 print_tabs(fd, depth);
719 fprintf(fd, "</struct>\n");
3122e6f0 720 if (!bt_list_empty(&node->u._struct.min_align)) {
b7e35bad
MD		 721 print_tabs(fd, depth);
722 fprintf(fd, "<align>\n");
3122e6f0 723 bt_list_for_each_entry(iter, &node->u._struct.min_align, siblings) {
b7e35bad
MD		 724 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
725 if (ret)
726 return ret;
727 }
728 print_tabs(fd, depth);
729 fprintf(fd, "</align>\n");
730 }
7de8808c
MD		 731 break;
732
733 case NODE_UNKNOWN:
734 default:
735 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
736 (int) node->type);
737 return -EINVAL;
738 }
739 return ret;
740}
BabelTrace - Trace Format Babel Tower
This page took 0.05971 seconds and 4 git commands to generate.