Scope path: split dynamic scope path
[babeltrace.git] / formats / ctf / metadata / ctf-visitor-generate-io-struct.c
1 /*
2 * ctf-visitor-generate-io-struct.c
3 *
4 * Common Trace Format Metadata Visitor (generate I/O structures).
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>
24 #include <glib.h>
25 #include <inttypes.h>
26 #include <errno.h>
27 #include <babeltrace/list.h>
28 #include <uuid/uuid.h>
29 #include "ctf-scanner.h"
30 #include "ctf-parser.h"
31 #include "ctf-ast.h"
32
33 #define fprintf_dbg(fd, fmt, args...) fprintf(fd, "%s: " fmt, __func__, ## args)
34
35 #define _cds_list_first_entry(ptr, type, member) \
36 cds_list_entry((ptr)->next, type, member)
37
38 static
39 int ctf_visitor_print_type_specifier(FILE *fd, int depth, struct ctf_node *node)
40 {
41 print_tabs(fd, depth);
42 fprintf(fd, "<type_specifier \"");
43
44 switch (node->u.type_specifier.type) {
45 case TYPESPEC_VOID:
46 fprintf(fd, "void");
47 break;
48 case TYPESPEC_CHAR:
49 fprintf(fd, "char");
50 break;
51 case TYPESPEC_SHORT:
52 fprintf(fd, "short");
53 break;
54 case TYPESPEC_INT:
55 fprintf(fd, "int");
56 break;
57 case TYPESPEC_LONG:
58 fprintf(fd, "long");
59 break;
60 case TYPESPEC_FLOAT:
61 fprintf(fd, "float");
62 break;
63 case TYPESPEC_DOUBLE:
64 fprintf(fd, "double");
65 break;
66 case TYPESPEC_SIGNED:
67 fprintf(fd, "signed");
68 break;
69 case TYPESPEC_UNSIGNED:
70 fprintf(fd, "unsigned");
71 break;
72 case TYPESPEC_BOOL:
73 fprintf(fd, "bool");
74 break;
75 case TYPESPEC_COMPLEX:
76 fprintf(fd, "_Complex");
77 break;
78 case TYPESPEC_IMAGINARY:
79 fprintf(fd, "_Imaginary");
80 break;
81 case TYPESPEC_CONST:
82 fprintf(fd, "const");
83 break;
84 case TYPESPEC_ID_TYPE:
85 fprintf(fd, "%s", node->u.type_specifier.id_type);
86 break;
87
88 case TYPESPEC_UNKNOWN:
89 default:
90 fprintf(stderr, "[error] %s: unknown type specifier %d\n", __func__,
91 (int) node->u.type_specifier.type);
92 return -EINVAL;
93 }
94 fprintf(fd, "\"/>\n");
95 return 0;
96 }
97
98 static
99 int ctf_visitor_print_type_declarator(FILE *fd, int depth, struct ctf_node *node)
100 {
101 int ret = 0;
102 struct ctf_node *iter;
103
104 print_tabs(fd, depth);
105 fprintf(fd, "<type_declarator>\n");
106 depth++;
107
108 if (!cds_list_empty(&node->u.type_declarator.pointers)) {
109 print_tabs(fd, depth);
110 fprintf(fd, "<pointers>\n");
111 cds_list_for_each_entry(iter, &node->u.type_declarator.pointers,
112 siblings) {
113 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
114 if (ret)
115 return ret;
116 }
117 print_tabs(fd, depth);
118 fprintf(fd, "</pointers>\n");
119 }
120
121 switch (node->u.type_declarator.type) {
122 case TYPEDEC_ID:
123 if (node->u.type_declarator.u.id) {
124 print_tabs(fd, depth);
125 fprintf(fd, "<id \"");
126 fprintf(fd, "%s", node->u.type_declarator.u.id);
127 fprintf(fd, "\" />\n");
128 }
129 break;
130 case TYPEDEC_NESTED:
131 if (node->u.type_declarator.u.nested.type_declarator) {
132 print_tabs(fd, depth);
133 fprintf(fd, "<type_declarator>\n");
134 ret = ctf_visitor_print_xml(fd, depth + 1,
135 node->u.type_declarator.u.nested.type_declarator);
136 if (ret)
137 return ret;
138 print_tabs(fd, depth);
139 fprintf(fd, "</type_declarator>\n");
140 }
141 if (node->u.type_declarator.u.nested.length) {
142 print_tabs(fd, depth);
143 fprintf(fd, "<length>\n");
144 ret = ctf_visitor_print_xml(fd, depth + 1,
145 node->u.type_declarator.u.nested.length);
146 if (ret)
147 return ret;
148 print_tabs(fd, depth);
149 fprintf(fd, "</length>\n");
150 }
151 if (node->u.type_declarator.u.nested.abstract_array) {
152 print_tabs(fd, depth);
153 fprintf(fd, "<length>\n");
154 print_tabs(fd, depth);
155 fprintf(fd, "</length>\n");
156 }
157 if (node->u.type_declarator.bitfield_len) {
158 print_tabs(fd, depth);
159 fprintf(fd, "<bitfield_len>\n");
160 ret = ctf_visitor_print_xml(fd, depth + 1,
161 node->u.type_declarator.bitfield_len);
162 if (ret)
163 return ret;
164 print_tabs(fd, depth);
165 fprintf(fd, "</bitfield_len>\n");
166 }
167 break;
168 case TYPEDEC_UNKNOWN:
169 default:
170 fprintf(stderr, "[error] %s: unknown type declarator %d\n", __func__,
171 (int) node->u.type_declarator.type);
172 return -EINVAL;
173 }
174
175 depth--;
176 print_tabs(fd, depth);
177 fprintf(fd, "</type_declarator>\n");
178 return 0;
179 }
180
181 /*
182 * String returned must be freed by the caller using g_free.
183 */
184 static
185 char *concatenate_unary_strings(struct list_head *head)
186 {
187 struct ctf_node *node;
188 GString *str;
189 int i = 0;
190
191 str = g_string_new();
192 cds_list_for_each_entry(node, head, siblings) {
193 char *src_string;
194
195 assert(node->type == NODE_UNARY_EXPRESSION);
196 assert(node->u.unary_expression.type == UNARY_STRING);
197 assert((node->u.unary_expression.link == UNARY_LINK_UNKNOWN)
198 ^ (i != 0))
199 switch (node->u.unary_expression.link) {
200 case UNARY_DOTLINK:
201 g_string_append(str, ".")
202 break;
203 case UNARY_ARROWLINK:
204 g_string_append(str, "->")
205 break;
206 case UNARY_DOTDOTDOT:
207 g_string_append(str, "...")
208 break;
209 }
210 src_string = u.unary_expression.u.string;
211 g_string_append(str, src_string);
212 i++;
213 }
214 return g_string_free(str, FALSE);
215 }
216
217 static
218 int get_unary_unsigned(struct list_head *head, uint64_t *value)
219 {
220 struct ctf_node *node;
221 int i = 0;
222
223 cds_list_for_each_entry(node, head, siblings) {
224 assert(node->type == NODE_UNARY_EXPRESSION);
225 assert(node->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT);
226 assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
227 assert(i == 0);
228 *value = node->u.unary_expression.unsigned_constant
229 i++;
230 }
231 return 0;
232 }
233
234 static
235 int get_unary_uuid(struct list_head *head, uuid_t *uuid)
236 {
237 struct ctf_node *node;
238 int i = 0;
239 int ret = -1;
240
241 cds_list_for_each_entry(node, head, siblings) {
242 const char *src_string;
243
244 assert(node->type == NODE_UNARY_EXPRESSION);
245 assert(node->u.unary_expression.type == UNARY_STRING);
246 assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
247 assert(i == 0);
248 src_string = u.unary_expression.u.string;
249 ret = uuid_parse(u.unary_expression.u.string, *uuid);
250 }
251 return ret;
252 }
253
254 static
255 struct ctf_stream *trace_stream_lookup(struct ctf_trace *trace, uint64_t stream_id)
256 {
257 if (trace->streams->len <= stream_id)
258 return NULL;
259 return g_ptr_array_index(trace->streams, stream_id);
260 }
261
262 /*
263 * Also add named variant, struct or enum to the current declaration scope.
264 */
265 static
266 struct ctf_declaration *ctf_declaration_specifier_visit(FILE *fd,
267 int depth, struct list_head *head,
268 struct declaration_scope *declaration_scope)
269 {
270 struct ctf_declaration *declaration;
271 struct node *first;
272
273 first = _cds_list_first_entry(head, struct node, siblings);
274
275 switch (first->type) {
276 case NODE_STRUCT:
277 /*
278 * For named struct (without body), lookup in
279 * declaration scope and create declaration copy.
280 */
281 /* For named struct (with body), create type and add to declaration scope */
282 /* For unnamed struct, create type */
283 break;
284 case NODE_VARIANT:
285 /*
286 * For named variant (without body), lookup in
287 * declaration scope and create declaration copy.
288 */
289 /* For named variant (with body), create type and add to declaration scope */
290 /* For unnamed variant, create type */
291 /* If variant has a tag field specifier, assign tag name. */
292 break;
293 case NODE_ENUM:
294 /*
295 * For named enum (without body), lookup in declaration
296 * scope and create declaration copy.
297 */
298 /* For named enum (with body), create type and add to declaration scope */
299 /* For unnamed enum, create type */
300 /* Enumerations need to have their size/type specifier (< >). */
301 break;
302 case NODE_INTEGER:
303 /*
304 * Create an integer declaration.
305 */
306 break;
307 case NODE_FLOATING_POINT:
308 /*
309 * Create a floating point declaration.
310 */
311 break;
312 case NODE_STRING:
313 /*
314 * Create a string declaration.
315 */
316 break;
317 case NODE_TYPE_SPECIFIER:
318 /*
319 * Lookup named type in typedef declarations (in
320 * declaration scope). Create a copy of the declaration.
321 */
322 break;
323
324 }
325 }
326
327 static
328 int ctf_typedef_declarator_visit(FILE *fd, int depth,
329 struct list_head *declaration_specifier,
330 struct node *type_declarator,
331 struct declaration_scope *declaration_scope)
332 {
333 /*
334 * Build the type using declaration specifier (creating
335 * declaration from type_specifier), then apply type declarator,
336 * add the resulting type to the current declaration scope.
337 */
338 cds_list_for_each_entry(iter, declaration_specifier, siblings) {
339
340
341 }
342 return 0;
343 }
344
345 static
346 int ctf_typedef_visit(FILE *fd, int depth,
347 struct list_head *declaration_specifier,
348 struct list_head *type_declarators,
349 struct declaration_scope *declaration_scope)
350 {
351 struct ctf_node *iter;
352
353 cds_list_for_each_entry(iter, type_declarators, siblings) {
354 ret = ctf_typedef_declarator_visit(fd, depth + 1,
355 &node->u._typedef.declaration_specifier, iter,
356 declaration_scope);
357 if (ret)
358 return ret;
359 }
360 return 0;
361 }
362
363 static
364 int ctf_typealias_visit(FILE *fd, int depth, struct ctf_node *target,
365 struct ctf_node *alias,
366 struct declaration_scope *declaration_scope)
367 {
368 /*
369 * Build target type, check that it is reachable in current
370 * declaration scope.
371 */
372
373 /* Only one type declarator is allowed */
374
375 /* Build alias type, add to current declaration scope. */
376 /* Only one type declarator is allowed */
377 }
378
379 static
380 int ctf_event_declaration_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_event *event, struct ctf_trace *trace)
381 {
382 int ret = 0;
383
384 switch (node->type) {
385 case NODE_TYPEDEF:
386 ret = ctf_typedef_visit(fd, depth + 1,
387 &node->u._typedef.declaration_specifier,
388 &node->u._typedef.type_declarators,
389 event->declaration_scope);
390 if (ret)
391 return ret;
392 break;
393 case NODE_TYPEALIAS:
394 ret = ctf_typealias_visit(fd, depth + 1,
395 &node->u.typealias.target, &node->u.typealias.alias
396 event->declaration_scope);
397 if (ret)
398 return ret;
399 break;
400 case NODE_CTF_EXPRESSION:
401 {
402 char *left;
403
404 left = concatenate_unary_strings(&node->u.ctf_expression.left);
405 if (!strcmp(left, "name")) {
406 char *right;
407
408 if (CTF_EVENT_FIELD_IS_SET(event, name))
409 return -EPERM;
410 right = concatenate_unary_strings(&node->u.ctf_expression.right);
411 if (!right) {
412 fprintf(stderr, "[error] %s: unexpected unary expression for event name\n", __func__);
413 return -EINVAL;
414 }
415 event->name = g_quark_from_string(right);
416 g_free(right);
417 CTF_EVENT_SET_FIELD(event, name);
418 } else if (!strcmp(left, "id")) {
419 if (CTF_EVENT_FIELD_IS_SET(event, id))
420 return -EPERM;
421 ret = get_unary_unsigned(&node->u.ctf_expression.right, &event->id);
422 if (ret) {
423 fprintf(stderr, "[error] %s: unexpected unary expression for event id\n", __func__);
424 return -EINVAL;
425 }
426 CTF_EVENT_SET_FIELD(event, id);
427 } else if (!strcmp(left, "stream_id")) {
428 if (CTF_EVENT_FIELD_IS_SET(event, stream_id))
429 return -EPERM;
430 ret = get_unary_unsigned(&node->u.ctf_expression.right, &event->stream_id);
431 if (ret) {
432 fprintf(stderr, "[error] %s: unexpected unary expression for event stream_id\n", __func__);
433 return -EINVAL;
434 }
435 event->stream = trace_stream_lookup(trace, event->stream_id);
436 if (!event->stream) {
437 fprintf(stderr, "[error] %s: stream id %" PRIu64 " cannot be found\n", __func__, event->stream_id);
438 return -EINVAL;
439 }
440 CTF_EVENT_SET_FIELD(event, stream_id);
441 } else if (!strcmp(left, "context")) {
442 struct declaration *declaration;
443
444 if (!event->definition_scope)
445 return -EPERM;
446 declaration = ctf_declaration_specifier_visit(fd, depth,
447 &node->u.ctf_expression.right,
448 event->declaration_scope);
449 if (!declaration)
450 return -EPERM;
451 if (declaration->type->id != CTF_TYPE_STRUCT)
452 return -EPERM;
453 event->context_decl = container_of(declaration, struct declaration_struct, p);
454 } else if (!strcmp(left, "fields")) {
455 struct declaration *declaration;
456
457 if (!event->definition_scope)
458 return -EPERM;
459 declaration = ctf_declaration_specifier_visit(fd, depth,
460 &node->u.ctf_expression.right,
461 event->declaration_scope);
462 if (!declaration)
463 return -EPERM;
464 if (declaration->type->id != CTF_TYPE_STRUCT)
465 return -EPERM;
466 event->fields_decl = container_of(declaration, struct declaration_struct, p);
467 }
468 g_free(left);
469 break;
470 }
471 default:
472 return -EPERM;
473 /* TODO: declaration specifier should be added. */
474 }
475
476 return 0;
477 }
478
479 static
480 int ctf_event_visit(FILE *fd, int depth, struct ctf_node *node,
481 struct declaration_scope *parent_declaration_scope, struct ctf_trace *trace)
482 {
483 int ret = 0;
484 struct ctf_node *iter;
485 struct ctf_event *event;
486 struct definition_scope *parent_def_scope;
487
488 event = g_new0(struct ctf_event, 1);
489 event->declaration_scope = new_declaration_scope(parent_declaration_scope);
490 cds_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
491 ret = ctf_event_declaration_visit(fd, depth + 1, iter, event, trace);
492 if (ret)
493 goto error;
494 }
495 if (!CTF_EVENT_FIELD_IS_SET(event, name)) {
496 ret = -EPERM;
497 goto error;
498 }
499 if (!CTF_EVENT_FIELD_IS_SET(event, id)) {
500 ret = -EPERM;
501 goto error;
502 }
503 if (!CTF_EVENT_FIELD_IS_SET(event, stream_id)) {
504 ret = -EPERM;
505 goto error;
506 }
507 if (event->stream->events_by_id->len <= event->id)
508 g_ptr_array_set_size(event->stream->events_by_id, event->id + 1);
509 g_ptr_array_index(event->stream->events_by_id, event->id) = event;
510 g_hash_table_insert(event->stream->event_quark_to_id,
511 (gpointer)(unsigned long) event->name,
512 &event->id);
513 parent_def_scope = stream->definition_scope;
514 if (event->context_decl) {
515 event->context =
516 event->context_decl->definition_new(event->context_decl,
517 parent_def_scope, 0, 0);
518 set_dynamic_definition_scope(&event->context->p,
519 event->context->scope,
520 "event.context");
521 parent_def_scope = event->context->scope;
522 declaration_unref(event->context_decl);
523 }
524 if (event->fields_decl) {
525 event->fields =
526 event->fields_decl->definition_new(event->fields_decl,
527 parent_def_scope, 0, 0);
528 set_dynamic_definition_scope(&event->fields->p,
529 event->fields->scope,
530 "event.fields");
531 parent_def_scope = event->fields->scope;
532 declaration_unref(event->fields_decl);
533 }
534 return 0;
535
536 error:
537 declaration_unref(event->fields_decl);
538 declaration_unref(event->context_decl);
539 free_definition_scope(event->definition_scope);
540 free_declaration_scope(event->declaration_scope);
541 g_free(event);
542 return ret;
543 }
544
545
546 static
547 int ctf_stream_declaration_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_stream *stream, struct ctf_trace *trace)
548 {
549 int ret = 0;
550
551 switch (node->type) {
552 case NODE_TYPEDEF:
553 ret = ctf_typedef_visit(fd, depth + 1,
554 &node->u._typedef.declaration_specifier,
555 &node->u._typedef.type_declarators,
556 stream->declaration_scope);
557 if (ret)
558 return ret;
559 break;
560 case NODE_TYPEALIAS:
561 ret = ctf_typealias_visit(fd, depth + 1,
562 &node->u.typealias.target, &node->u.typealias.alias
563 stream->declaration_scope);
564 if (ret)
565 return ret;
566 break;
567 case NODE_CTF_EXPRESSION:
568 {
569 char *left;
570
571 left = concatenate_unary_strings(&node->u.ctf_expression.left);
572 if (!strcmp(left, "stream_id")) {
573 if (CTF_EVENT_FIELD_IS_SET(event, stream_id))
574 return -EPERM;
575 ret = get_unary_unsigned(&node->u.ctf_expression.right, &event->stream_id);
576 if (ret) {
577 fprintf(stderr, "[error] %s: unexpected unary expression for event stream_id\n", __func__);
578 return -EINVAL;
579 }
580 CTF_EVENT_SET_FIELD(event, stream_id);
581 } else if (!strcmp(left, "event.header")) {
582 struct declaration *declaration;
583
584 declaration = ctf_declaration_specifier_visit(fd, depth,
585 &node->u.ctf_expression.right,
586 stream->declaration_scope, stream->definition_scope);
587 if (!declaration)
588 return -EPERM;
589 if (declaration->type->id != CTF_TYPE_STRUCT)
590 return -EPERM;
591 stream->event_header_decl = container_of(declaration, struct declaration_struct, p);
592 } else if (!strcmp(left, "event.context")) {
593 struct declaration *declaration;
594
595 declaration = ctf_declaration_specifier_visit(fd, depth,
596 &node->u.ctf_expression.right,
597 stream->declaration_scope);
598 if (!declaration)
599 return -EPERM;
600 if (declaration->type->id != CTF_TYPE_STRUCT)
601 return -EPERM;
602 stream->event_context_decl = container_of(declaration, struct declaration_struct, p);
603 } else if (!strcmp(left, "packet.context")) {
604 struct declaration *declaration;
605
606 declaration = ctf_declaration_specifier_visit(fd, depth,
607 &node->u.ctf_expression.right,
608 stream->declaration_scope);
609 if (!declaration)
610 return -EPERM;
611 if (declaration->type->id != CTF_TYPE_STRUCT)
612 return -EPERM;
613 stream->packet_context_decl = container_of(declaration, struct declaration_struct, p);
614 }
615 g_free(left);
616 break;
617 }
618 default:
619 return -EPERM;
620 /* TODO: declaration specifier should be added. */
621 }
622
623 return 0;
624 }
625
626 static
627 int ctf_stream_visit(FILE *fd, int depth, struct ctf_node *node,
628 struct declaration_scope *parent_declaration_scope, struct ctf_trace *trace)
629 {
630 int ret = 0;
631 struct ctf_node *iter;
632 struct ctf_stream *stream;
633 struct definition_scope *parent_def_scope;
634
635 stream = g_new0(struct ctf_stream, 1);
636 stream->declaration_scope = new_declaration_scope(parent_declaration_scope);
637 stream->events_by_id = g_ptr_array_new();
638 stream->event_quark_to_id = g_hash_table_new(g_int_hash, g_int_equal);
639 cds_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
640 ret = ctf_stream_declaration_visit(fd, depth + 1, iter, stream, trace);
641 if (ret)
642 goto error;
643 }
644 if (!CTF_EVENT_FIELD_IS_SET(stream, stream_id)) {
645 ret = -EPERM;
646 goto error;
647 }
648 if (trace->streams->len <= stream->stream_id)
649 g_ptr_array_set_size(trace->streams, stream->stream_id + 1);
650 g_ptr_array_index(trace->streams, stream->stream_id) = stream;
651
652 parent_def_scope = NULL;
653 if (stream->packet_context_decl) {
654 stream->packet_context =
655 stream->packet_context_decl->definition_new(stream->packet_context_decl,
656 parent_def_scope, 0, 0);
657 set_dynamic_definition_scope(&stream->packet_context->p,
658 stream->packet_context->scope,
659 "stream.packet.context");
660 parent_def_scope = stream->packet_context->scope;
661 declaration_unref(stream->packet_context_decl);
662 }
663 if (stream->event_header_decl) {
664 stream->event_header =
665 stream->event_header_decl->definition_new(stream->event_header_decl,
666 parent_def_scope, 0, 0);
667 set_dynamic_definition_scope(&stream->event_header->p,
668 stream->event_header->scope,
669 "stream.event.header");
670 parent_def_scope = stream->event_header->scope;
671 declaration_unref(stream->event_header_decl);
672 }
673 if (stream->event_context_decl) {
674 stream->event_context =
675 stream->event_context_decl->definition_new(stream->event_context_decl,
676 parent_def_scope, 0, 0);
677 set_dynamic_definition_scope(&stream->event_context->p,
678 stream->event_context->scope,
679 "stream.event.context");
680 parent_def_scope = stream->event_context->scope;
681 declaration_unref(stream->event_context_decl);
682 }
683 stream->definition_scope = parent_def_scope;
684
685 return 0;
686
687 error:
688 declaration_unref(stream->event_header);
689 declaration_unref(stream->event_context);
690 declaration_unref(stream->packet_context);
691 g_ptr_array_free(stream->events_by_id, TRUE);
692 g_hash_table_free(stream->event_quark_to_id);
693 free_definition_scope(stream->definition_scope);
694 free_declaration_scope(stream->declaration_scope);
695 g_free(stream);
696 return ret;
697 }
698
699 static
700 int ctf_trace_declaration_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace *trace)
701 {
702 int ret = 0;
703
704 switch (node->type) {
705 case NODE_TYPEDEF:
706 ret = ctf_typedef_visit(fd, depth + 1,
707 &node->u._typedef.declaration_specifier,
708 &node->u._typedef.type_declarators,
709 trace->declaration_scope);
710 if (ret)
711 return ret;
712 break;
713 case NODE_TYPEALIAS:
714 ret = ctf_typealias_visit(fd, depth + 1,
715 &node->u.typealias.target, &node->u.typealias.alias
716 trace->declaration_scope);
717 if (ret)
718 return ret;
719 break;
720 case NODE_CTF_EXPRESSION:
721 {
722 char *left;
723
724 left = concatenate_unary_strings(&node->u.ctf_expression.left);
725 if (!strcmp(left, "major")) {
726 if (CTF_EVENT_FIELD_IS_SET(trace, major))
727 return -EPERM;
728 ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->major);
729 if (ret) {
730 fprintf(stderr, "[error] %s: unexpected unary expression for trace major number\n", __func__);
731 return -EINVAL;
732 }
733 CTF_EVENT_SET_FIELD(trace, major);
734 } else if (!strcmp(left, "minor")) {
735 if (CTF_EVENT_FIELD_IS_SET(trace, minor))
736 return -EPERM;
737 ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->minor);
738 if (ret) {
739 fprintf(stderr, "[error] %s: unexpected unary expression for trace minor number\n", __func__);
740 return -EINVAL;
741 }
742 CTF_EVENT_SET_FIELD(trace, minor);
743 } else if (!strcmp(left, "word_size")) {
744 if (CTF_EVENT_FIELD_IS_SET(trace, word_size))
745 return -EPERM;
746 ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->word_size);
747 if (ret) {
748 fprintf(stderr, "[error] %s: unexpected unary expression for trace word_size\n", __func__);
749 return -EINVAL;
750 }
751 CTF_EVENT_SET_FIELD(trace, word_size);
752 } else if (!strcmp(left, "uuid")) {
753 if (CTF_EVENT_FIELD_IS_SET(trace, uuid))
754 return -EPERM;
755 ret = get_unary_uuid(&node->u.ctf_expression.right, &trace->uuid);
756 if (ret) {
757 fprintf(stderr, "[error] %s: unexpected unary expression for trace uuid\n", __func__);
758 return -EINVAL;
759 }
760 CTF_EVENT_SET_FIELD(trace, uuid);
761 }
762 g_free(left);
763 break;
764 }
765 default:
766 return -EPERM;
767 /* TODO: declaration specifier should be added. */
768 }
769
770 return 0;
771 }
772
773
774 static
775 int ctf_trace_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace *trace)
776 {
777 int ret = 0;
778 struct ctf_node *iter;
779
780 if (trace->declaration_scope)
781 return -EEXIST;
782 trace->declaration_scope = new_declaration_scope(trace->root_declaration_scope);
783 trace->definition_scope = new_dynamic_definition_scope(trace->root_definition_scope);
784 trace->streams = g_ptr_array_new();
785 cds_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
786 ret = ctf_trace_declaration_visit(fd, depth + 1, iter, trace);
787 if (ret)
788 goto error;
789 }
790 if (!CTF_EVENT_FIELD_IS_SET(trace, major)) {
791 ret = -EPERM;
792 goto error;
793 }
794 if (!CTF_EVENT_FIELD_IS_SET(trace, minor)) {
795 ret = -EPERM;
796 goto error;
797 }
798 if (!CTF_EVENT_FIELD_IS_SET(trace, uuid)) {
799 ret = -EPERM;
800 goto error;
801 }
802 if (!CTF_EVENT_FIELD_IS_SET(trace, word_size)) {
803 ret = -EPERM;
804 goto error;
805 }
806 return 0;
807
808 error:
809 g_ptr_array_free(trace->streams, TRUE);
810 free_definition_scope(stream->definition_scope);
811 free_declaration_scope(stream->declaration_scope);
812 return ret;
813 }
814
815 int _ctf_visitor(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace *trace)
816 {
817 int ret = 0;
818 struct ctf_node *iter;
819
820 switch (node->type) {
821 case NODE_ROOT:
822 cds_list_for_each_entry(iter, &node->u.root._typedef,
823 siblings) {
824 ret = ctf_typedef_visit(fd, depth + 1,
825 &iter->u._typedef.declaration_specifier,
826 &iter->u._typedef.type_declarators,
827 trace->declaration_scope);
828 if (ret)
829 return ret;
830 }
831 cds_list_for_each_entry(iter, &node->u.root.typealias,
832 siblings) {
833 ret = ctf_typealias_visit(fd, depth + 1,
834 &iter->u.typealias.target, &iter->u.typealias.alias
835 trace->declaration_scope);
836 if (ret)
837 return ret;
838 }
839 cds_list_for_each_entry(iter, &node->u.root.declaration_specifier, siblings) {
840 ret = ctf_declaration_specifier_visit(fd, depth, iter,
841 trace->root_declaration_scope);
842 if (ret)
843 return ret;
844 }
845 cds_list_for_each_entry(iter, &node->u.root.trace, siblings) {
846 ret = ctf_trace_visit(fd, depth + 1, iter, trace);
847 if (ret)
848 return ret;
849 }
850 cds_list_for_each_entry(iter, &node->u.root.stream, siblings) {
851 ret = ctf_stream_visit(fd, depth + 1, iter,
852 trace->root_declaration_scope, trace);
853 if (ret)
854 return ret;
855 }
856 cds_list_for_each_entry(iter, &node->u.root.event, siblings) {
857 ret = ctf_event_visit(fd, depth + 1, iter,
858 trace->root_declaration_scope, trace);
859 if (ret)
860 return ret;
861 }
862 break;
863
864 case NODE_TYPEALIAS_TARGET:
865 print_tabs(fd, depth);
866 fprintf(fd, "<target>\n");
867 depth++;
868
869 print_tabs(fd, depth);
870 fprintf(fd, "<declaration_specifier>\n");
871 cds_list_for_each_entry(iter, &node->u.typealias_target.declaration_specifier, siblings) {
872 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
873 if (ret)
874 return ret;
875 }
876 print_tabs(fd, depth);
877 fprintf(fd, "</declaration_specifier>\n");
878
879 print_tabs(fd, depth);
880 fprintf(fd, "<type_declarators>\n");
881 cds_list_for_each_entry(iter, &node->u.typealias_target.type_declarators, siblings) {
882 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
883 if (ret)
884 return ret;
885 }
886 print_tabs(fd, depth);
887 fprintf(fd, "</type_declarators>\n");
888
889 depth--;
890 print_tabs(fd, depth);
891 fprintf(fd, "</target>\n");
892 break;
893 case NODE_TYPEALIAS_ALIAS:
894 print_tabs(fd, depth);
895 fprintf(fd, "<alias>\n");
896 depth++;
897
898 print_tabs(fd, depth);
899 fprintf(fd, "<declaration_specifier>\n");
900 cds_list_for_each_entry(iter, &node->u.typealias_alias.declaration_specifier, siblings) {
901 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
902 if (ret)
903 return ret;
904 }
905 print_tabs(fd, depth);
906 fprintf(fd, "</declaration_specifier>\n");
907
908 print_tabs(fd, depth);
909 fprintf(fd, "<type_declarators>\n");
910 cds_list_for_each_entry(iter, &node->u.typealias_alias.type_declarators, siblings) {
911 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
912 if (ret)
913 return ret;
914 }
915 print_tabs(fd, depth);
916 fprintf(fd, "</type_declarators>\n");
917
918 depth--;
919 print_tabs(fd, depth);
920 fprintf(fd, "</alias>\n");
921 break;
922 case NODE_TYPEALIAS:
923 print_tabs(fd, depth);
924 fprintf(fd, "<typealias>\n");
925 ret = ctf_visitor_print_xml(fd, depth + 1, node->u.typealias.target);
926 if (ret)
927 return ret;
928 ret = ctf_visitor_print_xml(fd, depth + 1, node->u.typealias.alias);
929 if (ret)
930 return ret;
931 print_tabs(fd, depth);
932 fprintf(fd, "</typealias>\n");
933 break;
934
935 case NODE_TYPE_SPECIFIER:
936 ret = ctf_visitor_print_type_specifier(fd, depth, node);
937 if (ret)
938 return ret;
939 break;
940 case NODE_POINTER:
941 print_tabs(fd, depth);
942 if (node->u.pointer.const_qualifier)
943 fprintf(fd, "<const_pointer />\n");
944 else
945 fprintf(fd, "<pointer />\n");
946 break;
947 case NODE_TYPE_DECLARATOR:
948 ret = ctf_visitor_print_type_declarator(fd, depth, node);
949 if (ret)
950 return ret;
951 break;
952
953 case NODE_FLOATING_POINT:
954 print_tabs(fd, depth);
955 fprintf(fd, "<floating_point>\n");
956 cds_list_for_each_entry(iter, &node->u.floating_point.expressions, siblings) {
957 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
958 if (ret)
959 return ret;
960 }
961 print_tabs(fd, depth);
962 fprintf(fd, "</floating_point>\n");
963 break;
964 case NODE_INTEGER:
965 print_tabs(fd, depth);
966 fprintf(fd, "<integer>\n");
967 cds_list_for_each_entry(iter, &node->u.integer.expressions, siblings) {
968 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
969 if (ret)
970 return ret;
971 }
972 print_tabs(fd, depth);
973 fprintf(fd, "</integer>\n");
974 break;
975 case NODE_STRING:
976 print_tabs(fd, depth);
977 fprintf(fd, "<string>\n");
978 cds_list_for_each_entry(iter, &node->u.string.expressions, siblings) {
979 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
980 if (ret)
981 return ret;
982 }
983 print_tabs(fd, depth);
984 fprintf(fd, "</string>\n");
985 break;
986 case NODE_ENUMERATOR:
987 print_tabs(fd, depth);
988 fprintf(fd, "<enumerator");
989 if (node->u.enumerator.id)
990 fprintf(fd, " id=\"%s\"", node->u.enumerator.id);
991 fprintf(fd, ">\n");
992 cds_list_for_each_entry(iter, &node->u.enumerator.values, siblings) {
993 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
994 if (ret)
995 return ret;
996 }
997 print_tabs(fd, depth);
998 fprintf(fd, "</enumerator>\n");
999 break;
1000 case NODE_ENUM:
1001 print_tabs(fd, depth);
1002 if (node->u._struct.name)
1003 fprintf(fd, "<enum name=\"%s\">\n",
1004 node->u._enum.enum_id);
1005 else
1006 fprintf(fd, "<enum >\n");
1007 depth++;
1008
1009 if (node->u._enum.container_type) {
1010 print_tabs(fd, depth);
1011 fprintf(fd, "<container_type>\n");
1012 ret = ctf_visitor_print_xml(fd, depth + 1, node->u._enum.container_type);
1013 if (ret)
1014 return ret;
1015 print_tabs(fd, depth);
1016 fprintf(fd, "</container_type>\n");
1017 }
1018
1019 print_tabs(fd, depth);
1020 fprintf(fd, "<enumerator_list>\n");
1021 cds_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) {
1022 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
1023 if (ret)
1024 return ret;
1025 }
1026 print_tabs(fd, depth);
1027 fprintf(fd, "</enumerator_list>\n");
1028
1029 depth--;
1030 print_tabs(fd, depth);
1031 fprintf(fd, "</enum>\n");
1032 break;
1033 case NODE_STRUCT_OR_VARIANT_DECLARATION:
1034 print_tabs(fd, depth);
1035 fprintf(fd, "<declaration_specifier>\n");
1036 cds_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.declaration_specifier, siblings) {
1037 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
1038 if (ret)
1039 return ret;
1040 }
1041 print_tabs(fd, depth);
1042 fprintf(fd, "</declaration_specifier>\n");
1043
1044 print_tabs(fd, depth);
1045 fprintf(fd, "<type_declarators>\n");
1046 cds_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.type_declarators, siblings) {
1047 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
1048 if (ret)
1049 return ret;
1050 }
1051 print_tabs(fd, depth);
1052 fprintf(fd, "</type_declarators>\n");
1053 break;
1054 case NODE_VARIANT:
1055 print_tabs(fd, depth);
1056 fprintf(fd, "<variant");
1057 if (node->u.variant.name)
1058 fprintf(fd, " name=\"%s\"", node->u.variant.name);
1059 if (node->u.variant.choice)
1060 fprintf(fd, " choice=\"%s\"", node->u.variant.choice);
1061 fprintf(fd, ">\n");
1062 cds_list_for_each_entry(iter, &node->u.variant.declaration_list, siblings) {
1063 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
1064 if (ret)
1065 return ret;
1066 }
1067 print_tabs(fd, depth);
1068 fprintf(fd, "</variant>\n");
1069 break;
1070 case NODE_STRUCT:
1071 print_tabs(fd, depth);
1072 if (node->u._struct.name)
1073 fprintf(fd, "<struct name=\"%s\">\n",
1074 node->u._struct.name);
1075 else
1076 fprintf(fd, "<struct>\n");
1077 cds_list_for_each_entry(iter, &node->u._struct.declaration_list, siblings) {
1078 ret = ctf_visitor_print_xml(fd, depth + 1, iter);
1079 if (ret)
1080 return ret;
1081 }
1082 print_tabs(fd, depth);
1083 fprintf(fd, "</struct>\n");
1084 break;
1085
1086 case NODE_UNKNOWN:
1087 default:
1088 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
1089 (int) node->type);
1090 return -EINVAL;
1091 }
1092 return ret;
1093 }
This page took 0.051795 seconds and 5 git commands to generate.