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/babeltrace.h>
29 #include <babeltrace/list.h>
30 #include <babeltrace/types.h>
31 #include <babeltrace/ctf/metadata.h>
32 #include <uuid/uuid.h>
33 #include "ctf-scanner.h"
34 #include "ctf-parser.h"
37 #define fprintf_dbg(fd, fmt, args...) fprintf(fd, "%s: " fmt, __func__, ## args)
39 #define _cds_list_first_entry(ptr, type, member) \
40 cds_list_entry((ptr)->next, type, member)
43 struct declaration
*ctf_type_specifier_list_visit(FILE *fd
,
44 int depth
, struct ctf_node
*type_specifier_list
,
45 struct declaration_scope
*declaration_scope
,
46 struct ctf_trace
*trace
);
49 int ctf_stream_visit(FILE *fd
, int depth
, struct ctf_node
*node
,
50 struct declaration_scope
*parent_declaration_scope
, struct ctf_trace
*trace
);
53 * String returned must be freed by the caller using g_free.
56 char *concatenate_unary_strings(struct cds_list_head
*head
)
58 struct ctf_node
*node
;
62 str
= g_string_new("");
63 cds_list_for_each_entry(node
, head
, siblings
) {
66 assert(node
->type
== NODE_UNARY_EXPRESSION
);
67 assert(node
->u
.unary_expression
.type
== UNARY_STRING
);
68 assert((node
->u
.unary_expression
.link
== UNARY_LINK_UNKNOWN
)
70 switch (node
->u
.unary_expression
.link
) {
72 g_string_append(str
, ".");
75 g_string_append(str
, "->");
78 g_string_append(str
, "...");
83 src_string
= node
->u
.unary_expression
.u
.string
;
84 g_string_append(str
, src_string
);
87 return g_string_free(str
, FALSE
);
91 int get_unary_unsigned(struct cds_list_head
*head
, uint64_t *value
)
93 struct ctf_node
*node
;
96 cds_list_for_each_entry(node
, head
, siblings
) {
97 assert(node
->type
== NODE_UNARY_EXPRESSION
);
98 assert(node
->u
.unary_expression
.type
== UNARY_UNSIGNED_CONSTANT
);
99 assert(node
->u
.unary_expression
.link
== UNARY_LINK_UNKNOWN
);
101 *value
= node
->u
.unary_expression
.u
.unsigned_constant
;
108 int get_unary_uuid(struct cds_list_head
*head
, uuid_t
*uuid
)
110 struct ctf_node
*node
;
114 cds_list_for_each_entry(node
, head
, siblings
) {
115 const char *src_string
;
117 assert(node
->type
== NODE_UNARY_EXPRESSION
);
118 assert(node
->u
.unary_expression
.type
== UNARY_STRING
);
119 assert(node
->u
.unary_expression
.link
== UNARY_LINK_UNKNOWN
);
121 src_string
= node
->u
.unary_expression
.u
.string
;
122 ret
= uuid_parse(node
->u
.unary_expression
.u
.string
, *uuid
);
128 struct ctf_stream_class
*trace_stream_lookup(struct ctf_trace
*trace
, uint64_t stream_id
)
130 if (trace
->streams
->len
<= stream_id
)
132 return g_ptr_array_index(trace
->streams
, stream_id
);
136 int visit_type_specifier(FILE *fd
, struct ctf_node
*type_specifier
, GString
*str
)
138 assert(type_specifier
->type
== NODE_TYPE_SPECIFIER
);
140 switch (type_specifier
->u
.type_specifier
.type
) {
142 g_string_append(str
, "void");
145 g_string_append(str
, "char");
148 g_string_append(str
, "short");
151 g_string_append(str
, "int");
154 g_string_append(str
, "long");
157 g_string_append(str
, "float");
159 case TYPESPEC_DOUBLE
:
160 g_string_append(str
, "double");
162 case TYPESPEC_SIGNED
:
163 g_string_append(str
, "signed");
165 case TYPESPEC_UNSIGNED
:
166 g_string_append(str
, "unsigned");
169 g_string_append(str
, "bool");
171 case TYPESPEC_COMPLEX
:
172 g_string_append(str
, "_Complex");
174 case TYPESPEC_IMAGINARY
:
175 g_string_append(str
, "_Imaginary");
178 g_string_append(str
, "const");
180 case TYPESPEC_ID_TYPE
:
181 if (type_specifier
->u
.type_specifier
.id_type
)
182 g_string_append(str
, type_specifier
->u
.type_specifier
.id_type
);
184 case TYPESPEC_STRUCT
:
186 struct ctf_node
*node
= type_specifier
->u
.type_specifier
.node
;
188 if (!node
->u
._struct
.name
) {
189 fprintf(fd
, "[error] %s: unexpected empty variant name\n", __func__
);
192 g_string_append(str
, "struct ");
193 g_string_append(str
, node
->u
._struct
.name
);
196 case TYPESPEC_VARIANT
:
198 struct ctf_node
*node
= type_specifier
->u
.type_specifier
.node
;
200 if (!node
->u
.variant
.name
) {
201 fprintf(fd
, "[error] %s: unexpected empty variant name\n", __func__
);
204 g_string_append(str
, "variant ");
205 g_string_append(str
, node
->u
.variant
.name
);
210 struct ctf_node
*node
= type_specifier
->u
.type_specifier
.node
;
212 if (!node
->u
._enum
.enum_id
) {
213 fprintf(fd
, "[error] %s: unexpected empty enum ID\n", __func__
);
216 g_string_append(str
, "enum ");
217 g_string_append(str
, node
->u
._enum
.enum_id
);
220 case TYPESPEC_FLOATING_POINT
:
221 case TYPESPEC_INTEGER
:
222 case TYPESPEC_STRING
:
224 fprintf(fd
, "[error] %s: unknown specifier\n", __func__
);
231 int visit_type_specifier_list(FILE *fd
, struct ctf_node
*type_specifier_list
, GString
*str
)
233 struct ctf_node
*iter
;
234 int alias_item_nr
= 0;
237 cds_list_for_each_entry(iter
, &type_specifier_list
->u
.type_specifier_list
.head
, siblings
) {
238 if (alias_item_nr
!= 0)
239 g_string_append(str
, " ");
241 ret
= visit_type_specifier(fd
, iter
, str
);
249 GQuark
create_typealias_identifier(FILE *fd
, int depth
,
250 struct ctf_node
*type_specifier_list
,
251 struct ctf_node
*node_type_declarator
)
253 struct ctf_node
*iter
;
259 str
= g_string_new("");
260 ret
= visit_type_specifier_list(fd
, type_specifier_list
, str
);
262 g_string_free(str
, TRUE
);
265 cds_list_for_each_entry(iter
, &node_type_declarator
->u
.type_declarator
.pointers
, siblings
) {
266 g_string_append(str
, " *");
267 if (iter
->u
.pointer
.const_qualifier
)
268 g_string_append(str
, " const");
270 str_c
= g_string_free(str
, FALSE
);
271 alias_q
= g_quark_from_string(str_c
);
277 struct declaration
*ctf_type_declarator_visit(FILE *fd
, int depth
,
278 struct ctf_node
*type_specifier_list
,
280 struct ctf_node
*node_type_declarator
,
281 struct declaration_scope
*declaration_scope
,
282 struct declaration
*nested_declaration
,
283 struct ctf_trace
*trace
)
286 * Visit type declarator by first taking care of sequence/array
287 * (recursively). Then, when we get to the identifier, take care
291 if (node_type_declarator
) {
292 assert(node_type_declarator
->u
.type_declarator
.type
!= TYPEDEC_UNKNOWN
);
294 /* TODO: gcc bitfields not supported yet. */
295 if (node_type_declarator
->u
.type_declarator
.bitfield_len
!= NULL
) {
296 fprintf(fd
, "[error] %s: gcc bitfields are not supported yet.\n", __func__
);
301 if (!nested_declaration
) {
302 if (node_type_declarator
&& !cds_list_empty(&node_type_declarator
->u
.type_declarator
.pointers
)) {
306 * If we have a pointer declarator, it _has_ to be present in
307 * the typealiases (else fail).
309 alias_q
= create_typealias_identifier(fd
, depth
,
310 type_specifier_list
, node_type_declarator
);
311 nested_declaration
= lookup_declaration(alias_q
, declaration_scope
);
312 if (!nested_declaration
) {
313 fprintf(fd
, "[error] %s: cannot find typealias \"%s\".\n", __func__
, g_quark_to_string(alias_q
));
317 nested_declaration
= ctf_type_specifier_list_visit(fd
, depth
,
318 type_specifier_list
, declaration_scope
, trace
);
322 if (!node_type_declarator
)
323 return nested_declaration
;
325 if (node_type_declarator
->u
.type_declarator
.type
== TYPEDEC_ID
) {
326 if (node_type_declarator
->u
.type_declarator
.u
.id
)
327 *field_name
= g_quark_from_string(node_type_declarator
->u
.type_declarator
.u
.id
);
330 return nested_declaration
;
332 struct declaration
*declaration
;
333 struct ctf_node
*length
;
337 /* create array/sequence, pass nested_declaration as child. */
338 length
= node_type_declarator
->u
.type_declarator
.u
.nested
.length
;
340 fprintf(fd
, "[error] %s: expecting length type or value.\n", __func__
);
343 switch (length
->type
) {
344 case NODE_UNARY_EXPRESSION
:
346 struct declaration_array
*array_declaration
;
349 if (length
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
350 fprintf(fd
, "[error] %s: array: unexpected unary expression.\n", __func__
);
353 len
= length
->u
.unary_expression
.u
.unsigned_constant
;
354 array_declaration
= array_declaration_new(len
, nested_declaration
,
356 declaration
= &array_declaration
->p
;
359 case NODE_TYPE_SPECIFIER_LIST
:
361 struct declaration_sequence
*sequence_declaration
;
362 struct declaration_integer
*integer_declaration
;
364 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
365 length
, declaration_scope
, trace
);
367 fprintf(fd
, "[error] %s: unable to find declaration type for sequence length\n", __func__
);
370 if (declaration
->id
!= CTF_TYPE_INTEGER
) {
371 fprintf(fd
, "[error] %s: length type for sequence is expected to be an integer (unsigned).\n", __func__
);
372 declaration_unref(declaration
);
375 integer_declaration
= container_of(declaration
, struct declaration_integer
, p
);
376 if (integer_declaration
->signedness
!= false) {
377 fprintf(fd
, "[error] %s: length type for sequence should always be an unsigned integer.\n", __func__
);
378 declaration_unref(declaration
);
382 sequence_declaration
= sequence_declaration_new(integer_declaration
,
383 nested_declaration
, declaration_scope
);
384 declaration
= &sequence_declaration
->p
;
391 /* Pass it as content of outer container */
392 declaration
= ctf_type_declarator_visit(fd
, depth
,
393 type_specifier_list
, field_name
,
394 node_type_declarator
->u
.type_declarator
.u
.nested
.type_declarator
,
395 declaration_scope
, declaration
, trace
);
401 int ctf_struct_type_declarators_visit(FILE *fd
, int depth
,
402 struct declaration_struct
*struct_declaration
,
403 struct ctf_node
*type_specifier_list
,
404 struct cds_list_head
*type_declarators
,
405 struct declaration_scope
*declaration_scope
,
406 struct ctf_trace
*trace
)
408 struct ctf_node
*iter
;
411 cds_list_for_each_entry(iter
, type_declarators
, siblings
) {
412 struct declaration
*field_declaration
;
414 field_declaration
= ctf_type_declarator_visit(fd
, depth
,
417 struct_declaration
->scope
,
419 if (!field_declaration
) {
420 fprintf(fd
, "[error] %s: unable to find struct field declaration type\n", __func__
);
423 struct_declaration_add_field(struct_declaration
,
424 g_quark_to_string(field_name
),
431 int ctf_variant_type_declarators_visit(FILE *fd
, int depth
,
432 struct declaration_untagged_variant
*untagged_variant_declaration
,
433 struct ctf_node
*type_specifier_list
,
434 struct cds_list_head
*type_declarators
,
435 struct declaration_scope
*declaration_scope
,
436 struct ctf_trace
*trace
)
438 struct ctf_node
*iter
;
441 cds_list_for_each_entry(iter
, type_declarators
, siblings
) {
442 struct declaration
*field_declaration
;
444 field_declaration
= ctf_type_declarator_visit(fd
, depth
,
447 untagged_variant_declaration
->scope
,
449 if (!field_declaration
) {
450 fprintf(fd
, "[error] %s: unable to find variant field declaration type\n", __func__
);
453 untagged_variant_declaration_add_field(untagged_variant_declaration
,
454 g_quark_to_string(field_name
),
461 int ctf_typedef_visit(FILE *fd
, int depth
, struct declaration_scope
*scope
,
462 struct ctf_node
*type_specifier_list
,
463 struct cds_list_head
*type_declarators
,
464 struct ctf_trace
*trace
)
466 struct ctf_node
*iter
;
469 cds_list_for_each_entry(iter
, type_declarators
, siblings
) {
470 struct declaration
*type_declaration
;
473 type_declaration
= ctf_type_declarator_visit(fd
, depth
,
477 if (!type_declaration
) {
478 fprintf(fd
, "[error] %s: problem creating type declaration\n", __func__
);
482 * Don't allow typedef and typealias of untagged
485 if (type_declaration
->id
== CTF_TYPE_UNTAGGED_VARIANT
) {
486 fprintf(fd
, "[error] %s: typedef of untagged variant is not permitted.\n", __func__
);
487 declaration_unref(type_declaration
);
490 ret
= register_declaration(identifier
, type_declaration
, scope
);
492 type_declaration
->declaration_free(type_declaration
);
500 int ctf_typealias_visit(FILE *fd
, int depth
, struct declaration_scope
*scope
,
501 struct ctf_node
*target
, struct ctf_node
*alias
,
502 struct ctf_trace
*trace
)
504 struct declaration
*type_declaration
;
505 struct ctf_node
*node
;
510 /* See ctf_visitor_type_declarator() in the semantic validator. */
513 * Create target type declaration.
516 if (cds_list_empty(&target
->u
.typealias_target
.type_declarators
))
519 node
= _cds_list_first_entry(&target
->u
.typealias_target
.type_declarators
,
520 struct ctf_node
, siblings
);
521 type_declaration
= ctf_type_declarator_visit(fd
, depth
,
522 target
->u
.typealias_target
.type_specifier_list
,
525 if (!type_declaration
) {
526 fprintf(fd
, "[error] %s: problem creating type declaration\n", __func__
);
531 * Don't allow typedef and typealias of untagged
534 if (type_declaration
->id
== CTF_TYPE_UNTAGGED_VARIANT
) {
535 fprintf(fd
, "[error] %s: typedef of untagged variant is not permitted.\n", __func__
);
536 declaration_unref(type_declaration
);
540 * The semantic validator does not check whether the target is
541 * abstract or not (if it has an identifier). Check it here.
544 fprintf(fd
, "[error] %s: expecting empty identifier\n", __func__
);
549 * Create alias identifier.
552 node
= _cds_list_first_entry(&alias
->u
.typealias_alias
.type_declarators
,
553 struct ctf_node
, siblings
);
554 alias_q
= create_typealias_identifier(fd
, depth
,
555 alias
->u
.typealias_alias
.type_specifier_list
, node
);
556 err
= register_declaration(alias_q
, type_declaration
, scope
);
562 type_declaration
->declaration_free(type_declaration
);
567 int ctf_struct_declaration_list_visit(FILE *fd
, int depth
,
568 struct ctf_node
*iter
, struct declaration_struct
*struct_declaration
,
569 struct ctf_trace
*trace
)
573 switch (iter
->type
) {
575 /* For each declarator, declare type and add type to struct declaration scope */
576 ret
= ctf_typedef_visit(fd
, depth
,
577 struct_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 struct declaration scope */
585 ret
= ctf_typealias_visit(fd
, depth
,
586 struct_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_struct_type_declarators_visit(fd
, depth
,
596 iter
->u
.struct_or_variant_declaration
.type_specifier_list
,
597 &iter
->u
.struct_or_variant_declaration
.type_declarators
,
598 struct_declaration
->scope
, trace
);
603 fprintf(fd
, "[error] %s: unexpected node type %d\n", __func__
, (int) iter
->type
);
610 int ctf_variant_declaration_list_visit(FILE *fd
, int depth
,
611 struct ctf_node
*iter
,
612 struct declaration_untagged_variant
*untagged_variant_declaration
,
613 struct ctf_trace
*trace
)
617 switch (iter
->type
) {
619 /* For each declarator, declare type and add type to variant declaration scope */
620 ret
= ctf_typedef_visit(fd
, depth
,
621 untagged_variant_declaration
->scope
,
622 iter
->u
._typedef
.type_specifier_list
,
623 &iter
->u
._typedef
.type_declarators
, trace
);
628 /* Declare type with declarator and add type to variant declaration scope */
629 ret
= ctf_typealias_visit(fd
, depth
,
630 untagged_variant_declaration
->scope
,
631 iter
->u
.typealias
.target
,
632 iter
->u
.typealias
.alias
, trace
);
636 case NODE_STRUCT_OR_VARIANT_DECLARATION
:
637 /* Add field to structure declaration */
638 ret
= ctf_variant_type_declarators_visit(fd
, depth
,
639 untagged_variant_declaration
,
640 iter
->u
.struct_or_variant_declaration
.type_specifier_list
,
641 &iter
->u
.struct_or_variant_declaration
.type_declarators
,
642 untagged_variant_declaration
->scope
, trace
);
647 fprintf(fd
, "[error] %s: unexpected node type %d\n", __func__
, (int) iter
->type
);
654 struct declaration
*ctf_declaration_struct_visit(FILE *fd
,
655 int depth
, const char *name
, struct cds_list_head
*declaration_list
,
656 int has_body
, struct cds_list_head
*min_align
,
657 struct declaration_scope
*declaration_scope
,
658 struct ctf_trace
*trace
)
660 struct declaration_struct
*struct_declaration
;
661 struct ctf_node
*iter
;
665 * For named struct (without body), lookup in
666 * declaration scope. Don't take reference on struct
667 * declaration: ref is only taken upon definition.
672 lookup_struct_declaration(g_quark_from_string(name
),
674 return &struct_declaration
->p
;
676 uint64_t min_align_value
= 0;
678 /* For unnamed struct, create type */
679 /* For named struct (with body), create type and add to declaration scope */
681 if (lookup_struct_declaration(g_quark_from_string(name
),
682 declaration_scope
)) {
684 fprintf(fd
, "[error] %s: struct %s already declared in scope\n", __func__
, name
);
688 if (!cds_list_empty(min_align
)) {
689 ret
= get_unary_unsigned(min_align
, &min_align_value
);
691 fprintf(fd
, "[error] %s: unexpected unary expression for structure \"align\" attribute\n", __func__
);
696 struct_declaration
= struct_declaration_new(declaration_scope
,
698 cds_list_for_each_entry(iter
, declaration_list
, siblings
) {
699 ret
= ctf_struct_declaration_list_visit(fd
, depth
+ 1, iter
,
700 struct_declaration
, trace
);
705 ret
= register_struct_declaration(g_quark_from_string(name
),
710 return &struct_declaration
->p
;
713 struct_declaration
->p
.declaration_free(&struct_declaration
->p
);
718 struct declaration
*ctf_declaration_variant_visit(FILE *fd
,
719 int depth
, const char *name
, const char *choice
,
720 struct cds_list_head
*declaration_list
,
721 int has_body
, struct declaration_scope
*declaration_scope
,
722 struct ctf_trace
*trace
)
724 struct declaration_untagged_variant
*untagged_variant_declaration
;
725 struct declaration_variant
*variant_declaration
;
726 struct ctf_node
*iter
;
730 * For named variant (without body), lookup in
731 * declaration scope. Don't take reference on variant
732 * declaration: ref is only taken upon definition.
736 untagged_variant_declaration
=
737 lookup_variant_declaration(g_quark_from_string(name
),
740 /* For unnamed variant, create type */
741 /* For named variant (with body), create type and add to declaration scope */
743 if (lookup_variant_declaration(g_quark_from_string(name
),
744 declaration_scope
)) {
746 fprintf(fd
, "[error] %s: variant %s already declared in scope\n", __func__
, name
);
750 untagged_variant_declaration
= untagged_variant_declaration_new(declaration_scope
);
751 cds_list_for_each_entry(iter
, declaration_list
, siblings
) {
752 ret
= ctf_variant_declaration_list_visit(fd
, depth
+ 1, iter
,
753 untagged_variant_declaration
, trace
);
758 ret
= register_variant_declaration(g_quark_from_string(name
),
759 untagged_variant_declaration
,
765 * if tagged, create tagged variant and return. else return
769 return &untagged_variant_declaration
->p
;
771 variant_declaration
= variant_declaration_new(untagged_variant_declaration
, choice
);
772 if (!variant_declaration
)
774 declaration_unref(&untagged_variant_declaration
->p
);
775 return &variant_declaration
->p
;
778 untagged_variant_declaration
->p
.declaration_free(&untagged_variant_declaration
->p
);
783 int ctf_enumerator_list_visit(FILE *fd
, int depth
,
784 struct ctf_node
*enumerator
,
785 struct declaration_enum
*enum_declaration
)
788 struct ctf_node
*iter
;
790 q
= g_quark_from_string(enumerator
->u
.enumerator
.id
);
791 if (enum_declaration
->integer_declaration
->signedness
) {
795 cds_list_for_each_entry(iter
, &enumerator
->u
.enumerator
.values
, siblings
) {
798 assert(iter
->type
== NODE_UNARY_EXPRESSION
);
804 switch (iter
->u
.unary_expression
.type
) {
805 case UNARY_SIGNED_CONSTANT
:
806 *target
= iter
->u
.unary_expression
.u
.signed_constant
;
808 case UNARY_UNSIGNED_CONSTANT
:
809 *target
= iter
->u
.unary_expression
.u
.unsigned_constant
;
812 fprintf(fd
, "[error] %s: invalid enumerator\n", __func__
);
816 fprintf(fd
, "[error] %s: invalid enumerator\n", __func__
);
823 enum_signed_insert(enum_declaration
, start
, end
, q
);
828 cds_list_for_each_entry(iter
, &enumerator
->u
.enumerator
.values
, siblings
) {
831 assert(iter
->type
== NODE_UNARY_EXPRESSION
);
837 switch (iter
->u
.unary_expression
.type
) {
838 case UNARY_UNSIGNED_CONSTANT
:
839 *target
= iter
->u
.unary_expression
.u
.unsigned_constant
;
841 case UNARY_SIGNED_CONSTANT
:
843 * We don't accept signed constants for enums with unsigned
846 fprintf(fd
, "[error] %s: invalid enumerator (signed constant encountered, but enum container type is unsigned)\n", __func__
);
849 fprintf(fd
, "[error] %s: invalid enumerator\n", __func__
);
853 fprintf(fd
, "[error] %s: invalid enumerator\n", __func__
);
860 enum_unsigned_insert(enum_declaration
, start
, end
, q
);
866 struct declaration
*ctf_declaration_enum_visit(FILE *fd
, int depth
,
868 struct ctf_node
*container_type
,
869 struct cds_list_head
*enumerator_list
,
871 struct declaration_scope
*declaration_scope
,
872 struct ctf_trace
*trace
)
874 struct declaration
*declaration
;
875 struct declaration_enum
*enum_declaration
;
876 struct declaration_integer
*integer_declaration
;
877 struct ctf_node
*iter
;
882 * For named enum (without body), lookup in
883 * declaration scope. Don't take reference on enum
884 * declaration: ref is only taken upon definition.
889 lookup_enum_declaration(g_quark_from_string(name
),
891 return &enum_declaration
->p
;
893 /* For unnamed enum, create type */
894 /* For named enum (with body), create type and add to declaration scope */
896 if (lookup_enum_declaration(g_quark_from_string(name
),
897 declaration_scope
)) {
899 fprintf(fd
, "[error] %s: enum %s already declared in scope\n", __func__
, name
);
903 if (!container_type
) {
904 declaration
= lookup_declaration(g_quark_from_static_string("int"),
907 fprintf(fd
, "[error] %s: \"int\" type declaration missing for enumeration\n", __func__
);
911 declaration
= ctf_type_declarator_visit(fd
, depth
,
918 fprintf(fd
, "[error] %s: unable to create container type for enumeration\n", __func__
);
921 if (declaration
->id
!= CTF_TYPE_INTEGER
) {
922 fprintf(fd
, "[error] %s: container type for enumeration is not integer\n", __func__
);
925 integer_declaration
= container_of(declaration
, struct declaration_integer
, p
);
926 enum_declaration
= enum_declaration_new(integer_declaration
);
927 declaration_unref(&integer_declaration
->p
); /* leave ref to enum */
928 cds_list_for_each_entry(iter
, enumerator_list
, siblings
) {
929 ret
= ctf_enumerator_list_visit(fd
, depth
+ 1, iter
, enum_declaration
);
934 ret
= register_enum_declaration(g_quark_from_string(name
),
939 return &enum_declaration
->p
;
942 enum_declaration
->p
.declaration_free(&enum_declaration
->p
);
947 struct declaration
*ctf_declaration_type_specifier_visit(FILE *fd
, int depth
,
948 struct ctf_node
*type_specifier_list
,
949 struct declaration_scope
*declaration_scope
)
952 struct declaration
*declaration
;
957 str
= g_string_new("");
958 ret
= visit_type_specifier_list(fd
, type_specifier_list
, str
);
961 str_c
= g_string_free(str
, FALSE
);
962 id_q
= g_quark_from_string(str_c
);
964 declaration
= lookup_declaration(id_q
, declaration_scope
);
969 * Returns 0/1 boolean, or < 0 on error.
972 int get_boolean(FILE *fd
, int depth
, struct ctf_node
*unary_expression
)
974 if (unary_expression
->type
!= NODE_UNARY_EXPRESSION
) {
975 fprintf(fd
, "[error] %s: expecting unary expression\n",
979 switch (unary_expression
->u
.unary_expression
.type
) {
980 case UNARY_UNSIGNED_CONSTANT
:
981 if (unary_expression
->u
.unary_expression
.u
.unsigned_constant
== 0)
985 case UNARY_SIGNED_CONSTANT
:
986 if (unary_expression
->u
.unary_expression
.u
.signed_constant
== 0)
991 if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "true"))
993 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "TRUE"))
995 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "false"))
997 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "FALSE"))
1000 fprintf(fd
, "[error] %s: unexpected string \"%s\"\n",
1001 __func__
, unary_expression
->u
.unary_expression
.u
.string
);
1006 fprintf(fd
, "[error] %s: unexpected unary expression type\n",
1014 int get_trace_byte_order(FILE *fd
, int depth
, struct ctf_node
*unary_expression
)
1018 if (unary_expression
->u
.unary_expression
.type
!= UNARY_STRING
) {
1019 fprintf(fd
, "[error] %s: byte_order: expecting string\n",
1023 if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "be"))
1024 byte_order
= BIG_ENDIAN
;
1025 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "le"))
1026 byte_order
= LITTLE_ENDIAN
;
1028 fprintf(fd
, "[error] %s: unexpected string \"%s\". Should be \"native\", \"network\", \"be\" or \"le\".\n",
1029 __func__
, unary_expression
->u
.unary_expression
.u
.string
);
1036 int get_byte_order(FILE *fd
, int depth
, struct ctf_node
*unary_expression
,
1037 struct ctf_trace
*trace
)
1041 if (unary_expression
->u
.unary_expression
.type
!= UNARY_STRING
) {
1042 fprintf(fd
, "[error] %s: byte_order: expecting string\n",
1046 if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "native"))
1047 byte_order
= trace
->byte_order
;
1048 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "network"))
1049 byte_order
= BIG_ENDIAN
;
1050 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "be"))
1051 byte_order
= BIG_ENDIAN
;
1052 else if (!strcmp(unary_expression
->u
.unary_expression
.u
.string
, "le"))
1053 byte_order
= LITTLE_ENDIAN
;
1055 fprintf(fd
, "[error] %s: unexpected string \"%s\". Should be \"native\", \"network\", \"be\" or \"le\".\n",
1056 __func__
, unary_expression
->u
.unary_expression
.u
.string
);
1063 struct declaration
*ctf_declaration_integer_visit(FILE *fd
, int depth
,
1064 struct cds_list_head
*expressions
,
1065 struct ctf_trace
*trace
)
1067 struct ctf_node
*expression
;
1068 uint64_t alignment
, size
;
1069 int byte_order
= trace
->byte_order
;
1071 int has_alignment
= 0, has_size
= 0;
1072 struct declaration_integer
*integer_declaration
;
1074 cds_list_for_each_entry(expression
, expressions
, siblings
) {
1075 struct ctf_node
*left
, *right
;
1077 left
= _cds_list_first_entry(&expression
->u
.ctf_expression
.left
, struct ctf_node
, siblings
);
1078 right
= _cds_list_first_entry(&expression
->u
.ctf_expression
.right
, struct ctf_node
, siblings
);
1079 assert(left
->u
.unary_expression
.type
== UNARY_STRING
);
1080 if (!strcmp(left
->u
.unary_expression
.u
.string
, "signed")) {
1081 signedness
= get_boolean(fd
, depth
, right
);
1084 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "byte_order")) {
1085 byte_order
= get_byte_order(fd
, depth
, right
, trace
);
1088 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "size")) {
1089 if (right
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
1090 fprintf(fd
, "[error] %s: size: expecting unsigned constant\n",
1094 size
= right
->u
.unary_expression
.u
.unsigned_constant
;
1096 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "align")) {
1097 if (right
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
1098 fprintf(fd
, "[error] %s: align: expecting unsigned constant\n",
1102 alignment
= right
->u
.unary_expression
.u
.unsigned_constant
;
1103 /* Make sure alignment is a power of two */
1104 if (alignment
== 0 || (alignment
& (alignment
- 1)) != 0) {
1105 fprintf(fd
, "[error] %s: align: expecting power of two\n",
1111 fprintf(fd
, "[error] %s: unknown attribute name %s\n",
1112 __func__
, left
->u
.unary_expression
.u
.string
);
1117 fprintf(fd
, "[error] %s: missing size attribute\n", __func__
);
1120 if (!has_alignment
) {
1121 if (size
% CHAR_BIT
) {
1122 /* bit-packed alignment */
1125 /* byte-packed alignment */
1126 alignment
= CHAR_BIT
;
1129 integer_declaration
= integer_declaration_new(size
,
1130 byte_order
, signedness
, alignment
);
1131 return &integer_declaration
->p
;
1135 struct declaration
*ctf_declaration_floating_point_visit(FILE *fd
, int depth
,
1136 struct cds_list_head
*expressions
,
1137 struct ctf_trace
*trace
)
1139 struct ctf_node
*expression
;
1140 uint64_t alignment
, exp_dig
, mant_dig
, byte_order
= trace
->byte_order
;
1141 int has_alignment
= 0, has_exp_dig
= 0, has_mant_dig
= 0;
1142 struct declaration_float
*float_declaration
;
1144 cds_list_for_each_entry(expression
, expressions
, siblings
) {
1145 struct ctf_node
*left
, *right
;
1147 left
= _cds_list_first_entry(&expression
->u
.ctf_expression
.left
, struct ctf_node
, siblings
);
1148 right
= _cds_list_first_entry(&expression
->u
.ctf_expression
.right
, struct ctf_node
, siblings
);
1149 assert(left
->u
.unary_expression
.type
== UNARY_STRING
);
1150 if (!strcmp(left
->u
.unary_expression
.u
.string
, "byte_order")) {
1151 byte_order
= get_byte_order(fd
, depth
, right
, trace
);
1154 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "exp_dig")) {
1155 if (right
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
1156 fprintf(fd
, "[error] %s: exp_dig: expecting unsigned constant\n",
1160 exp_dig
= right
->u
.unary_expression
.u
.unsigned_constant
;
1162 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "mant_dig")) {
1163 if (right
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
1164 fprintf(fd
, "[error] %s: mant_dig: expecting unsigned constant\n",
1168 mant_dig
= right
->u
.unary_expression
.u
.unsigned_constant
;
1170 } else if (!strcmp(left
->u
.unary_expression
.u
.string
, "align")) {
1171 if (right
->u
.unary_expression
.type
!= UNARY_UNSIGNED_CONSTANT
) {
1172 fprintf(fd
, "[error] %s: align: expecting unsigned constant\n",
1176 alignment
= right
->u
.unary_expression
.u
.unsigned_constant
;
1177 /* Make sure alignment is a power of two */
1178 if (alignment
== 0 || (alignment
& (alignment
- 1)) != 0) {
1179 fprintf(fd
, "[error] %s: align: expecting power of two\n",
1185 fprintf(fd
, "[error] %s: unknown attribute name %s\n",
1186 __func__
, left
->u
.unary_expression
.u
.string
);
1190 if (!has_mant_dig
) {
1191 fprintf(fd
, "[error] %s: missing mant_dig attribute\n", __func__
);
1195 fprintf(fd
, "[error] %s: missing exp_dig attribute\n", __func__
);
1198 if (!has_alignment
) {
1199 if ((mant_dig
+ exp_dig
) % CHAR_BIT
) {
1200 /* bit-packed alignment */
1203 /* byte-packed alignment */
1204 alignment
= CHAR_BIT
;
1207 float_declaration
= float_declaration_new(mant_dig
, exp_dig
,
1208 byte_order
, alignment
);
1209 return &float_declaration
->p
;
1213 struct declaration
*ctf_declaration_string_visit(FILE *fd
, int depth
,
1214 struct cds_list_head
*expressions
,
1215 struct ctf_trace
*trace
)
1217 struct ctf_node
*expression
;
1218 const char *encoding_c
= NULL
;
1219 enum ctf_string_encoding encoding
= CTF_STRING_UTF8
;
1220 struct declaration_string
*string_declaration
;
1222 cds_list_for_each_entry(expression
, expressions
, siblings
) {
1223 struct ctf_node
*left
, *right
;
1225 left
= _cds_list_first_entry(&expression
->u
.ctf_expression
.left
, struct ctf_node
, siblings
);
1226 right
= _cds_list_first_entry(&expression
->u
.ctf_expression
.right
, struct ctf_node
, siblings
);
1227 assert(left
->u
.unary_expression
.type
== UNARY_STRING
);
1228 if (!strcmp(left
->u
.unary_expression
.u
.string
, "encoding")) {
1229 if (right
->u
.unary_expression
.type
!= UNARY_STRING
) {
1230 fprintf(fd
, "[error] %s: encoding: expecting string\n",
1234 encoding_c
= right
->u
.unary_expression
.u
.string
;
1236 fprintf(fd
, "[error] %s: unknown attribute name %s\n",
1237 __func__
, left
->u
.unary_expression
.u
.string
);
1241 if (encoding_c
&& !strcmp(encoding_c
, "ASCII"))
1242 encoding
= CTF_STRING_ASCII
;
1243 string_declaration
= string_declaration_new(encoding
);
1244 return &string_declaration
->p
;
1249 struct declaration
*ctf_type_specifier_list_visit(FILE *fd
,
1250 int depth
, struct ctf_node
*type_specifier_list
,
1251 struct declaration_scope
*declaration_scope
,
1252 struct ctf_trace
*trace
)
1254 struct ctf_node
*first
;
1255 struct ctf_node
*node
;
1257 assert(type_specifier_list
->type
== NODE_TYPE_SPECIFIER_LIST
);
1259 first
= _cds_list_first_entry(&type_specifier_list
->u
.type_specifier_list
.head
, struct ctf_node
, siblings
);
1261 assert(first
->type
== NODE_TYPE_SPECIFIER
);
1263 node
= first
->u
.type_specifier
.node
;
1265 switch (first
->u
.type_specifier
.type
) {
1266 case TYPESPEC_FLOATING_POINT
:
1267 return ctf_declaration_floating_point_visit(fd
, depth
,
1268 &node
->u
.floating_point
.expressions
, trace
);
1269 case TYPESPEC_INTEGER
:
1270 return ctf_declaration_integer_visit(fd
, depth
,
1271 &node
->u
.integer
.expressions
, trace
);
1272 case TYPESPEC_STRING
:
1273 return ctf_declaration_string_visit(fd
, depth
,
1274 &node
->u
.string
.expressions
, trace
);
1275 case TYPESPEC_STRUCT
:
1276 return ctf_declaration_struct_visit(fd
, depth
,
1277 node
->u
._struct
.name
,
1278 &node
->u
._struct
.declaration_list
,
1279 node
->u
._struct
.has_body
,
1280 &node
->u
._struct
.min_align
,
1283 case TYPESPEC_VARIANT
:
1284 return ctf_declaration_variant_visit(fd
, depth
,
1285 node
->u
.variant
.name
,
1286 node
->u
.variant
.choice
,
1287 &node
->u
.variant
.declaration_list
,
1288 node
->u
.variant
.has_body
,
1292 return ctf_declaration_enum_visit(fd
, depth
,
1293 node
->u
._enum
.enum_id
,
1294 node
->u
._enum
.container_type
,
1295 &node
->u
._enum
.enumerator_list
,
1296 node
->u
._enum
.has_body
,
1302 case TYPESPEC_SHORT
:
1305 case TYPESPEC_FLOAT
:
1306 case TYPESPEC_DOUBLE
:
1307 case TYPESPEC_SIGNED
:
1308 case TYPESPEC_UNSIGNED
:
1310 case TYPESPEC_COMPLEX
:
1311 case TYPESPEC_IMAGINARY
:
1312 case TYPESPEC_CONST
:
1313 case TYPESPEC_ID_TYPE
:
1314 return ctf_declaration_type_specifier_visit(fd
, depth
,
1315 type_specifier_list
, declaration_scope
);
1317 fprintf(fd
, "[error] %s: unexpected node type %d\n", __func__
, (int) first
->u
.type_specifier
.type
);
1323 int ctf_event_declaration_visit(FILE *fd
, int depth
, struct ctf_node
*node
, struct ctf_event
*event
, struct ctf_trace
*trace
)
1327 switch (node
->type
) {
1329 ret
= ctf_typedef_visit(fd
, depth
+ 1,
1330 event
->declaration_scope
,
1331 node
->u
._typedef
.type_specifier_list
,
1332 &node
->u
._typedef
.type_declarators
,
1337 case NODE_TYPEALIAS
:
1338 ret
= ctf_typealias_visit(fd
, depth
+ 1,
1339 event
->declaration_scope
,
1340 node
->u
.typealias
.target
, node
->u
.typealias
.alias
,
1345 case NODE_CTF_EXPRESSION
:
1349 left
= concatenate_unary_strings(&node
->u
.ctf_expression
.left
);
1350 if (!strcmp(left
, "name")) {
1353 if (CTF_EVENT_FIELD_IS_SET(event
, name
)) {
1354 fprintf(fd
, "[error] %s: name already declared in event declaration\n", __func__
);
1358 right
= concatenate_unary_strings(&node
->u
.ctf_expression
.right
);
1360 fprintf(fd
, "[error] %s: unexpected unary expression for event name\n", __func__
);
1364 event
->name
= g_quark_from_string(right
);
1366 CTF_EVENT_SET_FIELD(event
, name
);
1367 } else if (!strcmp(left
, "id")) {
1368 if (CTF_EVENT_FIELD_IS_SET(event
, id
)) {
1369 fprintf(fd
, "[error] %s: id already declared in event declaration\n", __func__
);
1373 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &event
->id
);
1375 fprintf(fd
, "[error] %s: unexpected unary expression for event id\n", __func__
);
1379 CTF_EVENT_SET_FIELD(event
, id
);
1380 } else if (!strcmp(left
, "stream_id")) {
1381 if (CTF_EVENT_FIELD_IS_SET(event
, stream_id
)) {
1382 fprintf(fd
, "[error] %s: stream_id already declared in event declaration\n", __func__
);
1386 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &event
->stream_id
);
1388 fprintf(fd
, "[error] %s: unexpected unary expression for event stream_id\n", __func__
);
1392 event
->stream
= trace_stream_lookup(trace
, event
->stream_id
);
1393 if (!event
->stream
) {
1394 fprintf(fd
, "[error] %s: stream id %" PRIu64
" cannot be found\n", __func__
, event
->stream_id
);
1398 CTF_EVENT_SET_FIELD(event
, stream_id
);
1399 } else if (!strcmp(left
, "context")) {
1400 struct declaration
*declaration
;
1402 if (event
->context_decl
) {
1403 fprintf(fd
, "[error] %s: context already declared in event declaration\n", __func__
);
1407 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1408 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1409 struct ctf_node
, siblings
),
1410 event
->declaration_scope
, trace
);
1415 if (declaration
->id
!= CTF_TYPE_STRUCT
) {
1419 event
->context_decl
= container_of(declaration
, struct declaration_struct
, p
);
1420 } else if (!strcmp(left
, "fields")) {
1421 struct declaration
*declaration
;
1423 if (event
->fields_decl
) {
1424 fprintf(fd
, "[error] %s: fields already declared in event declaration\n", __func__
);
1428 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1429 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1430 struct ctf_node
, siblings
),
1431 event
->declaration_scope
, trace
);
1436 if (declaration
->id
!= CTF_TYPE_STRUCT
) {
1440 event
->fields_decl
= container_of(declaration
, struct declaration_struct
, p
);
1448 /* TODO: declaration specifier should be added. */
1455 int ctf_event_visit(FILE *fd
, int depth
, struct ctf_node
*node
,
1456 struct declaration_scope
*parent_declaration_scope
, struct ctf_trace
*trace
)
1459 struct ctf_node
*iter
;
1460 struct ctf_event
*event
;
1461 struct definition_scope
*parent_def_scope
;
1463 event
= g_new0(struct ctf_event
, 1);
1464 event
->declaration_scope
= new_declaration_scope(parent_declaration_scope
);
1465 cds_list_for_each_entry(iter
, &node
->u
.event
.declaration_list
, siblings
) {
1466 ret
= ctf_event_declaration_visit(fd
, depth
+ 1, iter
, event
, trace
);
1470 if (!CTF_EVENT_FIELD_IS_SET(event
, name
)) {
1472 fprintf(fd
, "[error] %s: missing name field in event declaration\n", __func__
);
1475 if (!CTF_EVENT_FIELD_IS_SET(event
, stream_id
)) {
1476 /* Allow missing stream_id if there is only a single stream */
1477 switch (trace
->streams
->len
) {
1478 case 0: /* Create stream if there was none. */
1479 ret
= ctf_stream_visit(fd
, depth
, NULL
, trace
->root_declaration_scope
, trace
);
1484 event
->stream_id
= 0;
1485 event
->stream
= trace_stream_lookup(trace
, event
->stream_id
);
1489 fprintf(fd
, "[error] %s: missing stream_id field in event declaration\n", __func__
);
1493 /* Allow only one event without id per stream */
1494 if (!CTF_EVENT_FIELD_IS_SET(event
, id
)
1495 && event
->stream
->events_by_id
->len
!= 0) {
1497 fprintf(fd
, "[error] %s: missing id field in event declaration\n", __func__
);
1500 if (event
->stream
->events_by_id
->len
<= event
->id
)
1501 g_ptr_array_set_size(event
->stream
->events_by_id
, event
->id
+ 1);
1502 g_ptr_array_index(event
->stream
->events_by_id
, event
->id
) = event
;
1503 g_hash_table_insert(event
->stream
->event_quark_to_id
,
1504 (gpointer
)(unsigned long) event
->name
,
1506 parent_def_scope
= event
->stream
->definition_scope
;
1507 if (event
->context_decl
) {
1510 event
->context_decl
->p
.definition_new(&event
->context_decl
->p
,
1511 parent_def_scope
, 0, 0),
1512 struct definition_struct
, p
);
1513 set_dynamic_definition_scope(&event
->context
->p
,
1514 event
->context
->scope
,
1516 parent_def_scope
= event
->context
->scope
;
1517 declaration_unref(&event
->context_decl
->p
);
1519 if (event
->fields_decl
) {
1522 event
->fields_decl
->p
.definition_new(&event
->fields_decl
->p
,
1523 parent_def_scope
, 0, 0),
1524 struct definition_struct
, p
);
1525 set_dynamic_definition_scope(&event
->fields
->p
,
1526 event
->fields
->scope
,
1528 parent_def_scope
= event
->fields
->scope
;
1529 declaration_unref(&event
->fields_decl
->p
);
1534 declaration_unref(&event
->fields_decl
->p
);
1535 declaration_unref(&event
->context_decl
->p
);
1536 free_declaration_scope(event
->declaration_scope
);
1543 int ctf_stream_declaration_visit(FILE *fd
, int depth
, struct ctf_node
*node
, struct ctf_stream_class
*stream
, struct ctf_trace
*trace
)
1547 switch (node
->type
) {
1549 ret
= ctf_typedef_visit(fd
, depth
+ 1,
1550 stream
->declaration_scope
,
1551 node
->u
._typedef
.type_specifier_list
,
1552 &node
->u
._typedef
.type_declarators
,
1557 case NODE_TYPEALIAS
:
1558 ret
= ctf_typealias_visit(fd
, depth
+ 1,
1559 stream
->declaration_scope
,
1560 node
->u
.typealias
.target
, node
->u
.typealias
.alias
,
1565 case NODE_CTF_EXPRESSION
:
1569 left
= concatenate_unary_strings(&node
->u
.ctf_expression
.left
);
1570 if (!strcmp(left
, "id")) {
1571 if (CTF_STREAM_FIELD_IS_SET(stream
, stream_id
)) {
1572 fprintf(fd
, "[error] %s: id already declared in stream declaration\n", __func__
);
1576 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &stream
->stream_id
);
1578 fprintf(fd
, "[error] %s: unexpected unary expression for stream id\n", __func__
);
1582 CTF_STREAM_SET_FIELD(stream
, stream_id
);
1583 } else if (!strcmp(left
, "event.header")) {
1584 struct declaration
*declaration
;
1586 if (stream
->event_header_decl
) {
1587 fprintf(fd
, "[error] %s: event.header already declared in stream declaration\n", __func__
);
1591 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1592 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1593 struct ctf_node
, siblings
),
1594 stream
->declaration_scope
, trace
);
1599 if (declaration
->id
!= CTF_TYPE_STRUCT
) {
1603 stream
->event_header_decl
= container_of(declaration
, struct declaration_struct
, p
);
1604 } else if (!strcmp(left
, "event.context")) {
1605 struct declaration
*declaration
;
1607 if (stream
->event_context_decl
) {
1608 fprintf(fd
, "[error] %s: event.context already declared in stream declaration\n", __func__
);
1612 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1613 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1614 struct ctf_node
, siblings
),
1615 stream
->declaration_scope
, trace
);
1620 if (declaration
->id
!= CTF_TYPE_STRUCT
) {
1624 stream
->event_context_decl
= container_of(declaration
, struct declaration_struct
, p
);
1625 } else if (!strcmp(left
, "packet.context")) {
1626 struct declaration
*declaration
;
1628 if (stream
->packet_context_decl
) {
1629 fprintf(fd
, "[error] %s: packet.context already declared in stream declaration\n", __func__
);
1633 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1634 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1635 struct ctf_node
, siblings
),
1636 stream
->declaration_scope
, trace
);
1641 if (declaration
->id
!= CTF_TYPE_STRUCT
) {
1645 stream
->packet_context_decl
= container_of(declaration
, struct declaration_struct
, p
);
1653 /* TODO: declaration specifier should be added. */
1660 int ctf_stream_visit(FILE *fd
, int depth
, struct ctf_node
*node
,
1661 struct declaration_scope
*parent_declaration_scope
, struct ctf_trace
*trace
)
1664 struct ctf_node
*iter
;
1665 struct ctf_stream_class
*stream
;
1666 struct definition_scope
*parent_def_scope
;
1668 stream
= g_new0(struct ctf_stream_class
, 1);
1669 stream
->declaration_scope
= new_declaration_scope(parent_declaration_scope
);
1670 stream
->events_by_id
= g_ptr_array_new();
1671 stream
->event_quark_to_id
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
1672 stream
->files
= g_ptr_array_new();
1674 cds_list_for_each_entry(iter
, &node
->u
.stream
.declaration_list
, siblings
) {
1675 ret
= ctf_stream_declaration_visit(fd
, depth
+ 1, iter
, stream
, trace
);
1680 if (CTF_STREAM_FIELD_IS_SET(stream
, stream_id
)) {
1681 /* check that packet header has stream_id field. */
1682 if (!trace
->packet_header_decl
1683 || struct_declaration_lookup_field_index(trace
->packet_header_decl
, g_quark_from_static_string("stream_id")) < 0) {
1685 fprintf(fd
, "[error] %s: missing stream_id field in packet header declaration, but stream_id attribute is declared for stream.\n", __func__
);
1689 /* Allow only one id-less stream */
1690 if (trace
->streams
->len
!= 0) {
1692 fprintf(fd
, "[error] %s: missing id field in stream declaration\n", __func__
);
1695 stream
->stream_id
= 0;
1697 if (trace
->streams
->len
<= stream
->stream_id
)
1698 g_ptr_array_set_size(trace
->streams
, stream
->stream_id
+ 1);
1699 g_ptr_array_index(trace
->streams
, stream
->stream_id
) = stream
;
1701 parent_def_scope
= trace
->definition_scope
;
1702 if (stream
->packet_context_decl
) {
1703 stream
->packet_context
=
1705 stream
->packet_context_decl
->p
.definition_new(&stream
->packet_context_decl
->p
,
1706 parent_def_scope
, 0, 0),
1707 struct definition_struct
, p
);
1708 set_dynamic_definition_scope(&stream
->packet_context
->p
,
1709 stream
->packet_context
->scope
,
1710 "stream.packet.context");
1711 parent_def_scope
= stream
->packet_context
->scope
;
1712 declaration_unref(&stream
->packet_context_decl
->p
);
1714 if (stream
->event_header_decl
) {
1715 stream
->event_header
=
1717 stream
->event_header_decl
->p
.definition_new(&stream
->event_header_decl
->p
,
1718 parent_def_scope
, 0, 0),
1719 struct definition_struct
, p
);
1720 set_dynamic_definition_scope(&stream
->event_header
->p
,
1721 stream
->event_header
->scope
,
1722 "stream.event.header");
1723 parent_def_scope
= stream
->event_header
->scope
;
1724 declaration_unref(&stream
->event_header_decl
->p
);
1726 if (stream
->event_context_decl
) {
1727 stream
->event_context
=
1729 stream
->event_context_decl
->p
.definition_new(&stream
->event_context_decl
->p
,
1730 parent_def_scope
, 0, 0),
1731 struct definition_struct
, p
);
1732 set_dynamic_definition_scope(&stream
->event_context
->p
,
1733 stream
->event_context
->scope
,
1734 "stream.event.context");
1735 parent_def_scope
= stream
->event_context
->scope
;
1736 declaration_unref(&stream
->event_context_decl
->p
);
1738 stream
->definition_scope
= parent_def_scope
;
1743 declaration_unref(&stream
->event_header_decl
->p
);
1744 declaration_unref(&stream
->event_context_decl
->p
);
1745 declaration_unref(&stream
->packet_context_decl
->p
);
1746 g_ptr_array_free(stream
->files
, TRUE
);
1747 g_ptr_array_free(stream
->events_by_id
, TRUE
);
1748 g_hash_table_destroy(stream
->event_quark_to_id
);
1749 free_declaration_scope(stream
->declaration_scope
);
1755 int ctf_trace_declaration_visit(FILE *fd
, int depth
, struct ctf_node
*node
, struct ctf_trace
*trace
)
1759 switch (node
->type
) {
1761 ret
= ctf_typedef_visit(fd
, depth
+ 1,
1762 trace
->declaration_scope
,
1763 node
->u
._typedef
.type_specifier_list
,
1764 &node
->u
._typedef
.type_declarators
,
1769 case NODE_TYPEALIAS
:
1770 ret
= ctf_typealias_visit(fd
, depth
+ 1,
1771 trace
->declaration_scope
,
1772 node
->u
.typealias
.target
, node
->u
.typealias
.alias
,
1777 case NODE_CTF_EXPRESSION
:
1781 left
= concatenate_unary_strings(&node
->u
.ctf_expression
.left
);
1782 if (!strcmp(left
, "major")) {
1783 if (CTF_TRACE_FIELD_IS_SET(trace
, major
)) {
1784 fprintf(fd
, "[error] %s: major already declared in trace declaration\n", __func__
);
1788 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &trace
->major
);
1790 fprintf(fd
, "[error] %s: unexpected unary expression for trace major number\n", __func__
);
1794 CTF_TRACE_SET_FIELD(trace
, major
);
1795 } else if (!strcmp(left
, "minor")) {
1796 if (CTF_TRACE_FIELD_IS_SET(trace
, minor
)) {
1797 fprintf(fd
, "[error] %s: minor already declared in trace declaration\n", __func__
);
1801 ret
= get_unary_unsigned(&node
->u
.ctf_expression
.right
, &trace
->minor
);
1803 fprintf(fd
, "[error] %s: unexpected unary expression for trace minor number\n", __func__
);
1807 CTF_TRACE_SET_FIELD(trace
, minor
);
1808 } else if (!strcmp(left
, "uuid")) {
1809 if (CTF_TRACE_FIELD_IS_SET(trace
, uuid
)) {
1810 fprintf(fd
, "[error] %s: uuid already declared in trace declaration\n", __func__
);
1814 ret
= get_unary_uuid(&node
->u
.ctf_expression
.right
, &trace
->uuid
);
1816 fprintf(fd
, "[error] %s: unexpected unary expression for trace uuid\n", __func__
);
1820 CTF_TRACE_SET_FIELD(trace
, uuid
);
1821 } else if (!strcmp(left
, "byte_order")) {
1822 struct ctf_node
*right
;
1825 if (CTF_TRACE_FIELD_IS_SET(trace
, byte_order
)) {
1826 fprintf(fd
, "[error] %s: endianness already declared in trace declaration\n", __func__
);
1830 right
= _cds_list_first_entry(&node
->u
.ctf_expression
.right
, struct ctf_node
, siblings
);
1831 byte_order
= get_trace_byte_order(fd
, depth
, right
);
1834 trace
->byte_order
= byte_order
;
1835 CTF_TRACE_SET_FIELD(trace
, byte_order
);
1836 } else if (!strcmp(left
, "packet.header")) {
1837 struct declaration
*declaration
;
1839 if (trace
->packet_header_decl
) {
1840 fprintf(fd
, "[error] %s: packet.header already declared in trace declaration\n", __func__
);
1844 declaration
= ctf_type_specifier_list_visit(fd
, depth
,
1845 _cds_list_first_entry(&node
->u
.ctf_expression
.right
,
1846 struct ctf_node
, siblings
),
1847 trace
->declaration_scope
, trace
);
1852 if (declaration
->id
!= CTF_TYPE_STRUCT
) {
1856 trace
->packet_header_decl
= container_of(declaration
, struct declaration_struct
, p
);
1864 /* TODO: declaration specifier should be added. */
1871 int ctf_trace_visit(FILE *fd
, int depth
, struct ctf_node
*node
, struct ctf_trace
*trace
)
1873 struct definition_scope
*parent_def_scope
;
1875 struct ctf_node
*iter
;
1877 if (trace
->declaration_scope
)
1879 trace
->declaration_scope
= new_declaration_scope(trace
->root_declaration_scope
);
1880 trace
->streams
= g_ptr_array_new();
1881 cds_list_for_each_entry(iter
, &node
->u
.trace
.declaration_list
, siblings
) {
1882 ret
= ctf_trace_declaration_visit(fd
, depth
+ 1, iter
, trace
);
1886 if (!CTF_TRACE_FIELD_IS_SET(trace
, major
)) {
1888 fprintf(fd
, "[error] %s: missing major field in trace declaration\n", __func__
);
1891 if (!CTF_TRACE_FIELD_IS_SET(trace
, minor
)) {
1893 fprintf(fd
, "[error] %s: missing minor field in trace declaration\n", __func__
);
1896 if (!CTF_TRACE_FIELD_IS_SET(trace
, uuid
)) {
1898 fprintf(fd
, "[error] %s: missing uuid field in trace declaration\n", __func__
);
1901 if (!CTF_TRACE_FIELD_IS_SET(trace
, byte_order
)) {
1903 fprintf(fd
, "[error] %s: missing byte_order field in trace declaration\n", __func__
);
1907 parent_def_scope
= NULL
;
1908 if (trace
->packet_header_decl
) {
1909 trace
->packet_header
=
1911 trace
->packet_header_decl
->p
.definition_new(&trace
->packet_header_decl
->p
,
1912 parent_def_scope
, 0, 0),
1913 struct definition_struct
, p
);
1914 set_dynamic_definition_scope(&trace
->packet_header
->p
,
1915 trace
->packet_header
->scope
,
1916 "trace.packet.header");
1917 parent_def_scope
= trace
->packet_header
->scope
;
1918 declaration_unref(&trace
->packet_header_decl
->p
);
1920 trace
->definition_scope
= parent_def_scope
;
1922 if (!CTF_TRACE_FIELD_IS_SET(trace
, byte_order
)) {
1923 /* check that the packet header contains a "magic" field */
1924 if (!trace
->packet_header
1925 || struct_declaration_lookup_field_index(trace
->packet_header_decl
, g_quark_from_static_string("magic")) < 0) {
1927 fprintf(fd
, "[error] %s: missing both byte_order and packet header magic number in trace declaration\n", __func__
);
1928 goto error_free_def
;
1934 definition_unref(&trace
->packet_header
->p
);
1936 g_ptr_array_free(trace
->streams
, TRUE
);
1937 free_declaration_scope(trace
->declaration_scope
);
1942 int ctf_root_declaration_visit(FILE *fd
, int depth
, struct ctf_node
*node
, struct ctf_trace
*trace
)
1946 switch (node
->type
) {
1948 ret
= ctf_typedef_visit(fd
, depth
+ 1,
1949 trace
->root_declaration_scope
,
1950 node
->u
._typedef
.type_specifier_list
,
1951 &node
->u
._typedef
.type_declarators
,
1956 case NODE_TYPEALIAS
:
1957 ret
= ctf_typealias_visit(fd
, depth
+ 1,
1958 trace
->root_declaration_scope
,
1959 node
->u
.typealias
.target
, node
->u
.typealias
.alias
,
1964 case NODE_TYPE_SPECIFIER_LIST
:
1966 struct declaration
*declaration
;
1969 * Just add the type specifier to the root scope
1970 * declaration scope. Release local reference.
1972 declaration
= ctf_type_specifier_list_visit(fd
, depth
+ 1,
1973 node
, trace
->root_declaration_scope
, trace
);
1976 declaration_unref(declaration
);
1986 int ctf_visitor_construct_metadata(FILE *fd
, int depth
, struct ctf_node
*node
,
1987 struct ctf_trace
*trace
, int byte_order
)
1990 struct ctf_node
*iter
;
1992 printf_verbose("CTF visitor: metadata construction... ");
1993 trace
->root_declaration_scope
= new_declaration_scope(NULL
);
1994 trace
->streams
= g_ptr_array_new();
1995 trace
->byte_order
= byte_order
;
1997 switch (node
->type
) {
1999 cds_list_for_each_entry(iter
, &node
->u
.root
.declaration_list
,
2001 ret
= ctf_root_declaration_visit(fd
, depth
+ 1, iter
, trace
);
2003 fprintf(fd
, "[error] %s: root declaration error\n", __func__
);
2007 cds_list_for_each_entry(iter
, &node
->u
.root
.trace
, siblings
) {
2008 ret
= ctf_trace_visit(fd
, depth
+ 1, iter
, trace
);
2010 fprintf(fd
, "[error] %s: trace declaration error\n", __func__
);
2014 if (!trace
->streams
) {
2015 fprintf(fd
, "[error] %s: missing trace declaration\n", __func__
);
2018 cds_list_for_each_entry(iter
, &node
->u
.root
.stream
, siblings
) {
2019 ret
= ctf_stream_visit(fd
, depth
+ 1, iter
,
2020 trace
->root_declaration_scope
, trace
);
2022 fprintf(fd
, "[error] %s: stream declaration error\n", __func__
);
2026 cds_list_for_each_entry(iter
, &node
->u
.root
.event
, siblings
) {
2027 ret
= ctf_event_visit(fd
, depth
+ 1, iter
,
2028 trace
->root_declaration_scope
, trace
);
2030 fprintf(fd
, "[error] %s: event declaration error\n", __func__
);
2037 fprintf(fd
, "[error] %s: unknown node type %d\n", __func__
,
2041 printf_verbose("done.\n");