2 * ctf-visitor-generate-io-struct.c
4 * Common Trace Format Metadata Visitor (generate I/O structures).
6 * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
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:
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
28 #include <babeltrace/list.h>
29 #include <babeltrace/types.h>
30 #include <babeltrace/ctf/metadata.h>
31 #include <uuid/uuid.h>
32 #include "ctf-scanner.h"
33 #include "ctf-parser.h"
36 #define fprintf_dbg(fd, fmt, args...) fprintf(fd, "%s: " fmt, __func__, ## args)
38 #define _cds_list_first_entry(ptr, type, member) \
39 cds_list_entry((ptr)->next, type, member)
42 struct declaration
*ctf_type_specifier_list_visit(FILE *fd
,
43 int depth
, struct ctf_node
*type_specifier_list
,
44 struct declaration_scope
*declaration_scope
,
45 struct ctf_trace
*trace
);
48 * String returned must be freed by the caller using g_free.
51 char *concatenate_unary_strings(struct cds_list_head
*head
)
53 struct ctf_node
*node
;
57 str
= g_string_new("");
58 cds_list_for_each_entry(node
, head
, siblings
) {
61 assert(node
->type
== NODE_UNARY_EXPRESSION
);
62 assert(node
->u
.unary_expression
.type
== UNARY_STRING
);
63 assert((node
->u
.unary_expression
.link
== UNARY_LINK_UNKNOWN
)
65 switch (node
->u
.unary_expression
.link
) {
67 g_string_append(str
, ".");
70 g_string_append(str
, "->");
73 g_string_append(str
, "...");
78 src_string
= node
->u
.unary_expression
.u
.string
;
79 g_string_append(str
, src_string
);
82 return g_string_free(str
, FALSE
);
86 int get_unary_unsigned(struct cds_list_head
*head
, uint64_t *value
)
88 struct ctf_node
*node
;
91 cds_list_for_each_entry(node
, head
, siblings
) {
92 assert(node
->type
== NODE_UNARY_EXPRESSION
);
93 assert(node
->u
.unary_expression
.type
== UNARY_UNSIGNED_CONSTANT
);
94 assert(node
->u
.unary_expression
.link
== UNARY_LINK_UNKNOWN
);
96 *value
= node
->u
.unary_expression
.u
.unsigned_constant
;
103 int get_unary_uuid(struct cds_list_head
*head
, uuid_t
*uuid
)
105 struct ctf_node
*node
;
109 cds_list_for_each_entry(node
, head
, siblings
) {
110 const char *src_string
;
112 assert(node
->type
== NODE_UNARY_EXPRESSION
);
113 assert(node
->u
.unary_expression
.type
== UNARY_STRING
);
114 assert(node
->u
.unary_expression
.link
== UNARY_LINK_UNKNOWN
);
116 src_string
= node
->u
.unary_expression
.u
.string
;
117 ret
= uuid_parse(node
->u
.unary_expression
.u
.string
, *uuid
);
123 struct ctf_stream
*trace_stream_lookup(struct ctf_trace
*trace
, uint64_t stream_id
)
125 if (trace
->streams
->len
<= stream_id
)
127 return g_ptr_array_index(trace
->streams
, stream_id
);
131 int visit_type_specifier(FILE *fd
, struct ctf_node
*type_specifier
, GString
*str
)
133 assert(type_specifier
->type
== NODE_TYPE_SPECIFIER
);
135 switch (type_specifier
->u
.type_specifier
.type
) {
137 g_string_append(str
, "void");
140 g_string_append(str
, "char");
143 g_string_append(str
, "short");
146 g_string_append(str
, "int");
149 g_string_append(str
, "long");
152 g_string_append(str
, "float");
154 case TYPESPEC_DOUBLE
:
155 g_string_append(str
, "double");
157 case TYPESPEC_SIGNED
:
158 g_string_append(str
, "signed");
160 case TYPESPEC_UNSIGNED
:
161 g_string_append(str
, "unsigned");
164 g_string_append(str
, "bool");
166 case TYPESPEC_COMPLEX
:
167 g_string_append(str
, "_Complex");
169 case TYPESPEC_IMAGINARY
:
170 g_string_append(str
, "_Imaginary");
173 g_string_append(str
, "const");
175 case TYPESPEC_ID_TYPE
:
176 if (type_specifier
->u
.type_specifier
.id_type
)
177 g_string_append(str
, type_specifier
->u
.type_specifier
.id_type
);
179 case TYPESPEC_STRUCT
:
181 struct ctf_node
*node
= type_specifier
->u
.type_specifier
.node
;
183 if (!node
->u
._struct
.name
) {
184 fprintf(fd
, "[error] %s: unexpected empty variant name\n", __func__
);
187 g_string_append(str
, "struct ");
188 g_string_append(str
, node
->u
._struct
.name
);
191 case TYPESPEC_VARIANT
:
193 struct ctf_node
*node
= type_specifier
->u
.type_specifier
.node
;
195 if (!node
->u
.variant
.name
) {
196 fprintf(fd
, "[error] %s: unexpected empty variant name\n", __func__
);
199 g_string_append(str
, "variant ");
200 g_string_append(str
, node
->u
.variant
.name
);
205 struct ctf_node
*node
= type_specifier
->u
.type_specifier
.node
;
207 if (!node
->u
._enum
.enum_id
) {
208 fprintf(fd
, "[error] %s: unexpected empty enum ID\n", __func__
);
211 g_string_append(str
, "enum ");
212 g_string_append(str
, node
->u
._enum
.enum_id
);
215 case TYPESPEC_FLOATING_POINT
:
216 case TYPESPEC_INTEGER
:
217 case TYPESPEC_STRING
:
219 fprintf(fd
, "[error] %s: unknown specifier\n", __func__
);
226 int visit_type_specifier_list(FILE *fd
, struct ctf_node
*type_specifier_list
, GString
*str
)
228 struct ctf_node
*iter
;
229 int alias_item_nr
= 0;
232 cds_list_for_each_entry(iter
, &type_specifier_list
->u
.type_specifier_list
.head
, siblings
) {
233 if (alias_item_nr
!= 0)
234 g_string_append(str
, " ");
236 ret
= visit_type_specifier(fd
, iter
, str
);
244 GQuark
create_typealias_identifier(FILE *fd
, int depth
,
245 struct ctf_node
*type_specifier_list
,
246 struct ctf_node
*node_type_declarator
)
248 struct ctf_node
*iter
;
254 str
= g_string_new("");
255 ret
= visit_type_specifier_list(fd
, type_specifier_list
, str
);
257 g_string_free(str
, TRUE
);
260 cds_list_for_each_entry(iter
, &node_type_declarator
->u
.type_declarator
.pointers
, siblings
) {
261 g_string_append(str
, " *");
262 if (iter
->u
.pointer
.const_qualifier
)
263 g_string_append(str
, " const");
265 str_c
= g_string_free(str
, FALSE
);
266 alias_q
= g_quark_from_string(str_c
);
272 struct declaration
*ctf_type_declarator_visit(FILE *fd
, int depth
,
273 struct ctf_node
*type_specifier_list
,
275 struct ctf_node
*node_type_declarator
,
276 struct declaration_scope
*declaration_scope
,
277 struct declaration
*nested_declaration
,
278 struct ctf_trace
*trace
)
281 * Visit type declarator by first taking care of sequence/array
282 * (recursively). Then, when we get to the identifier, take care
286 if (node_type_declarator
) {
287 assert(node_type_declarator
->u
.type_declarator
.type
!= TYPEDEC_UNKNOWN
);
289 /* TODO: gcc bitfields not supported yet. */
290 if (node_type_declarator
->u
.type_declarator
.bitfield_len
!= NULL
) {
291 fprintf(fd
, "[error] %s: gcc bitfields are not supported yet.\n", __func__
);
296 if (!nested_declaration
) {
297 if (node_type_declarator
&& !cds_list_empty(&node_type_declarator
->u
.type_declarator
.pointers
)) {
301 * If we have a pointer declarator, it _has_ to be present in
302 * the typealiases (else fail).
304 alias_q
= create_typealias_identifier(fd
, depth
,
305 type_specifier_list
, node_type_declarator
);
306 nested_declaration
= lookup_declaration(alias_q
, declaration_scope
);
307 if (!nested_declaration
) {
308 fprintf(fd
, "[error] %s: cannot find typealias \"%s\".\n", __func__
, g_quark_to_string(alias_q
));
312 nested_declaration
= ctf_type_specifier_list_visit(fd
, depth
,
313 type_specifier_list
, declaration_scope
, trace
);
317 if (!node_type_declarator
)
318 return nested_declaration
;
320 if (node_type_declarator
->u
.type_declarator
.type
== TYPEDEC_ID
) {
321 if (node_type_declarator
->u
.type_declarator
.u
.id
)
322 *field_name
= g_quark_from_string(node_type_declarator
->u
.type_declarator
.u
.id
);
325 return nested_declaration
;
327 struct declaration
*declaration
;
328 struct ctf_node
*length
;
332 /* create array/sequence, pass nested_declaration as child. */
333 length
= node_type_declarator
->u
.type_declarator
.u
.nested
.length
;
335 fprintf(fd
, "[error] %s: expecting length type or value.\n", __func__
);
338 switch (length
->type
) {
339 case NODE_UNARY_EXPRESSION
:
341 struct declaration_array
*array_declaration
;
344 if (length
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
345 fprintf(fd
, "[error] %s: array: unexpected unary expression.\n", __func__
);
348 len
= length
->u
.unary_expression
.u
.unsigned_constant
;
349 array_declaration
= array_declaration_new(len
, nested_declaration
,
351 declaration
= &array_declaration
->p
;
355 case NODE_TYPE_SPECIFIER
:
357 struct declaration_sequence
*sequence_declaration
;
358 struct declaration_integer
*integer_declaration
;
361 declaration
= ctf_type_declarator_visit(fd
, depth
,
366 assert(declaration
->id
== CTF_TYPE_INTEGER
);
367 integer_declaration
= container_of(declaration
, struct declaration_integer
, p
);
368 sequence_declaration
= sequence_declaration_new(integer_declaration
,
369 nested_declaration
, declaration_scope
);
370 declaration
= &sequence_declaration
->p
;
377 /* Pass it as content of outer container */
378 declaration
= ctf_type_declarator_visit(fd
, depth
,
379 type_specifier_list
, field_name
,
380 node_type_declarator
->u
.type_declarator
.u
.nested
.type_declarator
,
381 declaration_scope
, declaration
, trace
);
387 int ctf_struct_type_declarators_visit(FILE *fd
, int depth
,
388 struct declaration_struct
*struct_declaration
,
389 struct ctf_node
*type_specifier_list
,
390 struct cds_list_head
*type_declarators
,
391 struct declaration_scope
*declaration_scope
,
392 struct ctf_trace
*trace
)
394 struct ctf_node
*iter
;
397 cds_list_for_each_entry(iter
, type_declarators
, siblings
) {
398 struct declaration
*field_declaration
;
400 field_declaration
= ctf_type_declarator_visit(fd
, depth
,
403 struct_declaration
->scope
,
405 struct_declaration_add_field(struct_declaration
,
406 g_quark_to_string(field_name
),
413 int ctf_variant_type_declarators_visit(FILE *fd
, int depth
,
414 struct declaration_untagged_variant
*untagged_variant_declaration
,
415 struct ctf_node
*type_specifier_list
,
416 struct cds_list_head
*type_declarators
,
417 struct declaration_scope
*declaration_scope
,
418 struct ctf_trace
*trace
)
420 struct ctf_node
*iter
;
423 cds_list_for_each_entry(iter
, type_declarators
, siblings
) {
424 struct declaration
*field_declaration
;
426 field_declaration
= ctf_type_declarator_visit(fd
, depth
,
429 untagged_variant_declaration
->scope
,
431 untagged_variant_declaration_add_field(untagged_variant_declaration
,
432 g_quark_to_string(field_name
),
439 int ctf_typedef_visit(FILE *fd
, int depth
, struct declaration_scope
*scope
,
440 struct ctf_node
*type_specifier_list
,
441 struct cds_list_head
*type_declarators
,
442 struct ctf_trace
*trace
)
444 struct ctf_node
*iter
;
447 cds_list_for_each_entry(iter
, type_declarators
, siblings
) {
448 struct declaration
*type_declaration
;
451 type_declaration
= ctf_type_declarator_visit(fd
, depth
,
455 ret
= register_declaration(identifier
, type_declaration
, scope
);
457 type_declaration
->declaration_free(type_declaration
);
465 int ctf_typealias_visit(FILE *fd
, int depth
, struct declaration_scope
*scope
,
466 struct ctf_node
*target
, struct ctf_node
*alias
,
467 struct ctf_trace
*trace
)
469 struct declaration
*type_declaration
;
470 struct ctf_node
*node
;
475 /* See ctf_visitor_type_declarator() in the semantic validator. */
478 * Create target type declaration.
481 if (cds_list_empty(&target
->u
.typealias_target
.type_declarators
))
484 node
= _cds_list_first_entry(&target
->u
.typealias_target
.type_declarators
,
485 struct ctf_node
, siblings
);
486 type_declaration
= ctf_type_declarator_visit(fd
, depth
,
487 target
->u
.typealias_target
.type_specifier_list
,
490 if (!type_declaration
) {
491 fprintf(fd
, "[error] %s: problem creating type declaration\n", __func__
);
496 * The semantic validator does not check whether the target is
497 * abstract or not (if it has an identifier). Check it here.
500 fprintf(fd
, "[error] %s: expecting empty identifier\n", __func__
);
505 * Create alias identifier.
508 node
= _cds_list_first_entry(&alias
->u
.typealias_alias
.type_declarators
,
509 struct ctf_node
, siblings
);
510 alias_q
= create_typealias_identifier(fd
, depth
,
511 alias
->u
.typealias_alias
.type_specifier_list
, node
);
512 err
= register_declaration(alias_q
, type_declaration
, scope
);
518 type_declaration
->declaration_free(type_declaration
);
523 int ctf_struct_declaration_list_visit(FILE *fd
, int depth
,
524 struct ctf_node
*iter
, struct declaration_struct
*struct_declaration
,
525 struct ctf_trace
*trace
)
529 switch (iter
->type
) {
531 /* For each declarator, declare type and add type to struct declaration scope */
532 ret
= ctf_typedef_visit(fd
, depth
,
533 struct_declaration
->scope
,
534 iter
->u
._typedef
.type_specifier_list
,
535 &iter
->u
._typedef
.type_declarators
, trace
);
540 /* Declare type with declarator and add type to struct declaration scope */
541 ret
= ctf_typealias_visit(fd
, depth
,
542 struct_declaration
->scope
,
543 iter
->u
.typealias
.target
,
544 iter
->u
.typealias
.alias
, trace
);
548 case NODE_STRUCT_OR_VARIANT_DECLARATION
:
549 /* Add field to structure declaration */
550 ret
= ctf_struct_type_declarators_visit(fd
, depth
,
552 iter
->u
.struct_or_variant_declaration
.type_specifier_list
,
553 &iter
->u
.struct_or_variant_declaration
.type_declarators
,
554 struct_declaration
->scope
, trace
);
559 fprintf(fd
, "[error] %s: unexpected node type %d\n", __func__
, (int) iter
->type
);
566 int ctf_variant_declaration_list_visit(FILE *fd
, int depth
,
567 struct ctf_node
*iter
,
568 struct declaration_untagged_variant
*untagged_variant_declaration
,
569 struct ctf_trace
*trace
)
573 switch (iter
->type
) {
575 /* For each declarator, declare type and add type to variant declaration scope */
576 ret
= ctf_typedef_visit(fd
, depth
,
577 untagged_variant_declaration
->scope
,
578 iter
->u
._typedef
.type_specifier_list
,
579 &iter
->u
._typedef
.type_declarators
, trace
);
584 /* Declare type with declarator and add type to variant declaration scope */
585 ret
= ctf_typealias_visit(fd
, depth
,
586 untagged_variant_declaration
->scope
,
587 iter
->u
.typealias
.target
,
588 iter
->u
.typealias
.alias
, trace
);
592 case NODE_STRUCT_OR_VARIANT_DECLARATION
:
593 /* Add field to structure declaration */
594 ret
= ctf_variant_type_declarators_visit(fd
, depth
,
595 untagged_variant_declaration
,
596 iter
->u
.struct_or_variant_declaration
.type_specifier_list
,
597 &iter
->u
.struct_or_variant_declaration
.type_declarators
,
598 untagged_variant_declaration
->scope
, trace
);
603 fprintf(fd
, "[error] %s: unexpected node type %d\n", __func__
, (int) iter
->type
);
610 struct declaration
*ctf_declaration_struct_visit(FILE *fd
,
611 int depth
, const char *name
, struct cds_list_head
*declaration_list
,
612 int has_body
, struct declaration_scope
*declaration_scope
,
613 struct ctf_trace
*trace
)
615 struct declaration_struct
*struct_declaration
;
616 struct ctf_node
*iter
;
620 * For named struct (without body), lookup in
621 * declaration scope. Don't take reference on struct
622 * declaration: ref is only taken upon definition.
627 lookup_struct_declaration(g_quark_from_string(name
),
629 return &struct_declaration
->p
;
631 /* For unnamed struct, create type */
632 /* For named struct (with body), create type and add to declaration scope */
634 if (lookup_struct_declaration(g_quark_from_string(name
),
635 declaration_scope
)) {
637 fprintf(fd
, "[error] %s: struct %s already declared in scope\n", __func__
, name
);
641 struct_declaration
= struct_declaration_new(declaration_scope
);
642 cds_list_for_each_entry(iter
, declaration_list
, siblings
) {
643 ret
= ctf_struct_declaration_list_visit(fd
, depth
+ 1, iter
,
644 struct_declaration
, trace
);
649 ret
= register_struct_declaration(g_quark_from_string(name
),
654 return &struct_declaration
->p
;
657 struct_declaration
->p
.declaration_free(&struct_declaration
->p
);
662 struct declaration
*ctf_declaration_variant_visit(FILE *fd
,
663 int depth
, const char *name
, const char *choice
,
664 struct cds_list_head
*declaration_list
,
665 int has_body
, struct declaration_scope
*declaration_scope
,
666 struct ctf_trace
*trace
)
668 struct declaration_untagged_variant
*untagged_variant_declaration
;
669 struct declaration_variant
*variant_declaration
;
670 struct ctf_node
*iter
;
674 * For named variant (without body), lookup in
675 * declaration scope. Don't take reference on variant
676 * declaration: ref is only taken upon definition.
680 untagged_variant_declaration
=
681 lookup_variant_declaration(g_quark_from_string(name
),
684 /* For unnamed variant, create type */
685 /* For named variant (with body), create type and add to declaration scope */
687 if (lookup_variant_declaration(g_quark_from_string(name
),
688 declaration_scope
)) {
690 fprintf(fd
, "[error] %s: variant %s already declared in scope\n", __func__
, name
);
694 untagged_variant_declaration
= untagged_variant_declaration_new(declaration_scope
);
695 cds_list_for_each_entry(iter
, declaration_list
, siblings
) {
696 ret
= ctf_variant_declaration_list_visit(fd
, depth
+ 1, iter
,
697 untagged_variant_declaration
, trace
);
702 ret
= register_variant_declaration(g_quark_from_string(name
),
703 untagged_variant_declaration
,
709 * if tagged, create tagged variant and return. else return
713 return &untagged_variant_declaration
->p
;
715 variant_declaration
= variant_declaration_new(untagged_variant_declaration
, choice
);
716 if (!variant_declaration
)
718 declaration_unref(&untagged_variant_declaration
->p
);
719 return &variant_declaration
->p
;
722 untagged_variant_declaration
->p
.declaration_free(&variant_declaration
->p
);
727 int ctf_enumerator_list_visit(FILE *fd
, int depth
,
728 struct ctf_node
*enumerator
,
729 struct declaration_enum
*enum_declaration
)
732 struct ctf_node
*iter
;
734 q
= g_quark_from_string(enumerator
->u
.enumerator
.id
);
735 if (enum_declaration
->integer_declaration
->signedness
) {
739 cds_list_for_each_entry(iter
, &enumerator
->u
.enumerator
.values
, siblings
) {
742 assert(iter
->type
== NODE_UNARY_EXPRESSION
);
748 switch (iter
->u
.unary_expression
.type
) {
749 case UNARY_SIGNED_CONSTANT
:
750 *target
= iter
->u
.unary_expression
.u
.signed_constant
;
752 case UNARY_UNSIGNED_CONSTANT
:
753 *target
= iter
->u
.unary_expression
.u
.unsigned_constant
;
756 fprintf(fd
, "[error] %s: invalid enumerator\n", __func__
);
760 fprintf(fd
, "[error] %s: invalid enumerator\n", __func__
);
767 enum_signed_insert(enum_declaration
, start
, end
, q
);
772 cds_list_for_each_entry(iter
, &enumerator
->u
.enumerator
.values
, siblings
) {
775 assert(iter
->type
== NODE_UNARY_EXPRESSION
);
781 switch (iter
->u
.unary_expression
.type
) {
782 case UNARY_UNSIGNED_CONSTANT
:
783 *target
= iter
->u
.unary_expression
.u
.unsigned_constant
;
785 case UNARY_SIGNED_CONSTANT
:
787 * We don't accept signed constants for enums with unsigned
790 fprintf(fd
, "[error] %s: invalid enumerator (signed constant encountered, but enum container type is unsigned)\n", __func__
);
793 fprintf(fd
, "[error] %s: invalid enumerator\n", __func__
);
797 fprintf(fd
, "[error] %s: invalid enumerator\n", __func__
);
804 enum_unsigned_insert(enum_declaration
, start
, end
, q
);
810 struct declaration
*ctf_declaration_enum_visit(FILE *fd
, int depth
,
812 struct ctf_node
*container_type
,
813 struct cds_list_head
*enumerator_list
,
815 struct declaration_scope
*declaration_scope
,
816 struct ctf_trace
*trace
)
818 struct declaration
*declaration
;
819 struct declaration_enum
*enum_declaration
;
820 struct declaration_integer
*integer_declaration
;
821 struct ctf_node
*iter
;
826 * For named enum (without body), lookup in
827 * declaration scope. Don't take reference on enum
828 * declaration: ref is only taken upon definition.
833 lookup_enum_declaration(g_quark_from_string(name
),
835 return &enum_declaration
->p
;
837 /* For unnamed enum, create type */
838 /* For named enum (with body), create type and add to declaration scope */
840 if (lookup_enum_declaration(g_quark_from_string(name
),
841 declaration_scope
)) {
843 fprintf(fd
, "[error] %s: enum %s already declared in scope\n", __func__
, name
);
847 if (!container_type
) {
848 fprintf(fd
, "[error] %s: missing container type for enumeration\n", __func__
);
852 switch (container_type
->type
) {
854 case NODE_TYPE_SPECIFIER
:
855 declaration
= ctf_type_declarator_visit(fd
, depth
,
860 assert(declaration
->id
== CTF_TYPE_INTEGER
);
861 integer_declaration
= container_of(declaration
, struct declaration_integer
, p
);
866 enum_declaration
= enum_declaration_new(integer_declaration
);
867 declaration_unref(&integer_declaration
->p
); /* leave ref to enum */
868 cds_list_for_each_entry(iter
, enumerator_list
, siblings
) {
869 ret
= ctf_enumerator_list_visit(fd
, depth
+ 1, iter
, enum_declaration
);
874 ret
= register_enum_declaration(g_quark_from_string(name
),
879 return &enum_declaration
->p
;
882 enum_declaration
->p
.declaration_free(&enum_declaration
->p
);
887 struct declaration
*ctf_declaration_type_specifier_visit(FILE *fd
, int depth
,
888 struct ctf_node
*type_specifier_list
,
889 struct declaration_scope
*declaration_scope
)
892 struct declaration
*declaration
;
897 str
= g_string_new("");
898 ret
= visit_type_specifier_list(fd
, type_specifier_list
, str
);
901 str_c
= g_string_free(str
, FALSE
);
902 id_q
= g_quark_from_string(str_c
);
904 declaration
= lookup_declaration(id_q
, declaration_scope
);
909 * Returns 0/1 boolean, or < 0 on error.
912 int get_boolean(FILE *fd
, int depth
, struct ctf_node
*unary_expression
)
914 if (unary_expression
->type
!= NODE_UNARY_EXPRESSION
) {
915 fprintf(fd
, "[error] %s: expecting unary expression\n",
919 switch (unary_expression
->u
.unary_expression
.type
) {
920 case UNARY_UNSIGNED_CONSTANT
:
921 if (unary_expression
->u
.unary_expression
.u
.unsigned_constant
== 0)
925 case UNARY_SIGNED_CONSTANT
:
926 if (unary_expression
->u
.unary_expression
.u
.signed_constant
== 0)
931 if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "true"))
933 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "TRUE"))
935 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "false"))
937 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "FALSE"))
940 fprintf(fd
, "[error] %s: unexpected string \"%s\"\n",
941 __func__
, unary_expression
->u
.unary_expression
.u
.string
);
946 fprintf(fd
, "[error] %s: unexpected unary expression type\n",
954 int get_byte_order(FILE *fd
, int depth
, struct ctf_node
*unary_expression
,
955 struct ctf_trace
*trace
)
959 if (unary_expression
->u
.unary_expression
.type
!= UNARY_STRING
) {
960 fprintf(fd
, "[error] %s: byte_order: expecting string\n",
964 if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "native"))
965 byte_order
= trace
->byte_order
;
966 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "network"))
967 byte_order
= BIG_ENDIAN
;
968 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "be"))
969 byte_order
= BIG_ENDIAN
;
970 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "le"))
971 byte_order
= LITTLE_ENDIAN
;
973 fprintf(fd
, "[error] %s: unexpected string \"%s\". Should be \"native\", \"network\", \"be\" or \"le\".\n",
974 __func__
, unary_expression
->u
.unary_expression
.u
.string
);
981 struct declaration
*ctf_declaration_integer_visit(FILE *fd
, int depth
,
982 struct cds_list_head
*expressions
,
983 struct ctf_trace
*trace
)
985 struct ctf_node
*expression
;
986 uint64_t alignment
, size
;
987 int byte_order
= trace
->byte_order
;
989 int has_alignment
= 0, has_size
= 0;
990 struct declaration_integer
*integer_declaration
;
992 cds_list_for_each_entry(expression
, expressions
, siblings
) {
993 struct ctf_node
*left
, *right
;
995 left
= _cds_list_first_entry(&expression
->u
.ctf_expression
.left
, struct ctf_node
, siblings
);
996 right
= _cds_list_first_entry(&expression
->u
.ctf_expression
.right
, struct ctf_node
, siblings
);
997 assert(left
->u
.unary_expression
.type
== UNARY_STRING
);
998 if (!strcmp(left
->u
.unary_expression
.u
.string
, "signed")) {
999 signedness
= get_boolean(fd
, depth
, right
);
1002 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "byte_order")) {
1003 byte_order
= get_byte_order(fd
, depth
, right
, trace
);
1006 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "size")) {
1007 if (right
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
1008 fprintf(fd
, "[error] %s: size: expecting unsigned constant\n",
1012 size
= right
->u
.unary_expression
.u
.unsigned_constant
;
1014 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "align")) {
1015 if (right
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
1016 fprintf(fd
, "[error] %s: align: expecting unsigned constant\n",
1020 alignment
= right
->u
.unary_expression
.u
.unsigned_constant
;
1023 fprintf(fd
, "[error] %s: unknown attribute name %s\n",
1024 __func__
, left
->u
.unary_expression
.u
.string
);
1029 fprintf(fd
, "[error] %s: missing size attribute\n", __func__
);
1032 if (!has_alignment
) {
1033 if (size
% CHAR_BIT
) {
1034 /* bit-packed alignment */
1037 /* byte-packed alignment */
1038 alignment
= CHAR_BIT
;
1041 integer_declaration
= integer_declaration_new(size
,
1042 byte_order
, signedness
, alignment
);
1043 return &integer_declaration
->p
;
1047 struct declaration
*ctf_declaration_floating_point_visit(FILE *fd
, int depth
,
1048 struct cds_list_head
*expressions
,
1049 struct ctf_trace
*trace
)
1051 struct ctf_node
*expression
;
1052 uint64_t alignment
, exp_dig
, mant_dig
, byte_order
= trace
->byte_order
;
1053 int has_alignment
= 0, has_exp_dig
= 0, has_mant_dig
= 0;
1054 struct declaration_float
*float_declaration
;
1056 cds_list_for_each_entry(expression
, expressions
, siblings
) {
1057 struct ctf_node
*left
, *right
;
1059 left
= _cds_list_first_entry(&expression
->u
.ctf_expression
.left
, struct ctf_node
, siblings
);
1060 right
= _cds_list_first_entry(&expression
->u
.ctf_expression
.right
, struct ctf_node
, siblings
);
1061 assert(left
->u
.unary_expression
.type
== UNARY_STRING
);
1062 if (!strcmp(left
->u
.unary_expression
.u
.string
, "byte_order")) {
1063 byte_order
= get_byte_order(fd
, depth
, right
, trace
);
1066 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "exp_dig")) {
1067 if (right
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
1068 fprintf(fd
, "[error] %s: exp_dig: expecting unsigned constant\n",
1072 exp_dig
= right
->u
.unary_expression
.u
.unsigned_constant
;
1074 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "mant_dig")) {
1075 if (right
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
1076 fprintf(fd
, "[error] %s: mant_dig: expecting unsigned constant\n",
1080 mant_dig
= right
->u
.unary_expression
.u
.unsigned_constant
;
1082 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "align")) {
1083 if (right
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
1084 fprintf(fd
, "[error] %s: align: expecting unsigned constant\n",
1088 alignment
= right
->u
.unary_expression
.u
.unsigned_constant
;
1091 fprintf(fd
, "[error] %s: unknown attribute name %s\n",
1092 __func__
, left
->u
.unary_expression
.u
.string
);
1096 if (!has_mant_dig
) {
1097 fprintf(fd
, "[error] %s: missing mant_dig attribute\n", __func__
);
1101 fprintf(fd
, "[error] %s: missing exp_dig attribute\n", __func__
);
1104 if (!has_alignment
) {
1105 if ((mant_dig
+ exp_dig
) % CHAR_BIT
) {
1106 /* bit-packed alignment */
1109 /* byte-packed alignment */
1110 alignment
= CHAR_BIT
;
1113 float_declaration
= float_declaration_new(mant_dig
, exp_dig
,
1114 byte_order
, alignment
);
1115 return &float_declaration
->p
;
1119 struct declaration
*ctf_declaration_string_visit(FILE *fd
, int depth
,
1120 struct cds_list_head
*expressions
,
1121 struct ctf_trace
*trace
)
1123 struct ctf_node
*expression
;
1124 const char *encoding_c
= NULL
;
1125 enum ctf_string_encoding encoding
= CTF_STRING_UTF8
;
1126 struct declaration_string
*string_declaration
;
1128 cds_list_for_each_entry(expression
, expressions
, siblings
) {
1129 struct ctf_node
*left
, *right
;
1131 left
= _cds_list_first_entry(&expression
->u
.ctf_expression
.left
, struct ctf_node
, siblings
);
1132 right
= _cds_list_first_entry(&expression
->u
.ctf_expression
.right
, struct ctf_node
, siblings
);
1133 assert(left
->u
.unary_expression
.type
== UNARY_STRING
);
1134 if (!strcmp(left
->u
.unary_expression
.u
.string
, "encoding")) {
1135 if (right
->u
.unary_expression
.type
!= UNARY_STRING
) {
1136 fprintf(fd
, "[error] %s: encoding: expecting string\n",
1140 encoding_c
= right
->u
.unary_expression
.u
.string
;
1142 fprintf(fd
, "[error] %s: unknown attribute name %s\n",
1143 __func__
, left
->u
.unary_expression
.u
.string
);
1147 if (encoding_c
&& !strcmp(encoding_c
, "ASCII"))
1148 encoding
= CTF_STRING_ASCII
;
1149 string_declaration
= string_declaration_new(encoding
);
1150 return &string_declaration
->p
;
1155 struct declaration
*ctf_type_specifier_list_visit(FILE *fd
,
1156 int depth
, struct ctf_node
*type_specifier_list
,
1157 struct declaration_scope
*declaration_scope
,
1158 struct ctf_trace
*trace
)
1160 struct ctf_node
*first
;
1161 struct ctf_node
*node
;
1163 assert(type_specifier_list
->type
== NODE_TYPE_SPECIFIER_LIST
);
1165 first
= _cds_list_first_entry(&type_specifier_list
->u
.type_specifier_list
.head
, struct ctf_node
, siblings
);
1167 assert(first
->type
== NODE_TYPE_SPECIFIER
);
1169 node
= first
->u
.type_specifier
.node
;
1171 switch (first
->u
.type_specifier
.type
) {
1172 case TYPESPEC_FLOATING_POINT
:
1173 return ctf_declaration_floating_point_visit(fd
, depth
,
1174 &node
->u
.floating_point
.expressions
, trace
);
1175 case TYPESPEC_INTEGER
:
1176 return ctf_declaration_integer_visit(fd
, depth
,
1177 &node
->u
.integer
.expressions
, trace
);
1178 case TYPESPEC_STRING
:
1179 return ctf_declaration_string_visit(fd
, depth
,
1180 &first
->u
.string
.expressions
, trace
);
1181 case TYPESPEC_STRUCT
:
1182 return ctf_declaration_struct_visit(fd
, depth
,
1183 node
->u
._struct
.name
,
1184 &node
->u
._struct
.declaration_list
,
1185 node
->u
._struct
.has_body
,
1188 case TYPESPEC_VARIANT
:
1189 return ctf_declaration_variant_visit(fd
, depth
,
1190 node
->u
.variant
.name
,
1191 node
->u
.variant
.choice
,
1192 &node
->u
.variant
.declaration_list
,
1193 node
->u
.variant
.has_body
,
1197 return ctf_declaration_enum_visit(fd
, depth
,
1198 node
->u
._enum
.enum_id
,
1199 node
->u
._enum
.container_type
,
1200 &node
->u
._enum
.enumerator_list
,
1201 node
->u
._enum
.has_body
,
1207 case TYPESPEC_SHORT
:
1210 case TYPESPEC_FLOAT
:
1211 case TYPESPEC_DOUBLE
:
1212 case TYPESPEC_SIGNED
:
1213 case TYPESPEC_UNSIGNED
:
1215 case TYPESPEC_COMPLEX
:
1216 case TYPESPEC_IMAGINARY
:
1217 case TYPESPEC_CONST
:
1218 case TYPESPEC_ID_TYPE
:
1219 return ctf_declaration_type_specifier_visit(fd
, depth
,
1220 type_specifier_list
, declaration_scope
);
1222 fprintf(fd
, "[error] %s: unexpected node type %d\n", __func__
, (int) first
->u
.type_specifier
.type
);
1228 int ctf_event_declaration_visit(FILE *fd
, int depth
, struct ctf_node
*node
, struct ctf_event
*event
, struct ctf_trace
*trace
)
1232 switch (node
->type
) {
1234 ret
= ctf_typedef_visit(fd
, depth
+ 1,
1235 event
->declaration_scope
,
1236 node
->u
._typedef
.type_specifier_list
,
1237 &node
->u
._typedef
.type_declarators
,
1242 case NODE_TYPEALIAS
:
1243 ret
= ctf_typealias_visit(fd
, depth
+ 1,
1244 event
->declaration_scope
,
1245 node
->u
.typealias
.target
, node
->u
.typealias
.alias
,
1250 case NODE_CTF_EXPRESSION
:
1254 left
= concatenate_unary_strings(&node
->u
.ctf_expression
.left
);
1255 if (!strcmp(left
, "name")) {
1258 if (CTF_EVENT_FIELD_IS_SET(event
, name
)) {
1259 fprintf(fd
, "[error] %s: name already declared in event declaration\n", __func__
);
1262 right
= concatenate_unary_strings(&node
->u
.ctf_expression
.right
);
1264 fprintf(fd
, "[error] %s: unexpected unary expression for event name\n", __func__
);
1267 event
->name
= g_quark_from_string(right
);
1269 CTF_EVENT_SET_FIELD(event
, name
);
1270 } else if (!strcmp(left
, "id")) {
1271 if (CTF_EVENT_FIELD_IS_SET(event
, id
)) {
1272 fprintf(fd
, "[error] %s: id already declared in event declaration\n", __func__
);
1275 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &event
->id
);
1277 fprintf(fd
, "[error] %s: unexpected unary expression for event id\n", __func__
);
1280 CTF_EVENT_SET_FIELD(event
, id
);
1281 } else if (!strcmp(left
, "stream_id")) {
1282 if (CTF_EVENT_FIELD_IS_SET(event
, stream_id
)) {
1283 fprintf(fd
, "[error] %s: stream_id already declared in event declaration\n", __func__
);
1286 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &event
->stream_id
);
1288 fprintf(fd
, "[error] %s: unexpected unary expression for event stream_id\n", __func__
);
1291 event
->stream
= trace_stream_lookup(trace
, event
->stream_id
);
1292 if (!event
->stream
) {
1293 fprintf(fd
, "[error] %s: stream id %" PRIu64
" cannot be found\n", __func__
, event
->stream_id
);
1296 CTF_EVENT_SET_FIELD(event
, stream_id
);
1297 } else if (!strcmp(left
, "context")) {
1298 struct declaration
*declaration
;
1300 if (event
->context_decl
) {
1301 fprintf(fd
, "[error] %s: context already declared in event declaration\n", __func__
);
1304 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1305 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1306 struct ctf_node
, siblings
),
1307 event
->declaration_scope
, trace
);
1310 if (declaration
->id
!= CTF_TYPE_STRUCT
)
1312 event
->context_decl
= container_of(declaration
, struct declaration_struct
, p
);
1313 } else if (!strcmp(left
, "fields")) {
1314 struct declaration
*declaration
;
1316 if (event
->fields_decl
) {
1317 fprintf(fd
, "[error] %s: fields already declared in event declaration\n", __func__
);
1320 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1321 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1322 struct ctf_node
, siblings
),
1323 event
->declaration_scope
, trace
);
1326 if (declaration
->id
!= CTF_TYPE_STRUCT
)
1328 event
->fields_decl
= container_of(declaration
, struct declaration_struct
, p
);
1335 /* TODO: declaration specifier should be added. */
1342 int ctf_event_visit(FILE *fd
, int depth
, struct ctf_node
*node
,
1343 struct declaration_scope
*parent_declaration_scope
, struct ctf_trace
*trace
)
1346 struct ctf_node
*iter
;
1347 struct ctf_event
*event
;
1348 struct definition_scope
*parent_def_scope
;
1350 event
= g_new0(struct ctf_event
, 1);
1351 event
->declaration_scope
= new_declaration_scope(parent_declaration_scope
);
1352 cds_list_for_each_entry(iter
, &node
->u
.event
.declaration_list
, siblings
) {
1353 ret
= ctf_event_declaration_visit(fd
, depth
+ 1, iter
, event
, trace
);
1357 if (!CTF_EVENT_FIELD_IS_SET(event
, name
)) {
1359 fprintf(fd
, "[error] %s: missing name field in event declaration\n", __func__
);
1362 if (!CTF_EVENT_FIELD_IS_SET(event
, id
)) {
1364 fprintf(fd
, "[error] %s: missing id field in event declaration\n", __func__
);
1367 if (!CTF_EVENT_FIELD_IS_SET(event
, stream_id
)) {
1369 fprintf(fd
, "[error] %s: missing stream_id field in event declaration\n", __func__
);
1372 if (event
->stream
->events_by_id
->len
<= event
->id
)
1373 g_ptr_array_set_size(event
->stream
->events_by_id
, event
->id
+ 1);
1374 g_ptr_array_index(event
->stream
->events_by_id
, event
->id
) = event
;
1375 g_hash_table_insert(event
->stream
->event_quark_to_id
,
1376 (gpointer
)(unsigned long) event
->name
,
1378 parent_def_scope
= event
->stream
->definition_scope
;
1379 if (event
->context_decl
) {
1382 event
->context_decl
->p
.definition_new(&event
->context_decl
->p
,
1383 parent_def_scope
, 0, 0),
1384 struct definition_struct
, p
);
1385 set_dynamic_definition_scope(&event
->context
->p
,
1386 event
->context
->scope
,
1388 parent_def_scope
= event
->context
->scope
;
1389 declaration_unref(&event
->context_decl
->p
);
1391 if (event
->fields_decl
) {
1394 event
->fields_decl
->p
.definition_new(&event
->fields_decl
->p
,
1395 parent_def_scope
, 0, 0),
1396 struct definition_struct
, p
);
1397 set_dynamic_definition_scope(&event
->fields
->p
,
1398 event
->fields
->scope
,
1400 parent_def_scope
= event
->fields
->scope
;
1401 declaration_unref(&event
->fields_decl
->p
);
1406 declaration_unref(&event
->fields_decl
->p
);
1407 declaration_unref(&event
->context_decl
->p
);
1408 free_declaration_scope(event
->declaration_scope
);
1415 int ctf_stream_declaration_visit(FILE *fd
, int depth
, struct ctf_node
*node
, struct ctf_stream
*stream
, struct ctf_trace
*trace
)
1419 switch (node
->type
) {
1421 ret
= ctf_typedef_visit(fd
, depth
+ 1,
1422 stream
->declaration_scope
,
1423 node
->u
._typedef
.type_specifier_list
,
1424 &node
->u
._typedef
.type_declarators
,
1429 case NODE_TYPEALIAS
:
1430 ret
= ctf_typealias_visit(fd
, depth
+ 1,
1431 stream
->declaration_scope
,
1432 node
->u
.typealias
.target
, node
->u
.typealias
.alias
,
1437 case NODE_CTF_EXPRESSION
:
1441 left
= concatenate_unary_strings(&node
->u
.ctf_expression
.left
);
1442 if (!strcmp(left
, "id")) {
1443 if (CTF_STREAM_FIELD_IS_SET(stream
, stream_id
)) {
1444 fprintf(fd
, "[error] %s: id already declared in stream declaration\n", __func__
);
1447 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &stream
->stream_id
);
1449 fprintf(fd
, "[error] %s: unexpected unary expression for stream id\n", __func__
);
1452 CTF_STREAM_SET_FIELD(stream
, stream_id
);
1453 } else if (!strcmp(left
, "event.header")) {
1454 struct declaration
*declaration
;
1456 if (stream
->event_header_decl
) {
1457 fprintf(fd
, "[error] %s: event.header already declared in stream declaration\n", __func__
);
1460 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1461 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1462 struct ctf_node
, siblings
),
1463 stream
->declaration_scope
, trace
);
1466 if (declaration
->id
!= CTF_TYPE_STRUCT
)
1468 stream
->event_header_decl
= container_of(declaration
, struct declaration_struct
, p
);
1469 } else if (!strcmp(left
, "event.context")) {
1470 struct declaration
*declaration
;
1472 if (stream
->event_context_decl
) {
1473 fprintf(fd
, "[error] %s: event.context already declared in stream declaration\n", __func__
);
1476 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1477 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1478 struct ctf_node
, siblings
),
1479 stream
->declaration_scope
, trace
);
1482 if (declaration
->id
!= CTF_TYPE_STRUCT
)
1484 stream
->event_context_decl
= container_of(declaration
, struct declaration_struct
, p
);
1485 } else if (!strcmp(left
, "packet.context")) {
1486 struct declaration
*declaration
;
1488 if (stream
->packet_context_decl
) {
1489 fprintf(fd
, "[error] %s: packet.context already declared in stream declaration\n", __func__
);
1492 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1493 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1494 struct ctf_node
, siblings
),
1495 stream
->declaration_scope
, trace
);
1498 if (declaration
->id
!= CTF_TYPE_STRUCT
)
1500 stream
->packet_context_decl
= container_of(declaration
, struct declaration_struct
, p
);
1507 /* TODO: declaration specifier should be added. */
1514 int ctf_stream_visit(FILE *fd
, int depth
, struct ctf_node
*node
,
1515 struct declaration_scope
*parent_declaration_scope
, struct ctf_trace
*trace
)
1518 struct ctf_node
*iter
;
1519 struct ctf_stream
*stream
;
1520 struct definition_scope
*parent_def_scope
;
1522 stream
= g_new0(struct ctf_stream
, 1);
1523 stream
->declaration_scope
= new_declaration_scope(parent_declaration_scope
);
1524 stream
->events_by_id
= g_ptr_array_new();
1525 stream
->event_quark_to_id
= g_hash_table_new(g_int_hash
, g_int_equal
);
1526 cds_list_for_each_entry(iter
, &node
->u
.stream
.declaration_list
, siblings
) {
1527 ret
= ctf_stream_declaration_visit(fd
, depth
+ 1, iter
, stream
, trace
);
1531 if (!CTF_STREAM_FIELD_IS_SET(stream
, stream_id
)) {
1533 fprintf(fd
, "[error] %s: missing id field in stream declaration\n", __func__
);
1536 if (trace
->streams
->len
<= stream
->stream_id
)
1537 g_ptr_array_set_size(trace
->streams
, stream
->stream_id
+ 1);
1538 g_ptr_array_index(trace
->streams
, stream
->stream_id
) = stream
;
1540 parent_def_scope
= NULL
;
1541 if (stream
->packet_context_decl
) {
1542 stream
->packet_context
=
1544 stream
->packet_context_decl
->p
.definition_new(&stream
->packet_context_decl
->p
,
1545 parent_def_scope
, 0, 0),
1546 struct definition_struct
, p
);
1547 set_dynamic_definition_scope(&stream
->packet_context
->p
,
1548 stream
->packet_context
->scope
,
1549 "stream.packet.context");
1550 parent_def_scope
= stream
->packet_context
->scope
;
1551 declaration_unref(&stream
->packet_context_decl
->p
);
1553 if (stream
->event_header_decl
) {
1554 stream
->event_header
=
1556 stream
->event_header_decl
->p
.definition_new(&stream
->event_header_decl
->p
,
1557 parent_def_scope
, 0, 0),
1558 struct definition_struct
, p
);
1559 set_dynamic_definition_scope(&stream
->event_header
->p
,
1560 stream
->event_header
->scope
,
1561 "stream.event.header");
1562 parent_def_scope
= stream
->event_header
->scope
;
1563 declaration_unref(&stream
->event_header_decl
->p
);
1565 if (stream
->event_context_decl
) {
1566 stream
->event_context
=
1568 stream
->event_context_decl
->p
.definition_new(&stream
->event_context_decl
->p
,
1569 parent_def_scope
, 0, 0),
1570 struct definition_struct
, p
);
1571 set_dynamic_definition_scope(&stream
->event_context
->p
,
1572 stream
->event_context
->scope
,
1573 "stream.event.context");
1574 parent_def_scope
= stream
->event_context
->scope
;
1575 declaration_unref(&stream
->event_context_decl
->p
);
1577 stream
->definition_scope
= parent_def_scope
;
1582 declaration_unref(&stream
->event_header_decl
->p
);
1583 declaration_unref(&stream
->event_context_decl
->p
);
1584 declaration_unref(&stream
->packet_context_decl
->p
);
1585 g_ptr_array_free(stream
->events_by_id
, TRUE
);
1586 g_hash_table_destroy(stream
->event_quark_to_id
);
1587 free_declaration_scope(stream
->declaration_scope
);
1593 int ctf_trace_declaration_visit(FILE *fd
, int depth
, struct ctf_node
*node
, struct ctf_trace
*trace
)
1597 switch (node
->type
) {
1599 ret
= ctf_typedef_visit(fd
, depth
+ 1,
1600 trace
->declaration_scope
,
1601 node
->u
._typedef
.type_specifier_list
,
1602 &node
->u
._typedef
.type_declarators
,
1607 case NODE_TYPEALIAS
:
1608 ret
= ctf_typealias_visit(fd
, depth
+ 1,
1609 trace
->declaration_scope
,
1610 node
->u
.typealias
.target
, node
->u
.typealias
.alias
,
1615 case NODE_CTF_EXPRESSION
:
1619 left
= concatenate_unary_strings(&node
->u
.ctf_expression
.left
);
1620 if (!strcmp(left
, "major")) {
1621 if (CTF_TRACE_FIELD_IS_SET(trace
, major
)) {
1622 fprintf(fd
, "[error] %s: major already declared in trace declaration\n", __func__
);
1625 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &trace
->major
);
1627 fprintf(fd
, "[error] %s: unexpected unary expression for trace major number\n", __func__
);
1630 CTF_TRACE_SET_FIELD(trace
, major
);
1631 } else if (!strcmp(left
, "minor")) {
1632 if (CTF_TRACE_FIELD_IS_SET(trace
, minor
)) {
1633 fprintf(fd
, "[error] %s: minor already declared in trace declaration\n", __func__
);
1636 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &trace
->minor
);
1638 fprintf(fd
, "[error] %s: unexpected unary expression for trace minor number\n", __func__
);
1641 CTF_TRACE_SET_FIELD(trace
, minor
);
1642 } else if (!strcmp(left
, "word_size")) {
1643 if (CTF_TRACE_FIELD_IS_SET(trace
, word_size
)) {
1644 fprintf(fd
, "[error] %s: word_size already declared in trace declaration\n", __func__
);
1647 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &trace
->word_size
);
1649 fprintf(fd
, "[error] %s: unexpected unary expression for trace word_size\n", __func__
);
1652 CTF_TRACE_SET_FIELD(trace
, word_size
);
1653 } else if (!strcmp(left
, "uuid")) {
1654 if (CTF_TRACE_FIELD_IS_SET(trace
, uuid
)) {
1655 fprintf(fd
, "[error] %s: uuid already declared in trace declaration\n", __func__
);
1658 ret
= get_unary_uuid(&node
->u
.ctf_expression
.right
, &trace
->uuid
);
1660 fprintf(fd
, "[error] %s: unexpected unary expression for trace uuid\n", __func__
);
1663 CTF_TRACE_SET_FIELD(trace
, uuid
);
1670 /* TODO: declaration specifier should be added. */
1677 int ctf_trace_visit(FILE *fd
, int depth
, struct ctf_node
*node
, struct ctf_trace
*trace
)
1680 struct ctf_node
*iter
;
1682 if (trace
->declaration_scope
)
1684 trace
->declaration_scope
= new_declaration_scope(trace
->root_declaration_scope
);
1685 trace
->streams
= g_ptr_array_new();
1686 cds_list_for_each_entry(iter
, &node
->u
.trace
.declaration_list
, siblings
) {
1687 ret
= ctf_trace_declaration_visit(fd
, depth
+ 1, iter
, trace
);
1691 if (!CTF_TRACE_FIELD_IS_SET(trace
, major
)) {
1693 fprintf(fd
, "[error] %s: missing major field in trace declaration\n", __func__
);
1696 if (!CTF_TRACE_FIELD_IS_SET(trace
, minor
)) {
1698 fprintf(fd
, "[error] %s: missing minor field in trace declaration\n", __func__
);
1701 if (!CTF_TRACE_FIELD_IS_SET(trace
, uuid
)) {
1703 fprintf(fd
, "[error] %s: missing uuid field in trace declaration\n", __func__
);
1706 if (!CTF_TRACE_FIELD_IS_SET(trace
, word_size
)) {
1708 fprintf(fd
, "[error] %s: missing word_size field in trace declaration\n", __func__
);
1714 g_ptr_array_free(trace
->streams
, TRUE
);
1715 free_declaration_scope(trace
->declaration_scope
);
1720 int ctf_root_declaration_visit(FILE *fd
, int depth
, struct ctf_node
*node
, struct ctf_trace
*trace
)
1724 switch (node
->type
) {
1726 ret
= ctf_typedef_visit(fd
, depth
+ 1,
1727 trace
->root_declaration_scope
,
1728 node
->u
._typedef
.type_specifier_list
,
1729 &node
->u
._typedef
.type_declarators
,
1734 case NODE_TYPEALIAS
:
1735 ret
= ctf_typealias_visit(fd
, depth
+ 1,
1736 trace
->root_declaration_scope
,
1737 node
->u
.typealias
.target
, node
->u
.typealias
.alias
,
1742 case NODE_TYPE_SPECIFIER_LIST
:
1744 struct declaration
*declaration
;
1747 * Just add the type specifier to the root scope
1748 * declaration scope. Release local reference.
1750 declaration
= ctf_type_specifier_list_visit(fd
, depth
+ 1,
1751 node
, trace
->root_declaration_scope
, trace
);
1754 declaration_unref(declaration
);
1764 int ctf_visitor_construct_metadata(FILE *fd
, int depth
, struct ctf_node
*node
,
1765 struct ctf_trace
*trace
, int byte_order
)
1768 struct ctf_node
*iter
;
1770 fprintf(fd
, "CTF visitor: metadata construction... ");
1771 trace
->root_declaration_scope
= new_declaration_scope(NULL
);
1772 trace
->byte_order
= byte_order
;
1774 switch (node
->type
) {
1776 cds_list_for_each_entry(iter
, &node
->u
.root
.declaration_list
,
1778 ret
= ctf_root_declaration_visit(fd
, depth
+ 1, iter
, trace
);
1780 fprintf(fd
, "[error] %s: root declaration error\n", __func__
);
1784 cds_list_for_each_entry(iter
, &node
->u
.root
.trace
, siblings
) {
1785 ret
= ctf_trace_visit(fd
, depth
+ 1, iter
, trace
);
1787 fprintf(fd
, "[error] %s: trace declaration error\n", __func__
);
1791 cds_list_for_each_entry(iter
, &node
->u
.root
.stream
, siblings
) {
1792 ret
= ctf_stream_visit(fd
, depth
+ 1, iter
,
1793 trace
->root_declaration_scope
, trace
);
1795 fprintf(fd
, "[error] %s: stream declaration error\n", __func__
);
1799 cds_list_for_each_entry(iter
, &node
->u
.root
.event
, siblings
) {
1800 ret
= ctf_event_visit(fd
, depth
+ 1, iter
,
1801 trace
->root_declaration_scope
, trace
);
1803 fprintf(fd
, "[error] %s: event declaration error\n", __func__
);
1810 fprintf(fd
, "[error] %s: unknown node type %d\n", __func__
,
1814 fprintf(fd
, "done.\n");