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
;
354 case NODE_TYPE_SPECIFIER_LIST
:
356 struct declaration_sequence
*sequence_declaration
;
357 struct declaration_integer
*integer_declaration
;
359 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
360 length
, declaration_scope
, trace
);
362 fprintf(fd
, "[error] %s: unable to find declaration type for sequence length\n", __func__
);
365 if (declaration
->id
!= CTF_TYPE_INTEGER
) {
366 fprintf(fd
, "[error] %s: length type for sequence is expected to be an integer (unsigned).\n", __func__
);
367 declaration_unref(declaration
);
370 integer_declaration
= container_of(declaration
, struct declaration_integer
, p
);
371 if (integer_declaration
->signedness
!= false) {
372 fprintf(fd
, "[error] %s: length type for sequence should always be an unsigned integer.\n", __func__
);
373 declaration_unref(declaration
);
377 sequence_declaration
= sequence_declaration_new(integer_declaration
,
378 nested_declaration
, declaration_scope
);
379 declaration
= &sequence_declaration
->p
;
386 /* Pass it as content of outer container */
387 declaration
= ctf_type_declarator_visit(fd
, depth
,
388 type_specifier_list
, field_name
,
389 node_type_declarator
->u
.type_declarator
.u
.nested
.type_declarator
,
390 declaration_scope
, declaration
, trace
);
396 int ctf_struct_type_declarators_visit(FILE *fd
, int depth
,
397 struct declaration_struct
*struct_declaration
,
398 struct ctf_node
*type_specifier_list
,
399 struct cds_list_head
*type_declarators
,
400 struct declaration_scope
*declaration_scope
,
401 struct ctf_trace
*trace
)
403 struct ctf_node
*iter
;
406 cds_list_for_each_entry(iter
, type_declarators
, siblings
) {
407 struct declaration
*field_declaration
;
409 field_declaration
= ctf_type_declarator_visit(fd
, depth
,
412 struct_declaration
->scope
,
414 if (!field_declaration
) {
415 fprintf(fd
, "[error] %s: unable to find struct field declaration type\n", __func__
);
418 struct_declaration_add_field(struct_declaration
,
419 g_quark_to_string(field_name
),
426 int ctf_variant_type_declarators_visit(FILE *fd
, int depth
,
427 struct declaration_untagged_variant
*untagged_variant_declaration
,
428 struct ctf_node
*type_specifier_list
,
429 struct cds_list_head
*type_declarators
,
430 struct declaration_scope
*declaration_scope
,
431 struct ctf_trace
*trace
)
433 struct ctf_node
*iter
;
436 cds_list_for_each_entry(iter
, type_declarators
, siblings
) {
437 struct declaration
*field_declaration
;
439 field_declaration
= ctf_type_declarator_visit(fd
, depth
,
442 untagged_variant_declaration
->scope
,
444 if (!field_declaration
) {
445 fprintf(fd
, "[error] %s: unable to find variant field declaration type\n", __func__
);
448 untagged_variant_declaration_add_field(untagged_variant_declaration
,
449 g_quark_to_string(field_name
),
456 int ctf_typedef_visit(FILE *fd
, int depth
, struct declaration_scope
*scope
,
457 struct ctf_node
*type_specifier_list
,
458 struct cds_list_head
*type_declarators
,
459 struct ctf_trace
*trace
)
461 struct ctf_node
*iter
;
464 cds_list_for_each_entry(iter
, type_declarators
, siblings
) {
465 struct declaration
*type_declaration
;
468 type_declaration
= ctf_type_declarator_visit(fd
, depth
,
472 if (!type_declaration
) {
473 fprintf(fd
, "[error] %s: problem creating type declaration\n", __func__
);
477 * Don't allow typedef and typealias of untagged
480 if (type_declaration
->id
== CTF_TYPE_UNTAGGED_VARIANT
) {
481 fprintf(fd
, "[error] %s: typedef of untagged variant is not permitted.\n", __func__
);
482 declaration_unref(type_declaration
);
485 ret
= register_declaration(identifier
, type_declaration
, scope
);
487 type_declaration
->declaration_free(type_declaration
);
495 int ctf_typealias_visit(FILE *fd
, int depth
, struct declaration_scope
*scope
,
496 struct ctf_node
*target
, struct ctf_node
*alias
,
497 struct ctf_trace
*trace
)
499 struct declaration
*type_declaration
;
500 struct ctf_node
*node
;
505 /* See ctf_visitor_type_declarator() in the semantic validator. */
508 * Create target type declaration.
511 if (cds_list_empty(&target
->u
.typealias_target
.type_declarators
))
514 node
= _cds_list_first_entry(&target
->u
.typealias_target
.type_declarators
,
515 struct ctf_node
, siblings
);
516 type_declaration
= ctf_type_declarator_visit(fd
, depth
,
517 target
->u
.typealias_target
.type_specifier_list
,
520 if (!type_declaration
) {
521 fprintf(fd
, "[error] %s: problem creating type declaration\n", __func__
);
526 * Don't allow typedef and typealias of untagged
529 if (type_declaration
->id
== CTF_TYPE_UNTAGGED_VARIANT
) {
530 fprintf(fd
, "[error] %s: typedef of untagged variant is not permitted.\n", __func__
);
531 declaration_unref(type_declaration
);
535 * The semantic validator does not check whether the target is
536 * abstract or not (if it has an identifier). Check it here.
539 fprintf(fd
, "[error] %s: expecting empty identifier\n", __func__
);
544 * Create alias identifier.
547 node
= _cds_list_first_entry(&alias
->u
.typealias_alias
.type_declarators
,
548 struct ctf_node
, siblings
);
549 alias_q
= create_typealias_identifier(fd
, depth
,
550 alias
->u
.typealias_alias
.type_specifier_list
, node
);
551 err
= register_declaration(alias_q
, type_declaration
, scope
);
557 type_declaration
->declaration_free(type_declaration
);
562 int ctf_struct_declaration_list_visit(FILE *fd
, int depth
,
563 struct ctf_node
*iter
, struct declaration_struct
*struct_declaration
,
564 struct ctf_trace
*trace
)
568 switch (iter
->type
) {
570 /* For each declarator, declare type and add type to struct declaration scope */
571 ret
= ctf_typedef_visit(fd
, depth
,
572 struct_declaration
->scope
,
573 iter
->u
._typedef
.type_specifier_list
,
574 &iter
->u
._typedef
.type_declarators
, trace
);
579 /* Declare type with declarator and add type to struct declaration scope */
580 ret
= ctf_typealias_visit(fd
, depth
,
581 struct_declaration
->scope
,
582 iter
->u
.typealias
.target
,
583 iter
->u
.typealias
.alias
, trace
);
587 case NODE_STRUCT_OR_VARIANT_DECLARATION
:
588 /* Add field to structure declaration */
589 ret
= ctf_struct_type_declarators_visit(fd
, depth
,
591 iter
->u
.struct_or_variant_declaration
.type_specifier_list
,
592 &iter
->u
.struct_or_variant_declaration
.type_declarators
,
593 struct_declaration
->scope
, trace
);
598 fprintf(fd
, "[error] %s: unexpected node type %d\n", __func__
, (int) iter
->type
);
605 int ctf_variant_declaration_list_visit(FILE *fd
, int depth
,
606 struct ctf_node
*iter
,
607 struct declaration_untagged_variant
*untagged_variant_declaration
,
608 struct ctf_trace
*trace
)
612 switch (iter
->type
) {
614 /* For each declarator, declare type and add type to variant declaration scope */
615 ret
= ctf_typedef_visit(fd
, depth
,
616 untagged_variant_declaration
->scope
,
617 iter
->u
._typedef
.type_specifier_list
,
618 &iter
->u
._typedef
.type_declarators
, trace
);
623 /* Declare type with declarator and add type to variant declaration scope */
624 ret
= ctf_typealias_visit(fd
, depth
,
625 untagged_variant_declaration
->scope
,
626 iter
->u
.typealias
.target
,
627 iter
->u
.typealias
.alias
, trace
);
631 case NODE_STRUCT_OR_VARIANT_DECLARATION
:
632 /* Add field to structure declaration */
633 ret
= ctf_variant_type_declarators_visit(fd
, depth
,
634 untagged_variant_declaration
,
635 iter
->u
.struct_or_variant_declaration
.type_specifier_list
,
636 &iter
->u
.struct_or_variant_declaration
.type_declarators
,
637 untagged_variant_declaration
->scope
, trace
);
642 fprintf(fd
, "[error] %s: unexpected node type %d\n", __func__
, (int) iter
->type
);
649 struct declaration
*ctf_declaration_struct_visit(FILE *fd
,
650 int depth
, const char *name
, struct cds_list_head
*declaration_list
,
651 int has_body
, struct declaration_scope
*declaration_scope
,
652 struct ctf_trace
*trace
)
654 struct declaration_struct
*struct_declaration
;
655 struct ctf_node
*iter
;
659 * For named struct (without body), lookup in
660 * declaration scope. Don't take reference on struct
661 * declaration: ref is only taken upon definition.
666 lookup_struct_declaration(g_quark_from_string(name
),
668 return &struct_declaration
->p
;
670 /* For unnamed struct, create type */
671 /* For named struct (with body), create type and add to declaration scope */
673 if (lookup_struct_declaration(g_quark_from_string(name
),
674 declaration_scope
)) {
676 fprintf(fd
, "[error] %s: struct %s already declared in scope\n", __func__
, name
);
680 struct_declaration
= struct_declaration_new(declaration_scope
);
681 cds_list_for_each_entry(iter
, declaration_list
, siblings
) {
682 ret
= ctf_struct_declaration_list_visit(fd
, depth
+ 1, iter
,
683 struct_declaration
, trace
);
688 ret
= register_struct_declaration(g_quark_from_string(name
),
693 return &struct_declaration
->p
;
696 struct_declaration
->p
.declaration_free(&struct_declaration
->p
);
701 struct declaration
*ctf_declaration_variant_visit(FILE *fd
,
702 int depth
, const char *name
, const char *choice
,
703 struct cds_list_head
*declaration_list
,
704 int has_body
, struct declaration_scope
*declaration_scope
,
705 struct ctf_trace
*trace
)
707 struct declaration_untagged_variant
*untagged_variant_declaration
;
708 struct declaration_variant
*variant_declaration
;
709 struct ctf_node
*iter
;
713 * For named variant (without body), lookup in
714 * declaration scope. Don't take reference on variant
715 * declaration: ref is only taken upon definition.
719 untagged_variant_declaration
=
720 lookup_variant_declaration(g_quark_from_string(name
),
723 /* For unnamed variant, create type */
724 /* For named variant (with body), create type and add to declaration scope */
726 if (lookup_variant_declaration(g_quark_from_string(name
),
727 declaration_scope
)) {
729 fprintf(fd
, "[error] %s: variant %s already declared in scope\n", __func__
, name
);
733 untagged_variant_declaration
= untagged_variant_declaration_new(declaration_scope
);
734 cds_list_for_each_entry(iter
, declaration_list
, siblings
) {
735 ret
= ctf_variant_declaration_list_visit(fd
, depth
+ 1, iter
,
736 untagged_variant_declaration
, trace
);
741 ret
= register_variant_declaration(g_quark_from_string(name
),
742 untagged_variant_declaration
,
748 * if tagged, create tagged variant and return. else return
752 return &untagged_variant_declaration
->p
;
754 variant_declaration
= variant_declaration_new(untagged_variant_declaration
, choice
);
755 if (!variant_declaration
)
757 declaration_unref(&untagged_variant_declaration
->p
);
758 return &variant_declaration
->p
;
761 untagged_variant_declaration
->p
.declaration_free(&untagged_variant_declaration
->p
);
766 int ctf_enumerator_list_visit(FILE *fd
, int depth
,
767 struct ctf_node
*enumerator
,
768 struct declaration_enum
*enum_declaration
)
771 struct ctf_node
*iter
;
773 q
= g_quark_from_string(enumerator
->u
.enumerator
.id
);
774 if (enum_declaration
->integer_declaration
->signedness
) {
778 cds_list_for_each_entry(iter
, &enumerator
->u
.enumerator
.values
, siblings
) {
781 assert(iter
->type
== NODE_UNARY_EXPRESSION
);
787 switch (iter
->u
.unary_expression
.type
) {
788 case UNARY_SIGNED_CONSTANT
:
789 *target
= iter
->u
.unary_expression
.u
.signed_constant
;
791 case UNARY_UNSIGNED_CONSTANT
:
792 *target
= iter
->u
.unary_expression
.u
.unsigned_constant
;
795 fprintf(fd
, "[error] %s: invalid enumerator\n", __func__
);
799 fprintf(fd
, "[error] %s: invalid enumerator\n", __func__
);
806 enum_signed_insert(enum_declaration
, start
, end
, q
);
811 cds_list_for_each_entry(iter
, &enumerator
->u
.enumerator
.values
, siblings
) {
814 assert(iter
->type
== NODE_UNARY_EXPRESSION
);
820 switch (iter
->u
.unary_expression
.type
) {
821 case UNARY_UNSIGNED_CONSTANT
:
822 *target
= iter
->u
.unary_expression
.u
.unsigned_constant
;
824 case UNARY_SIGNED_CONSTANT
:
826 * We don't accept signed constants for enums with unsigned
829 fprintf(fd
, "[error] %s: invalid enumerator (signed constant encountered, but enum container type is unsigned)\n", __func__
);
832 fprintf(fd
, "[error] %s: invalid enumerator\n", __func__
);
836 fprintf(fd
, "[error] %s: invalid enumerator\n", __func__
);
843 enum_unsigned_insert(enum_declaration
, start
, end
, q
);
849 struct declaration
*ctf_declaration_enum_visit(FILE *fd
, int depth
,
851 struct ctf_node
*container_type
,
852 struct cds_list_head
*enumerator_list
,
854 struct declaration_scope
*declaration_scope
,
855 struct ctf_trace
*trace
)
857 struct declaration
*declaration
;
858 struct declaration_enum
*enum_declaration
;
859 struct declaration_integer
*integer_declaration
;
860 struct ctf_node
*iter
;
865 * For named enum (without body), lookup in
866 * declaration scope. Don't take reference on enum
867 * declaration: ref is only taken upon definition.
872 lookup_enum_declaration(g_quark_from_string(name
),
874 return &enum_declaration
->p
;
876 /* For unnamed enum, create type */
877 /* For named enum (with body), create type and add to declaration scope */
879 if (lookup_enum_declaration(g_quark_from_string(name
),
880 declaration_scope
)) {
882 fprintf(fd
, "[error] %s: enum %s already declared in scope\n", __func__
, name
);
886 if (!container_type
) {
887 declaration
= lookup_declaration(g_quark_from_static_string("int"),
890 fprintf(fd
, "[error] %s: \"int\" type declaration missing for enumeration\n", __func__
);
894 declaration
= ctf_type_declarator_visit(fd
, depth
,
901 fprintf(fd
, "[error] %s: unable to create container type for enumeration\n", __func__
);
904 if (declaration
->id
!= CTF_TYPE_INTEGER
) {
905 fprintf(fd
, "[error] %s: container type for enumeration is not integer\n", __func__
);
908 integer_declaration
= container_of(declaration
, struct declaration_integer
, p
);
909 enum_declaration
= enum_declaration_new(integer_declaration
);
910 declaration_unref(&integer_declaration
->p
); /* leave ref to enum */
911 cds_list_for_each_entry(iter
, enumerator_list
, siblings
) {
912 ret
= ctf_enumerator_list_visit(fd
, depth
+ 1, iter
, enum_declaration
);
917 ret
= register_enum_declaration(g_quark_from_string(name
),
922 return &enum_declaration
->p
;
925 enum_declaration
->p
.declaration_free(&enum_declaration
->p
);
930 struct declaration
*ctf_declaration_type_specifier_visit(FILE *fd
, int depth
,
931 struct ctf_node
*type_specifier_list
,
932 struct declaration_scope
*declaration_scope
)
935 struct declaration
*declaration
;
940 str
= g_string_new("");
941 ret
= visit_type_specifier_list(fd
, type_specifier_list
, str
);
944 str_c
= g_string_free(str
, FALSE
);
945 id_q
= g_quark_from_string(str_c
);
947 declaration
= lookup_declaration(id_q
, declaration_scope
);
952 * Returns 0/1 boolean, or < 0 on error.
955 int get_boolean(FILE *fd
, int depth
, struct ctf_node
*unary_expression
)
957 if (unary_expression
->type
!= NODE_UNARY_EXPRESSION
) {
958 fprintf(fd
, "[error] %s: expecting unary expression\n",
962 switch (unary_expression
->u
.unary_expression
.type
) {
963 case UNARY_UNSIGNED_CONSTANT
:
964 if (unary_expression
->u
.unary_expression
.u
.unsigned_constant
== 0)
968 case UNARY_SIGNED_CONSTANT
:
969 if (unary_expression
->u
.unary_expression
.u
.signed_constant
== 0)
974 if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "true"))
976 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "TRUE"))
978 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "false"))
980 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "FALSE"))
983 fprintf(fd
, "[error] %s: unexpected string \"%s\"\n",
984 __func__
, unary_expression
->u
.unary_expression
.u
.string
);
989 fprintf(fd
, "[error] %s: unexpected unary expression type\n",
997 int get_trace_byte_order(FILE *fd
, int depth
, struct ctf_node
*unary_expression
)
1001 if (unary_expression
->u
.unary_expression
.type
!= UNARY_STRING
) {
1002 fprintf(fd
, "[error] %s: byte_order: expecting string\n",
1006 if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "be"))
1007 byte_order
= BIG_ENDIAN
;
1008 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "le"))
1009 byte_order
= LITTLE_ENDIAN
;
1011 fprintf(fd
, "[error] %s: unexpected string \"%s\". Should be \"native\", \"network\", \"be\" or \"le\".\n",
1012 __func__
, unary_expression
->u
.unary_expression
.u
.string
);
1019 int get_byte_order(FILE *fd
, int depth
, struct ctf_node
*unary_expression
,
1020 struct ctf_trace
*trace
)
1024 if (unary_expression
->u
.unary_expression
.type
!= UNARY_STRING
) {
1025 fprintf(fd
, "[error] %s: byte_order: expecting string\n",
1029 if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "native"))
1030 byte_order
= trace
->byte_order
;
1031 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "network"))
1032 byte_order
= BIG_ENDIAN
;
1033 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "be"))
1034 byte_order
= BIG_ENDIAN
;
1035 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "le"))
1036 byte_order
= LITTLE_ENDIAN
;
1038 fprintf(fd
, "[error] %s: unexpected string \"%s\". Should be \"native\", \"network\", \"be\" or \"le\".\n",
1039 __func__
, unary_expression
->u
.unary_expression
.u
.string
);
1046 struct declaration
*ctf_declaration_integer_visit(FILE *fd
, int depth
,
1047 struct cds_list_head
*expressions
,
1048 struct ctf_trace
*trace
)
1050 struct ctf_node
*expression
;
1051 uint64_t alignment
, size
;
1052 int byte_order
= trace
->byte_order
;
1054 int has_alignment
= 0, has_size
= 0;
1055 struct declaration_integer
*integer_declaration
;
1057 cds_list_for_each_entry(expression
, expressions
, siblings
) {
1058 struct ctf_node
*left
, *right
;
1060 left
= _cds_list_first_entry(&expression
->u
.ctf_expression
.left
, struct ctf_node
, siblings
);
1061 right
= _cds_list_first_entry(&expression
->u
.ctf_expression
.right
, struct ctf_node
, siblings
);
1062 assert(left
->u
.unary_expression
.type
== UNARY_STRING
);
1063 if (!strcmp(left
->u
.unary_expression
.u
.string
, "signed")) {
1064 signedness
= get_boolean(fd
, depth
, right
);
1067 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "byte_order")) {
1068 byte_order
= get_byte_order(fd
, depth
, right
, trace
);
1071 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "size")) {
1072 if (right
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
1073 fprintf(fd
, "[error] %s: size: expecting unsigned constant\n",
1077 size
= right
->u
.unary_expression
.u
.unsigned_constant
;
1079 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "align")) {
1080 if (right
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
1081 fprintf(fd
, "[error] %s: align: expecting unsigned constant\n",
1085 alignment
= right
->u
.unary_expression
.u
.unsigned_constant
;
1088 fprintf(fd
, "[error] %s: unknown attribute name %s\n",
1089 __func__
, left
->u
.unary_expression
.u
.string
);
1094 fprintf(fd
, "[error] %s: missing size attribute\n", __func__
);
1097 if (!has_alignment
) {
1098 if (size
% CHAR_BIT
) {
1099 /* bit-packed alignment */
1102 /* byte-packed alignment */
1103 alignment
= CHAR_BIT
;
1106 integer_declaration
= integer_declaration_new(size
,
1107 byte_order
, signedness
, alignment
);
1108 return &integer_declaration
->p
;
1112 struct declaration
*ctf_declaration_floating_point_visit(FILE *fd
, int depth
,
1113 struct cds_list_head
*expressions
,
1114 struct ctf_trace
*trace
)
1116 struct ctf_node
*expression
;
1117 uint64_t alignment
, exp_dig
, mant_dig
, byte_order
= trace
->byte_order
;
1118 int has_alignment
= 0, has_exp_dig
= 0, has_mant_dig
= 0;
1119 struct declaration_float
*float_declaration
;
1121 cds_list_for_each_entry(expression
, expressions
, siblings
) {
1122 struct ctf_node
*left
, *right
;
1124 left
= _cds_list_first_entry(&expression
->u
.ctf_expression
.left
, struct ctf_node
, siblings
);
1125 right
= _cds_list_first_entry(&expression
->u
.ctf_expression
.right
, struct ctf_node
, siblings
);
1126 assert(left
->u
.unary_expression
.type
== UNARY_STRING
);
1127 if (!strcmp(left
->u
.unary_expression
.u
.string
, "byte_order")) {
1128 byte_order
= get_byte_order(fd
, depth
, right
, trace
);
1131 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "exp_dig")) {
1132 if (right
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
1133 fprintf(fd
, "[error] %s: exp_dig: expecting unsigned constant\n",
1137 exp_dig
= right
->u
.unary_expression
.u
.unsigned_constant
;
1139 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "mant_dig")) {
1140 if (right
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
1141 fprintf(fd
, "[error] %s: mant_dig: expecting unsigned constant\n",
1145 mant_dig
= right
->u
.unary_expression
.u
.unsigned_constant
;
1147 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "align")) {
1148 if (right
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
1149 fprintf(fd
, "[error] %s: align: expecting unsigned constant\n",
1153 alignment
= right
->u
.unary_expression
.u
.unsigned_constant
;
1156 fprintf(fd
, "[error] %s: unknown attribute name %s\n",
1157 __func__
, left
->u
.unary_expression
.u
.string
);
1161 if (!has_mant_dig
) {
1162 fprintf(fd
, "[error] %s: missing mant_dig attribute\n", __func__
);
1166 fprintf(fd
, "[error] %s: missing exp_dig attribute\n", __func__
);
1169 if (!has_alignment
) {
1170 if ((mant_dig
+ exp_dig
) % CHAR_BIT
) {
1171 /* bit-packed alignment */
1174 /* byte-packed alignment */
1175 alignment
= CHAR_BIT
;
1178 float_declaration
= float_declaration_new(mant_dig
, exp_dig
,
1179 byte_order
, alignment
);
1180 return &float_declaration
->p
;
1184 struct declaration
*ctf_declaration_string_visit(FILE *fd
, int depth
,
1185 struct cds_list_head
*expressions
,
1186 struct ctf_trace
*trace
)
1188 struct ctf_node
*expression
;
1189 const char *encoding_c
= NULL
;
1190 enum ctf_string_encoding encoding
= CTF_STRING_UTF8
;
1191 struct declaration_string
*string_declaration
;
1193 cds_list_for_each_entry(expression
, expressions
, siblings
) {
1194 struct ctf_node
*left
, *right
;
1196 left
= _cds_list_first_entry(&expression
->u
.ctf_expression
.left
, struct ctf_node
, siblings
);
1197 right
= _cds_list_first_entry(&expression
->u
.ctf_expression
.right
, struct ctf_node
, siblings
);
1198 assert(left
->u
.unary_expression
.type
== UNARY_STRING
);
1199 if (!strcmp(left
->u
.unary_expression
.u
.string
, "encoding")) {
1200 if (right
->u
.unary_expression
.type
!= UNARY_STRING
) {
1201 fprintf(fd
, "[error] %s: encoding: expecting string\n",
1205 encoding_c
= right
->u
.unary_expression
.u
.string
;
1207 fprintf(fd
, "[error] %s: unknown attribute name %s\n",
1208 __func__
, left
->u
.unary_expression
.u
.string
);
1212 if (encoding_c
&& !strcmp(encoding_c
, "ASCII"))
1213 encoding
= CTF_STRING_ASCII
;
1214 string_declaration
= string_declaration_new(encoding
);
1215 return &string_declaration
->p
;
1220 struct declaration
*ctf_type_specifier_list_visit(FILE *fd
,
1221 int depth
, struct ctf_node
*type_specifier_list
,
1222 struct declaration_scope
*declaration_scope
,
1223 struct ctf_trace
*trace
)
1225 struct ctf_node
*first
;
1226 struct ctf_node
*node
;
1228 assert(type_specifier_list
->type
== NODE_TYPE_SPECIFIER_LIST
);
1230 first
= _cds_list_first_entry(&type_specifier_list
->u
.type_specifier_list
.head
, struct ctf_node
, siblings
);
1232 assert(first
->type
== NODE_TYPE_SPECIFIER
);
1234 node
= first
->u
.type_specifier
.node
;
1236 switch (first
->u
.type_specifier
.type
) {
1237 case TYPESPEC_FLOATING_POINT
:
1238 return ctf_declaration_floating_point_visit(fd
, depth
,
1239 &node
->u
.floating_point
.expressions
, trace
);
1240 case TYPESPEC_INTEGER
:
1241 return ctf_declaration_integer_visit(fd
, depth
,
1242 &node
->u
.integer
.expressions
, trace
);
1243 case TYPESPEC_STRING
:
1244 return ctf_declaration_string_visit(fd
, depth
,
1245 &node
->u
.string
.expressions
, trace
);
1246 case TYPESPEC_STRUCT
:
1247 return ctf_declaration_struct_visit(fd
, depth
,
1248 node
->u
._struct
.name
,
1249 &node
->u
._struct
.declaration_list
,
1250 node
->u
._struct
.has_body
,
1253 case TYPESPEC_VARIANT
:
1254 return ctf_declaration_variant_visit(fd
, depth
,
1255 node
->u
.variant
.name
,
1256 node
->u
.variant
.choice
,
1257 &node
->u
.variant
.declaration_list
,
1258 node
->u
.variant
.has_body
,
1262 return ctf_declaration_enum_visit(fd
, depth
,
1263 node
->u
._enum
.enum_id
,
1264 node
->u
._enum
.container_type
,
1265 &node
->u
._enum
.enumerator_list
,
1266 node
->u
._enum
.has_body
,
1272 case TYPESPEC_SHORT
:
1275 case TYPESPEC_FLOAT
:
1276 case TYPESPEC_DOUBLE
:
1277 case TYPESPEC_SIGNED
:
1278 case TYPESPEC_UNSIGNED
:
1280 case TYPESPEC_COMPLEX
:
1281 case TYPESPEC_IMAGINARY
:
1282 case TYPESPEC_CONST
:
1283 case TYPESPEC_ID_TYPE
:
1284 return ctf_declaration_type_specifier_visit(fd
, depth
,
1285 type_specifier_list
, declaration_scope
);
1287 fprintf(fd
, "[error] %s: unexpected node type %d\n", __func__
, (int) first
->u
.type_specifier
.type
);
1293 int ctf_event_declaration_visit(FILE *fd
, int depth
, struct ctf_node
*node
, struct ctf_event
*event
, struct ctf_trace
*trace
)
1297 switch (node
->type
) {
1299 ret
= ctf_typedef_visit(fd
, depth
+ 1,
1300 event
->declaration_scope
,
1301 node
->u
._typedef
.type_specifier_list
,
1302 &node
->u
._typedef
.type_declarators
,
1307 case NODE_TYPEALIAS
:
1308 ret
= ctf_typealias_visit(fd
, depth
+ 1,
1309 event
->declaration_scope
,
1310 node
->u
.typealias
.target
, node
->u
.typealias
.alias
,
1315 case NODE_CTF_EXPRESSION
:
1319 left
= concatenate_unary_strings(&node
->u
.ctf_expression
.left
);
1320 if (!strcmp(left
, "name")) {
1323 if (CTF_EVENT_FIELD_IS_SET(event
, name
)) {
1324 fprintf(fd
, "[error] %s: name already declared in event declaration\n", __func__
);
1328 right
= concatenate_unary_strings(&node
->u
.ctf_expression
.right
);
1330 fprintf(fd
, "[error] %s: unexpected unary expression for event name\n", __func__
);
1334 event
->name
= g_quark_from_string(right
);
1336 CTF_EVENT_SET_FIELD(event
, name
);
1337 } else if (!strcmp(left
, "id")) {
1338 if (CTF_EVENT_FIELD_IS_SET(event
, id
)) {
1339 fprintf(fd
, "[error] %s: id already declared in event declaration\n", __func__
);
1343 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &event
->id
);
1345 fprintf(fd
, "[error] %s: unexpected unary expression for event id\n", __func__
);
1349 CTF_EVENT_SET_FIELD(event
, id
);
1350 } else if (!strcmp(left
, "stream_id")) {
1351 if (CTF_EVENT_FIELD_IS_SET(event
, stream_id
)) {
1352 fprintf(fd
, "[error] %s: stream_id already declared in event declaration\n", __func__
);
1356 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &event
->stream_id
);
1358 fprintf(fd
, "[error] %s: unexpected unary expression for event stream_id\n", __func__
);
1362 event
->stream
= trace_stream_lookup(trace
, event
->stream_id
);
1363 if (!event
->stream
) {
1364 fprintf(fd
, "[error] %s: stream id %" PRIu64
" cannot be found\n", __func__
, event
->stream_id
);
1368 CTF_EVENT_SET_FIELD(event
, stream_id
);
1369 } else if (!strcmp(left
, "context")) {
1370 struct declaration
*declaration
;
1372 if (event
->context_decl
) {
1373 fprintf(fd
, "[error] %s: context already declared in event declaration\n", __func__
);
1377 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1378 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1379 struct ctf_node
, siblings
),
1380 event
->declaration_scope
, trace
);
1385 if (declaration
->id
!= CTF_TYPE_STRUCT
) {
1389 event
->context_decl
= container_of(declaration
, struct declaration_struct
, p
);
1390 } else if (!strcmp(left
, "fields")) {
1391 struct declaration
*declaration
;
1393 if (event
->fields_decl
) {
1394 fprintf(fd
, "[error] %s: fields already declared in event declaration\n", __func__
);
1398 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1399 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1400 struct ctf_node
, siblings
),
1401 event
->declaration_scope
, trace
);
1406 if (declaration
->id
!= CTF_TYPE_STRUCT
) {
1410 event
->fields_decl
= container_of(declaration
, struct declaration_struct
, p
);
1418 /* TODO: declaration specifier should be added. */
1425 int ctf_event_visit(FILE *fd
, int depth
, struct ctf_node
*node
,
1426 struct declaration_scope
*parent_declaration_scope
, struct ctf_trace
*trace
)
1429 struct ctf_node
*iter
;
1430 struct ctf_event
*event
;
1431 struct definition_scope
*parent_def_scope
;
1433 event
= g_new0(struct ctf_event
, 1);
1434 event
->declaration_scope
= new_declaration_scope(parent_declaration_scope
);
1435 cds_list_for_each_entry(iter
, &node
->u
.event
.declaration_list
, siblings
) {
1436 ret
= ctf_event_declaration_visit(fd
, depth
+ 1, iter
, event
, trace
);
1440 if (!CTF_EVENT_FIELD_IS_SET(event
, name
)) {
1442 fprintf(fd
, "[error] %s: missing name field in event declaration\n", __func__
);
1445 /* Allow only one event without id per stream */
1446 if (!CTF_EVENT_FIELD_IS_SET(event
, id
)
1447 && event
->stream
->events_by_id
->len
!= 0) {
1449 fprintf(fd
, "[error] %s: missing id field in event declaration\n", __func__
);
1452 if (!CTF_EVENT_FIELD_IS_SET(event
, stream_id
)) {
1453 /* Allow missing stream_id if there is only a single stream */
1454 if (trace
->streams
->len
== 1) {
1455 event
->stream_id
= 0;
1456 event
->stream
= trace_stream_lookup(trace
, event
->stream_id
);
1459 fprintf(fd
, "[error] %s: missing stream_id field in event declaration\n", __func__
);
1463 if (event
->stream
->events_by_id
->len
<= event
->id
)
1464 g_ptr_array_set_size(event
->stream
->events_by_id
, event
->id
+ 1);
1465 g_ptr_array_index(event
->stream
->events_by_id
, event
->id
) = event
;
1466 g_hash_table_insert(event
->stream
->event_quark_to_id
,
1467 (gpointer
)(unsigned long) event
->name
,
1469 parent_def_scope
= event
->stream
->definition_scope
;
1470 if (event
->context_decl
) {
1473 event
->context_decl
->p
.definition_new(&event
->context_decl
->p
,
1474 parent_def_scope
, 0, 0),
1475 struct definition_struct
, p
);
1476 set_dynamic_definition_scope(&event
->context
->p
,
1477 event
->context
->scope
,
1479 parent_def_scope
= event
->context
->scope
;
1480 declaration_unref(&event
->context_decl
->p
);
1482 if (event
->fields_decl
) {
1485 event
->fields_decl
->p
.definition_new(&event
->fields_decl
->p
,
1486 parent_def_scope
, 0, 0),
1487 struct definition_struct
, p
);
1488 set_dynamic_definition_scope(&event
->fields
->p
,
1489 event
->fields
->scope
,
1491 parent_def_scope
= event
->fields
->scope
;
1492 declaration_unref(&event
->fields_decl
->p
);
1497 declaration_unref(&event
->fields_decl
->p
);
1498 declaration_unref(&event
->context_decl
->p
);
1499 free_declaration_scope(event
->declaration_scope
);
1506 int ctf_stream_declaration_visit(FILE *fd
, int depth
, struct ctf_node
*node
, struct ctf_stream
*stream
, struct ctf_trace
*trace
)
1510 switch (node
->type
) {
1512 ret
= ctf_typedef_visit(fd
, depth
+ 1,
1513 stream
->declaration_scope
,
1514 node
->u
._typedef
.type_specifier_list
,
1515 &node
->u
._typedef
.type_declarators
,
1520 case NODE_TYPEALIAS
:
1521 ret
= ctf_typealias_visit(fd
, depth
+ 1,
1522 stream
->declaration_scope
,
1523 node
->u
.typealias
.target
, node
->u
.typealias
.alias
,
1528 case NODE_CTF_EXPRESSION
:
1532 left
= concatenate_unary_strings(&node
->u
.ctf_expression
.left
);
1533 if (!strcmp(left
, "id")) {
1534 if (CTF_STREAM_FIELD_IS_SET(stream
, stream_id
)) {
1535 fprintf(fd
, "[error] %s: id already declared in stream declaration\n", __func__
);
1539 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &stream
->stream_id
);
1541 fprintf(fd
, "[error] %s: unexpected unary expression for stream id\n", __func__
);
1545 CTF_STREAM_SET_FIELD(stream
, stream_id
);
1546 } else if (!strcmp(left
, "event.header")) {
1547 struct declaration
*declaration
;
1549 if (stream
->event_header_decl
) {
1550 fprintf(fd
, "[error] %s: event.header already declared in stream declaration\n", __func__
);
1554 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1555 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1556 struct ctf_node
, siblings
),
1557 stream
->declaration_scope
, trace
);
1562 if (declaration
->id
!= CTF_TYPE_STRUCT
) {
1566 stream
->event_header_decl
= container_of(declaration
, struct declaration_struct
, p
);
1567 } else if (!strcmp(left
, "event.context")) {
1568 struct declaration
*declaration
;
1570 if (stream
->event_context_decl
) {
1571 fprintf(fd
, "[error] %s: event.context already declared in stream declaration\n", __func__
);
1575 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1576 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1577 struct ctf_node
, siblings
),
1578 stream
->declaration_scope
, trace
);
1583 if (declaration
->id
!= CTF_TYPE_STRUCT
) {
1587 stream
->event_context_decl
= container_of(declaration
, struct declaration_struct
, p
);
1588 } else if (!strcmp(left
, "packet.context")) {
1589 struct declaration
*declaration
;
1591 if (stream
->packet_context_decl
) {
1592 fprintf(fd
, "[error] %s: packet.context already declared in stream declaration\n", __func__
);
1596 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1597 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1598 struct ctf_node
, siblings
),
1599 stream
->declaration_scope
, trace
);
1604 if (declaration
->id
!= CTF_TYPE_STRUCT
) {
1608 stream
->packet_context_decl
= container_of(declaration
, struct declaration_struct
, p
);
1616 /* TODO: declaration specifier should be added. */
1623 int ctf_stream_visit(FILE *fd
, int depth
, struct ctf_node
*node
,
1624 struct declaration_scope
*parent_declaration_scope
, struct ctf_trace
*trace
)
1627 struct ctf_node
*iter
;
1628 struct ctf_stream
*stream
;
1629 struct definition_scope
*parent_def_scope
;
1631 stream
= g_new0(struct ctf_stream
, 1);
1632 stream
->declaration_scope
= new_declaration_scope(parent_declaration_scope
);
1633 stream
->events_by_id
= g_ptr_array_new();
1634 stream
->event_quark_to_id
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
1635 stream
->files
= g_ptr_array_new();
1636 cds_list_for_each_entry(iter
, &node
->u
.stream
.declaration_list
, siblings
) {
1637 ret
= ctf_stream_declaration_visit(fd
, depth
+ 1, iter
, stream
, trace
);
1641 if (CTF_STREAM_FIELD_IS_SET(stream
, stream_id
)) {
1642 /* check that packet header has stream_id field. */
1643 if (!trace
->packet_header_decl
1644 || struct_declaration_lookup_field_index(trace
->packet_header_decl
, g_quark_from_static_string("stream_id")) < 0) {
1646 fprintf(fd
, "[error] %s: missing stream_id field in packet header declaration, but stream_id attribute is declared for stream.\n", __func__
);
1651 /* Allow only one id-less stream */
1652 if (!CTF_STREAM_FIELD_IS_SET(stream
, stream_id
)
1653 && trace
->streams
->len
!= 0) {
1655 fprintf(fd
, "[error] %s: missing id field in stream declaration\n", __func__
);
1658 if (trace
->streams
->len
<= stream
->stream_id
)
1659 g_ptr_array_set_size(trace
->streams
, stream
->stream_id
+ 1);
1660 g_ptr_array_index(trace
->streams
, stream
->stream_id
) = stream
;
1662 parent_def_scope
= trace
->definition_scope
;
1663 if (stream
->packet_context_decl
) {
1664 stream
->packet_context
=
1666 stream
->packet_context_decl
->p
.definition_new(&stream
->packet_context_decl
->p
,
1667 parent_def_scope
, 0, 0),
1668 struct definition_struct
, p
);
1669 set_dynamic_definition_scope(&stream
->packet_context
->p
,
1670 stream
->packet_context
->scope
,
1671 "stream.packet.context");
1672 parent_def_scope
= stream
->packet_context
->scope
;
1673 declaration_unref(&stream
->packet_context_decl
->p
);
1675 if (stream
->event_header_decl
) {
1676 stream
->event_header
=
1678 stream
->event_header_decl
->p
.definition_new(&stream
->event_header_decl
->p
,
1679 parent_def_scope
, 0, 0),
1680 struct definition_struct
, p
);
1681 set_dynamic_definition_scope(&stream
->event_header
->p
,
1682 stream
->event_header
->scope
,
1683 "stream.event.header");
1684 parent_def_scope
= stream
->event_header
->scope
;
1685 declaration_unref(&stream
->event_header_decl
->p
);
1687 if (stream
->event_context_decl
) {
1688 stream
->event_context
=
1690 stream
->event_context_decl
->p
.definition_new(&stream
->event_context_decl
->p
,
1691 parent_def_scope
, 0, 0),
1692 struct definition_struct
, p
);
1693 set_dynamic_definition_scope(&stream
->event_context
->p
,
1694 stream
->event_context
->scope
,
1695 "stream.event.context");
1696 parent_def_scope
= stream
->event_context
->scope
;
1697 declaration_unref(&stream
->event_context_decl
->p
);
1699 stream
->definition_scope
= parent_def_scope
;
1704 declaration_unref(&stream
->event_header_decl
->p
);
1705 declaration_unref(&stream
->event_context_decl
->p
);
1706 declaration_unref(&stream
->packet_context_decl
->p
);
1707 g_ptr_array_free(stream
->files
, TRUE
);
1708 g_ptr_array_free(stream
->events_by_id
, TRUE
);
1709 g_hash_table_destroy(stream
->event_quark_to_id
);
1710 free_declaration_scope(stream
->declaration_scope
);
1716 int ctf_trace_declaration_visit(FILE *fd
, int depth
, struct ctf_node
*node
, struct ctf_trace
*trace
)
1720 switch (node
->type
) {
1722 ret
= ctf_typedef_visit(fd
, depth
+ 1,
1723 trace
->declaration_scope
,
1724 node
->u
._typedef
.type_specifier_list
,
1725 &node
->u
._typedef
.type_declarators
,
1730 case NODE_TYPEALIAS
:
1731 ret
= ctf_typealias_visit(fd
, depth
+ 1,
1732 trace
->declaration_scope
,
1733 node
->u
.typealias
.target
, node
->u
.typealias
.alias
,
1738 case NODE_CTF_EXPRESSION
:
1742 left
= concatenate_unary_strings(&node
->u
.ctf_expression
.left
);
1743 if (!strcmp(left
, "major")) {
1744 if (CTF_TRACE_FIELD_IS_SET(trace
, major
)) {
1745 fprintf(fd
, "[error] %s: major already declared in trace declaration\n", __func__
);
1749 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &trace
->major
);
1751 fprintf(fd
, "[error] %s: unexpected unary expression for trace major number\n", __func__
);
1755 CTF_TRACE_SET_FIELD(trace
, major
);
1756 } else if (!strcmp(left
, "minor")) {
1757 if (CTF_TRACE_FIELD_IS_SET(trace
, minor
)) {
1758 fprintf(fd
, "[error] %s: minor already declared in trace declaration\n", __func__
);
1762 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &trace
->minor
);
1764 fprintf(fd
, "[error] %s: unexpected unary expression for trace minor number\n", __func__
);
1768 CTF_TRACE_SET_FIELD(trace
, minor
);
1769 } else if (!strcmp(left
, "uuid")) {
1770 if (CTF_TRACE_FIELD_IS_SET(trace
, uuid
)) {
1771 fprintf(fd
, "[error] %s: uuid already declared in trace declaration\n", __func__
);
1775 ret
= get_unary_uuid(&node
->u
.ctf_expression
.right
, &trace
->uuid
);
1777 fprintf(fd
, "[error] %s: unexpected unary expression for trace uuid\n", __func__
);
1781 CTF_TRACE_SET_FIELD(trace
, uuid
);
1782 } else if (!strcmp(left
, "byte_order")) {
1783 struct ctf_node
*right
;
1786 if (CTF_TRACE_FIELD_IS_SET(trace
, byte_order
)) {
1787 fprintf(fd
, "[error] %s: endianness already declared in trace declaration\n", __func__
);
1791 right
= _cds_list_first_entry(&node
->u
.ctf_expression
.right
, struct ctf_node
, siblings
);
1792 byte_order
= get_trace_byte_order(fd
, depth
, right
);
1795 trace
->byte_order
= byte_order
;
1796 CTF_TRACE_SET_FIELD(trace
, byte_order
);
1797 } else if (!strcmp(left
, "packet.header")) {
1798 struct declaration
*declaration
;
1800 if (trace
->packet_header_decl
) {
1801 fprintf(fd
, "[error] %s: packet.header already declared in trace declaration\n", __func__
);
1805 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1806 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1807 struct ctf_node
, siblings
),
1808 trace
->declaration_scope
, trace
);
1813 if (declaration
->id
!= CTF_TYPE_STRUCT
) {
1817 trace
->packet_header_decl
= container_of(declaration
, struct declaration_struct
, p
);
1825 /* TODO: declaration specifier should be added. */
1832 int ctf_trace_visit(FILE *fd
, int depth
, struct ctf_node
*node
, struct ctf_trace
*trace
)
1834 struct definition_scope
*parent_def_scope
;
1836 struct ctf_node
*iter
;
1838 if (trace
->declaration_scope
)
1840 trace
->declaration_scope
= new_declaration_scope(trace
->root_declaration_scope
);
1841 trace
->streams
= g_ptr_array_new();
1842 cds_list_for_each_entry(iter
, &node
->u
.trace
.declaration_list
, siblings
) {
1843 ret
= ctf_trace_declaration_visit(fd
, depth
+ 1, iter
, trace
);
1847 if (!CTF_TRACE_FIELD_IS_SET(trace
, major
)) {
1849 fprintf(fd
, "[error] %s: missing major field in trace declaration\n", __func__
);
1852 if (!CTF_TRACE_FIELD_IS_SET(trace
, minor
)) {
1854 fprintf(fd
, "[error] %s: missing minor field in trace declaration\n", __func__
);
1857 if (!CTF_TRACE_FIELD_IS_SET(trace
, uuid
)) {
1859 fprintf(fd
, "[error] %s: missing uuid field in trace declaration\n", __func__
);
1862 if (!CTF_TRACE_FIELD_IS_SET(trace
, byte_order
)) {
1864 fprintf(fd
, "[error] %s: missing byte_order field in trace declaration\n", __func__
);
1868 parent_def_scope
= NULL
;
1869 if (trace
->packet_header_decl
) {
1870 trace
->packet_header
=
1872 trace
->packet_header_decl
->p
.definition_new(&trace
->packet_header_decl
->p
,
1873 parent_def_scope
, 0, 0),
1874 struct definition_struct
, p
);
1875 set_dynamic_definition_scope(&trace
->packet_header
->p
,
1876 trace
->packet_header
->scope
,
1877 "trace.packet.header");
1878 parent_def_scope
= trace
->packet_header
->scope
;
1879 declaration_unref(&trace
->packet_header_decl
->p
);
1881 trace
->definition_scope
= parent_def_scope
;
1883 if (!CTF_TRACE_FIELD_IS_SET(trace
, byte_order
)) {
1884 /* check that the packet header contains a "magic" field */
1885 if (!trace
->packet_header
1886 || struct_declaration_lookup_field_index(trace
->packet_header_decl
, g_quark_from_static_string("magic")) < 0) {
1888 fprintf(fd
, "[error] %s: missing both byte_order and packet header magic number in trace declaration\n", __func__
);
1889 goto error_free_def
;
1895 definition_unref(&trace
->packet_header
->p
);
1897 g_ptr_array_free(trace
->streams
, TRUE
);
1898 free_declaration_scope(trace
->declaration_scope
);
1903 int ctf_root_declaration_visit(FILE *fd
, int depth
, struct ctf_node
*node
, struct ctf_trace
*trace
)
1907 switch (node
->type
) {
1909 ret
= ctf_typedef_visit(fd
, depth
+ 1,
1910 trace
->root_declaration_scope
,
1911 node
->u
._typedef
.type_specifier_list
,
1912 &node
->u
._typedef
.type_declarators
,
1917 case NODE_TYPEALIAS
:
1918 ret
= ctf_typealias_visit(fd
, depth
+ 1,
1919 trace
->root_declaration_scope
,
1920 node
->u
.typealias
.target
, node
->u
.typealias
.alias
,
1925 case NODE_TYPE_SPECIFIER_LIST
:
1927 struct declaration
*declaration
;
1930 * Just add the type specifier to the root scope
1931 * declaration scope. Release local reference.
1933 declaration
= ctf_type_specifier_list_visit(fd
, depth
+ 1,
1934 node
, trace
->root_declaration_scope
, trace
);
1937 declaration_unref(declaration
);
1947 int ctf_visitor_construct_metadata(FILE *fd
, int depth
, struct ctf_node
*node
,
1948 struct ctf_trace
*trace
, int byte_order
)
1951 struct ctf_node
*iter
;
1953 fprintf(fd
, "CTF visitor: metadata construction... ");
1954 trace
->root_declaration_scope
= new_declaration_scope(NULL
);
1955 trace
->byte_order
= byte_order
;
1957 switch (node
->type
) {
1959 cds_list_for_each_entry(iter
, &node
->u
.root
.declaration_list
,
1961 ret
= ctf_root_declaration_visit(fd
, depth
+ 1, iter
, trace
);
1963 fprintf(fd
, "[error] %s: root declaration error\n", __func__
);
1967 cds_list_for_each_entry(iter
, &node
->u
.root
.trace
, siblings
) {
1968 ret
= ctf_trace_visit(fd
, depth
+ 1, iter
, trace
);
1970 fprintf(fd
, "[error] %s: trace declaration error\n", __func__
);
1974 if (!trace
->streams
) {
1975 fprintf(fd
, "[error] %s: missing trace declaration\n", __func__
);
1978 cds_list_for_each_entry(iter
, &node
->u
.root
.stream
, siblings
) {
1979 ret
= ctf_stream_visit(fd
, depth
+ 1, iter
,
1980 trace
->root_declaration_scope
, trace
);
1982 fprintf(fd
, "[error] %s: stream declaration error\n", __func__
);
1986 cds_list_for_each_entry(iter
, &node
->u
.root
.event
, siblings
) {
1987 ret
= ctf_event_visit(fd
, depth
+ 1, iter
,
1988 trace
->root_declaration_scope
, trace
);
1990 fprintf(fd
, "[error] %s: event declaration error\n", __func__
);
1997 fprintf(fd
, "[error] %s: unknown node type %d\n", __func__
,
2001 fprintf(fd
, "done.\n");