Work in progress generate io struct
[babeltrace.git] / formats / ctf / metadata / ctf-visitor-generate-io-struct.c
1 /*
2 * ctf-visitor-generate-io-struct.c
3 *
4 * Common Trace Format Metadata Visitor (generate I/O structures).
5 *
6 * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
17 */
18
19 #include <stdio.h>
20 #include <unistd.h>
21 #include <string.h>
22 #include <stdlib.h>
23 #include <assert.h>
24 #include <glib.h>
25 #include <inttypes.h>
26 #include <endian.h>
27 #include <errno.h>
28 #include <babeltrace/list.h>
29 #include <uuid/uuid.h>
30 #include "ctf-scanner.h"
31 #include "ctf-parser.h"
32 #include "ctf-ast.h"
33
34 #define fprintf_dbg(fd, fmt, args...) fprintf(fd, "%s: " fmt, __func__, ## args)
35
36 #define _cds_list_first_entry(ptr, type, member) \
37 cds_list_entry((ptr)->next, type, member)
38
39 static
40 struct declaration *ctf_declaration_specifier_visit(FILE *fd,
41 int depth, struct cds_list_head *head,
42 struct declaration_scope *declaration_scope);
43
44 /*
45 * String returned must be freed by the caller using g_free.
46 */
47 static
48 char *concatenate_unary_strings(struct cds_list_head *head)
49 {
50 struct ctf_node *node;
51 GString *str;
52 int i = 0;
53
54 str = g_string_new();
55 cds_list_for_each_entry(node, head, siblings) {
56 char *src_string;
57
58 assert(node->type == NODE_UNARY_EXPRESSION);
59 assert(node->u.unary_expression.type == UNARY_STRING);
60 assert((node->u.unary_expression.link == UNARY_LINK_UNKNOWN)
61 ^ (i != 0))
62 switch (node->u.unary_expression.link) {
63 case UNARY_DOTLINK:
64 g_string_append(str, ".")
65 break;
66 case UNARY_ARROWLINK:
67 g_string_append(str, "->")
68 break;
69 case UNARY_DOTDOTDOT:
70 g_string_append(str, "...")
71 break;
72 }
73 src_string = u.unary_expression.u.string;
74 g_string_append(str, src_string);
75 i++;
76 }
77 return g_string_free(str, FALSE);
78 }
79
80 static
81 int get_unary_unsigned(struct cds_list_head *head, uint64_t *value)
82 {
83 struct ctf_node *node;
84 int i = 0;
85
86 cds_list_for_each_entry(node, head, siblings) {
87 assert(node->type == NODE_UNARY_EXPRESSION);
88 assert(node->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT);
89 assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
90 assert(i == 0);
91 *value = node->u.unary_expression.unsigned_constant
92 i++;
93 }
94 return 0;
95 }
96
97 static
98 int get_unary_uuid(struct cds_list_head *head, uuid_t *uuid)
99 {
100 struct ctf_node *node;
101 int i = 0;
102 int ret = -1;
103
104 cds_list_for_each_entry(node, head, siblings) {
105 const char *src_string;
106
107 assert(node->type == NODE_UNARY_EXPRESSION);
108 assert(node->u.unary_expression.type == UNARY_STRING);
109 assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
110 assert(i == 0);
111 src_string = u.unary_expression.u.string;
112 ret = uuid_parse(u.unary_expression.u.string, *uuid);
113 }
114 return ret;
115 }
116
117 static
118 struct ctf_stream *trace_stream_lookup(struct ctf_trace *trace, uint64_t stream_id)
119 {
120 if (trace->streams->len <= stream_id)
121 return NULL;
122 return g_ptr_array_index(trace->streams, stream_id);
123 }
124
125 static
126 void visit_declaration_specifier(struct cds_list_head *declaration_specifier, GString *str)
127 {
128 struct ctf_node *iter;
129 int alias_item_nr = 0;
130 int err;
131
132 cds_list_for_each_entry(iter, declaration_specifier, siblings) {
133 if (alias_item_nr != 0)
134 g_string_append(str, " ");
135 alias_item_nr++;
136
137 switch (iter->type) {
138 case NODE_TYPE_SPECIFIER:
139 switch (iter->u.type_specifier.type) {
140 case TYPESPEC_VOID:
141 g_string_append(str, "void");
142 break;
143 case TYPESPEC_CHAR:
144 g_string_append(str, "char");
145 break;
146 case TYPESPEC_SHORT:
147 g_string_append(str, "short");
148 break;
149 case TYPESPEC_INT:
150 g_string_append(str, "int");
151 break;
152 case TYPESPEC_LONG:
153 g_string_append(str, "long");
154 break;
155 case TYPESPEC_FLOAT:
156 g_string_append(str, "float");
157 break;
158 case TYPESPEC_DOUBLE:
159 g_string_append(str, "double");
160 break;
161 case TYPESPEC_SIGNED:
162 g_string_append(str, "signed");
163 break;
164 case TYPESPEC_UNSIGNED:
165 g_string_append(str, "unsigned");
166 break;
167 case TYPESPEC_BOOL:
168 g_string_append(str, "bool");
169 break;
170 case TYPESPEC_COMPLEX:
171 g_string_append(str, "_Complex");
172 break;
173 case TYPESPEC_IMAGINARY:
174 g_string_append(str, "_Imaginary");
175 break;
176 case TYPESPEC_CONST:
177 g_string_append(str, "const");
178 break;
179 case TYPESPEC_ID_TYPE:
180 if (iter->u.type_specifier.id_type)
181 g_string_append(str, iter->u.type_specifier.id_type);
182 break;
183 default:
184 fprintf(stderr, "[error] %s: unknown specifier\n", __func__);
185 err = -EINVAL;
186 goto error;
187 }
188 break;
189 case NODE_ENUM:
190 if (!iter->u._enum.enum_id) {
191 fprintf(stderr, "[error] %s: unexpected empty enum ID\n", __func__);
192 err = -EINVAL;
193 goto error;
194 }
195 g_string_append(str, "enum ");
196 g_string_append(str, iter->u._enum.enum_id);
197 break;
198 case NODE_VARIANT:
199 if (!iter->u.variant.name) {
200 fprintf(stderr, "[error] %s: unexpected empty variant name\n", __func__);
201 err = -EINVAL;
202 goto error;
203 }
204 g_string_append(str, "variant ");
205 g_string_append(str, iter->u.variant.name);
206 break;
207 case NODE_STRUCT:
208 if (!iter->u._struct.name) {
209 fprintf(stderr, "[error] %s: unexpected empty variant name\n", __func__);
210 err = -EINVAL;
211 goto error;
212 }
213 g_string_append(str, "struct ");
214 g_string_append(str, iter->u._struct.name);
215 break;
216 default:
217 fprintf(stderr, "[error] %s: unexpected node type %d\n", __func__, (int) iter->type);
218 err = -EINVAL;
219 goto error;
220 }
221 }
222 return 0;
223 error:
224 return err;
225 }
226
227 static
228 GQuark create_typealias_identifier(int fd, int depth,
229 struct cds_list_head *declaration_specifier,
230 struct ctf_node *node_type_declarator)
231 {
232 GString *str;
233 const char *str_c;
234 GQuark alias_q;
235 int ret;
236
237 str = g_string_new();
238 ret = visit_declaration_specifier(declaration_specifier, str);
239 if (ret) {
240 g_string_free(str, TRUE);
241 return 0;
242 }
243 cds_list_for_each_entry(iter, &node_type_declarator->u.type_declarator.pointers, siblings) {
244 g_string_append(str, " *");
245 if (iter->u.pointer.const_qualifier)
246 g_string_append(str, " const");
247 }
248 str_c = g_string_free(str, FALSE);
249 alias_q = g_quark_from_string(str_c);
250 g_free(str_c);
251 return alias_q;
252 }
253
254 static
255 struct declaration *ctf_type_declarator_visit(int fd, int depth,
256 struct cds_list_head *declaration_specifier,
257 GQuark *field_name,
258 struct ctf_node *node_type_declarator,
259 struct declaration_scope *declaration_scope,
260 struct declaration *nested_declaration)
261 {
262 /*
263 * Visit type declarator by first taking care of sequence/array
264 * (recursively). Then, when we get to the identifier, take care
265 * of pointers.
266 */
267
268 assert(node_type_declarator->u.type_declarator.type != TYPEDEC_UNKNOWN);
269
270 /* TODO: gcc bitfields not supported yet. */
271 if (node_type_declarator->u.type_declarator.bitfield_len != NULL) {
272 fprintf(stderr, "[error] %s: gcc bitfields are not supported yet.\n", __func__);
273 return NULL;
274 }
275
276 if (!nested_declaration) {
277 if (!cds_list_empty(&node_type_declarator->u.type_declarator.pointers)) {
278 GQuark alias_q;
279
280 /*
281 * If we have a pointer declarator, it _has_ to be present in
282 * the typealiases (else fail).
283 */
284 alias_q = create_typealias_identifier(fd, depth,
285 declaration_specifier, node_type_declarator);
286 nested_declaration = lookup_declaration(alias_q, declaration_scope);
287 if (!nested_declaration) {
288 fprintf(stderr, "[error] %s: cannot find typealias \"%s\".\n", __func__, g_quark_to_string(alias_q));
289 return NULL;
290 }
291 } else {
292 nested_declaration = /* parse declaration_specifier */;
293 }
294 }
295
296 if (node_type_declarator->u.type_declarator.type == TYPEDEC_ID) {
297 if (node_type_declarator->u.type_declarator.u.id)
298 *field_name = g_quark_from_string(node_type_declarator->u.type_declarator.u.id);
299 else
300 *field_name = 0;
301 return nested_declaration;
302 } else {
303 struct declaration *declaration;
304 struct node *length;
305
306 /* TYPEDEC_NESTED */
307
308 /* create array/sequence, pass nested_declaration as child. */
309 length = node_type_declarator->u.type_declarator.u.nested.length;
310 if (length) {
311 switch (length->type) {
312 case NODE_UNARY_EXPRESSION:
313 /* Array */
314 /* TODO */
315 .............
316 declaration = /* create array */;
317 break;
318 case NODE_TYPE_SPECIFIER:
319 /* Sequence */
320 declaration = /* create sequence */;
321 break;
322 default:
323 assert(0);
324 }
325 }
326
327 /* Pass it as content of outer container */
328 declaration = ctf_type_declarator_visit(fd, depth,
329 declaration_specifier, field_name,
330 node_type_declarator->u.type_declarator.u.nested.type_declarator,
331 declaration_scope, declaration);
332 return declaration;
333 }
334 }
335
336 static
337 int ctf_struct_type_declarators_visit(int fd, int depth,
338 struct declaration_struct *struct_declaration,
339 struct cds_list_head *declaration_specifier,
340 struct cds_list_head *type_declarators,
341 struct declaration_scope *declaration_scope)
342 {
343 struct ctf_node *iter;
344 GQuark field_name;
345
346 cds_list_for_each_entry(iter, type_declarators, siblings) {
347 struct declaration *field_declaration;
348
349 field_declaration = ctf_type_declarator_visit(fd, depth,
350 declaration_specifier,
351 &field_name, iter,
352 struct_declaration->scope,
353 NULL);
354 struct_declaration_add_field(struct_declaration,
355 g_quark_to_string(field_name),
356 field_declaration);
357 }
358 return 0;
359 }
360
361 static
362 int ctf_variant_type_declarators_visit(int fd, int depth,
363 struct declaration_variant *variant_declaration,
364 struct cds_list_head *declaration_specifier,
365 struct cds_list_head *type_declarators,
366 struct declaration_scope *declaration_scope)
367 {
368 struct ctf_node *iter;
369 GQuark field_name;
370
371 cds_list_for_each_entry(iter, type_declarators, siblings) {
372 struct declaration *field_declaration;
373
374 field_declaration = ctf_type_declarator_visit(fd, depth,
375 declaration_specifier,
376 &field_name, iter,
377 variant_declaration->scope,
378 NULL);
379 variant_declaration_add_field(variant_declaration,
380 g_quark_to_string(field_name),
381 field_declaration);
382 }
383 return 0;
384 }
385
386 static
387 int ctf_typedef_visit(int fd, int depth, struct declaration_scope *scope,
388 struct cds_list_head *declaration_specifier,
389 struct cds_list_head *type_declarators)
390 {
391 struct ctf_node *iter;
392 GQuark identifier;
393
394 cds_list_for_each_entry(iter, type_declarators, siblings) {
395 struct declaration *type_declaration;
396 int ret;
397
398 type_declaration = ctf_type_declarator_visit(fd, depth,
399 declaration_specifier,
400 &identifier, iter,
401 scope, NULL);
402 ret = register_declaration(identifier, type_declaration, scope);
403 if (ret) {
404 type_declaration->declaration_free(type_declaration);
405 return ret;
406 }
407 }
408 return 0;
409 }
410
411 static
412 int ctf_typealias_visit(int fd, int depth, struct declaration_scope *scope,
413 struct ctf_node *target, struct ctf_node *alias)
414 {
415 struct declaration *type_declaration;
416 struct ctf_node *iter, *node;
417 GQuark dummy_id;
418 GQuark alias_q;
419
420 /* See ctf_visitor_type_declarator() in the semantic validator. */
421
422 /*
423 * Create target type declaration.
424 */
425
426 type_declaration = ctf_type_declarator_visit(fd, depth,
427 &target->u.typealias_target.declaration_specifier,
428 &dummy_id, &target->u.typealias_target.type_declarators,
429 scope, NULL);
430 if (!type_declaration) {
431 fprintf(stderr, "[error] %s: problem creating type declaration\n", __func__);
432 err = -EINVAL;
433 goto error;
434 }
435 /*
436 * The semantic validator does not check whether the target is
437 * abstract or not (if it has an identifier). Check it here.
438 */
439 if (dummy_id != 0) {
440 fprintf(stderr, "[error] %s: expecting empty identifier\n", __func__);
441 err = -EINVAL;
442 goto error;
443 }
444 /*
445 * Create alias identifier.
446 */
447
448 node = _cds_list_first_entry(&alias->u.typealias_alias.type_declarators,
449 struct node, siblings);
450 alias_q = create_typealias_identifier(fd, depth,
451 &alias->u.typealias_alias.declaration_specifier, node);
452 ret = register_declaration(alias_q, type_declaration, scope);
453 if (ret)
454 goto error;
455 return 0;
456
457 error:
458 type_declaration->declaration_free(type_declaration);
459 return ret;
460 }
461
462 static
463 int ctf_struct_declaration_list_visit(int fd, int depth,
464 struct ctf_node *iter, struct declaration_struct *struct_declaration)
465 {
466 struct declaration *declaration;
467 int ret;
468
469 switch (iter->type) {
470 case NODE_TYPEDEF:
471 /* For each declarator, declare type and add type to struct declaration scope */
472 ret = ctf_typedef_visit(fd, depth,
473 struct_declaration->scope,
474 &iter->u._typedef.declaration_specifier,
475 &iter->u._typedef.type_declarators);
476 if (ret)
477 return ret;
478 break;
479 case NODE_TYPEALIAS:
480 /* Declare type with declarator and add type to struct declaration scope */
481 ret = ctf_typealias_visit(fd, depth,
482 struct_declaration->scope,
483 iter->u.typealias.target,
484 iter->u.typealias.alias);
485 if (ret)
486 return ret;
487 break;
488 case NODE_STRUCT_OR_VARIANT_DECLARATION:
489 /* Add field to structure declaration */
490 ret = ctf_struct_type_declarators_visit(fd, depth,
491 struct_declaration,
492 &iter->u.struct_or_variant_declaration.declaration_specifier,
493 &iter->u.struct_or_variant_declaration.type_declarators);
494 if (ret)
495 return ret;
496 break;
497 default:
498 fprintf(stderr, "[error] %s: unexpected node type %d\n", __func__, (int) iter->type);
499 assert(0);
500 }
501 return 0;
502 }
503
504 static
505 int ctf_variant_declaration_list_visit(int fd, int depth,
506 struct ctf_node *iter, struct declaration_variant *variant_declaration)
507 {
508 struct declaration *declaration;
509 int ret;
510
511 switch (iter->type) {
512 case NODE_TYPEDEF:
513 /* For each declarator, declare type and add type to variant declaration scope */
514 ret = ctf_typedef_visit(fd, depth,
515 variant_declaration->scope,
516 &iter->u._typedef.declaration_specifier,
517 &iter->u._typedef.type_declarators);
518 if (ret)
519 return ret;
520 break;
521 case NODE_TYPEALIAS:
522 /* Declare type with declarator and add type to variant declaration scope */
523 ret = ctf_typealias_visit(fd, depth,
524 variant_declaration->scope,
525 iter->u.typealias.target,
526 iter->u.typealias.alias);
527 if (ret)
528 return ret;
529 break;
530 case NODE_STRUCT_OR_VARIANT_DECLARATION:
531 /* Add field to structure declaration */
532 ret = ctf_variant_type_declarators_visit(fd, depth,
533 variant_declaration,
534 &iter->u.struct_or_variant_declaration.declaration_specifier,
535 &iter->u.struct_or_variant_declaration.type_declarators);
536 if (ret)
537 return ret;
538 break;
539 default:
540 fprintf(stderr, "[error] %s: unexpected node type %d\n", __func__, (int) iter->type);
541 assert(0);
542 }
543 return 0;
544 }
545
546 static
547 struct declaration_struct *ctf_declaration_struct_visit(FILE *fd,
548 int depth, const char *name, struct cds_list_head *declaration_list,
549 int has_body, struct declaration_scope *declaration_scope)
550 {
551 struct declaration *declaration;
552 struct declaration_struct *struct_declaration;
553 struct ctf_node *iter;
554
555 /*
556 * For named struct (without body), lookup in
557 * declaration scope. Don't take reference on struct
558 * declaration: ref is only taken upon definition.
559 */
560 if (!has_body) {
561 assert(name);
562 struct_declaration =
563 lookup_struct_declaration(g_quark_from_string(name),
564 declaration_scope);
565 return struct_declaration;
566 } else {
567 /* For unnamed struct, create type */
568 /* For named struct (with body), create type and add to declaration scope */
569 if (name) {
570 if (lookup_struct_declaration(g_quark_from_string(name),
571 declaration_scope)) {
572
573 fprintf(stderr, "[error] %s: struct %s already declared in scope\n", __func__, name);
574 return NULL;
575 }
576 }
577 struct_declaration = struct_declaration_new(name, declaration_scope);
578 cds_list_for_each_entry(iter, declaration_list, siblings) {
579 ret = ctf_struct_declaration_list_visit(fd, depth + 1, iter, struct_declaration);
580 if (ret)
581 goto error;
582 }
583 if (name) {
584 ret = register_struct_declaration(g_quark_from_string(name),
585 struct_declaration,
586 declaration_scope);
587 assert(!ret);
588 }
589 return struct_declaration;
590 }
591 error:
592 struct_declaration->p.declaration_free(&struct_declaration->p);
593 return NULL;
594 }
595
596 static
597 struct declaration_variant *ctf_declaration_variant_visit(FILE *fd,
598 int depth, const char *name, struct cds_list_head *declaration_list,
599 int has_body, struct declaration_scope *declaration_scope)
600 {
601 struct declaration *declaration;
602 struct declaration_variant *variant_declaration;
603 struct ctf_node *iter;
604
605 /*
606 * For named variant (without body), lookup in
607 * declaration scope. Don't take reference on variant
608 * declaration: ref is only taken upon definition.
609 */
610 if (!has_body) {
611 assert(name);
612 variant_declaration =
613 lookup_variant_declaration(g_quark_from_string(name),
614 declaration_scope);
615 return variant_declaration;
616 } else {
617 /* For unnamed variant, create type */
618 /* For named variant (with body), create type and add to declaration scope */
619 if (name) {
620 if (lookup_variant_declaration(g_quark_from_string(name),
621 declaration_scope)) {
622
623 fprintf(stderr, "[error] %s: variant %s already declared in scope\n", __func__, name);
624 return NULL;
625 }
626 }
627 variant_declaration = variant_declaration_new(name, declaration_scope);
628 cds_list_for_each_entry(iter, declaration_list, siblings) {
629 ret = ctf_variant_declaration_list_visit(fd, depth + 1, iter, variant_declaration);
630 if (ret)
631 goto error;
632 }
633 if (name) {
634 ret = register_variant_declaration(g_quark_from_string(name),
635 variant_declaration,
636 declaration_scope);
637 assert(!ret);
638 }
639 return variant_declaration;
640 }
641 error:
642 variant_declaration->p.declaration_free(&variant_declaration->p);
643 return NULL;
644 }
645
646 static
647 int ctf_enumerator_list_visit(int fd, int depth,
648 struct ctf_node *enumerator,
649 struct declaration_enum *enum_declaration)
650 {
651 /* TODO */
652 ........
653 return 0;
654 }
655
656 static
657 struct declaration *ctf_declaration_enum_visit(int fd, int depth,
658 const char *name,
659 struct ctf_node *container_type,
660 struct cds_list_head *enumerator_list,
661 int has_body)
662 {
663 struct declaration *declaration;
664 struct declaration_enum *enum_declaration;
665 struct declaration_integer *integer_declaration;
666 struct ctf_node *iter;
667
668 /*
669 * For named enum (without body), lookup in
670 * declaration scope. Don't take reference on enum
671 * declaration: ref is only taken upon definition.
672 */
673 if (!has_body) {
674 assert(name);
675 enum_declaration =
676 lookup_enum_declaration(g_quark_from_string(name),
677 declaration_scope);
678 return enum_declaration;
679 } else {
680 /* For unnamed enum, create type */
681 /* For named enum (with body), create type and add to declaration scope */
682 if (name) {
683 if (lookup_enum_declaration(g_quark_from_string(name),
684 declaration_scope)) {
685
686 fprintf(stderr, "[error] %s: enum %s already declared in scope\n", __func__, name);
687 return NULL;
688 }
689 }
690
691 /* TODO CHECK Enumerations need to have their size/type specifier (< >). */
692 integer_declaration = integer_declaration_new(); /* TODO ... */
693 .....
694 enum_declaration = enum_declaration_new(name, integer_declaration);
695 declaration_unref(&integer_declaration->p); /* leave ref to enum */
696 cds_list_for_each_entry(iter, enumerator_list, siblings) {
697 ret = ctf_enumerator_list_visit(fd, depth + 1, iter, enum_declaration);
698 if (ret)
699 goto error;
700 }
701 if (name) {
702 ret = register_enum_declaration(g_quark_from_string(name),
703 enum_declaration,
704 declaration_scope);
705 assert(!ret);
706 }
707 return enum_declaration;
708 }
709 error:
710 enum_declaration->p.declaration_free(&enum_declaration->p);
711 return NULL;
712 }
713
714 static
715 struct declaration *ctf_declaration_type_specifier_visit(int fd, int depth,
716 struct cds_list_head *declaration_specifier,
717 struct declaration_scope *declaration_scope)
718 {
719 GString *str;
720 struct declaration *declaration;
721 const char *str_c;
722
723 str = g_string_new();
724 ret = visit_declaration_specifier(declaration_specifier, str);
725 if (ret)
726 return NULL;
727 str_c = g_string_free(str, FALSE);
728 id_q = g_quark_from_string(str_c);
729 g_free(str_c);
730 declaration = lookup_declaration(id_q, declaration_scope);
731 return declaration;
732 }
733
734 static
735 struct declaration *ctf_declaration_integer_visit(int fd, int depth,
736 struct cds_list_head *expressions)
737 {
738 struct node *expression;
739 uint64_t alignment, size, byte_order = trace->native_bo, signedness = 0;
740 int has_alignment = 0, has_size = 0;
741 struct declaration_integer *integer_declaration;
742
743 cds_list_for_each_entry(expression, expressions, siblings) {
744 struct node *left, *right;
745
746 left = expression->u.ctf_expression.left;
747 right = expression->u.ctf_expression.right;
748 assert(left->u.unary_expression.type == UNARY_STRING);
749 if (!strcmp(left->u.unary_expression.u.string, "signed")) {
750 /* TODO */
751 ...........
752 } else if (!strcmp(left->u.unary_expression.u.string, "byte_order")) {
753
754 } else if (!strcmp(left->u.unary_expression.u.string, "size")) {
755 has_size = 1;
756 } else if (!strcmp(left->u.unary_expression.u.string, "align")) {
757 has_alignment = 1;
758 } else {
759 fprintf(stderr, "[error] %s: unknown attribute name %s\n",
760 __func__, left->u.unary_expression.u.string);
761 return NULL;
762 }
763 }
764 if (!has_alignment) {
765 fprintf(stderr, "[error] %s: missing alignment attribute\n", __func__);
766 return NULL;
767 }
768 if (!has_size) {
769 fprintf(stderr, "[error] %s: missing size attribute\n", __func__);
770 return NULL;
771 }
772 integer_declaration = integer_declaration_new(size,
773 byte_order, signedness, alignment);
774 return &integer_declaration->p;
775 }
776
777 /*
778 * Also add named variant, struct or enum to the current declaration scope.
779 */
780 static
781 struct declaration *ctf_declaration_specifier_visit(FILE *fd,
782 int depth, struct cds_list_head *head,
783 struct declaration_scope *declaration_scope)
784 {
785 struct declaration *declaration;
786 struct node *first;
787
788 first = _cds_list_first_entry(head, struct node, siblings);
789
790 switch (first->type) {
791 case NODE_STRUCT:
792 return ctf_declaration_struct_visit(fd, depth,
793 first->u._struct.name,
794 &first->u._struct.declaration_list,
795 first->u._struct.has_body,
796 declaration_scope);
797 case NODE_VARIANT:
798 return ctf_declaration_variant_visit(fd, depth,
799 first->u.variant.name,
800 &first->u.variant.declaration_list,
801 first->u.variant.has_body,
802 declaration_scope);
803 case NODE_ENUM:
804 return ctf_declaration_enum_visit(fd, depth,
805 first->u._enum.enum_id,
806 first->u._enum.container_type,
807 &first->u._enum.enumerator_list,
808 first->u._enum.has_body);
809 case NODE_INTEGER:
810 return ctf_declaration_integer_visit(fd, depth,
811 &first->u.integer.expressions);
812 case NODE_FLOATING_POINT: /* TODO */
813 return ctf_declaration_floating_point_visit(fd, depth,
814 &first->u.floating_point.expressions);
815 case NODE_STRING: /* TODO */
816 return ctf_declaration_string_visit(fd, depth,
817 &first->u.string.expressions);
818 case NODE_TYPE_SPECIFIER:
819 return ctf_declaration_type_specifier_visit(fd, depth,
820 head, declaration_scope);
821 }
822 }
823
824 static
825 int ctf_event_declaration_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_event *event, struct ctf_trace *trace)
826 {
827 int ret = 0;
828
829 switch (node->type) {
830 case NODE_TYPEDEF:
831 ret = ctf_typedef_visit(fd, depth + 1,
832 &node->u._typedef.declaration_specifier,
833 &node->u._typedef.type_declarators,
834 event->declaration_scope);
835 if (ret)
836 return ret;
837 break;
838 case NODE_TYPEALIAS:
839 ret = ctf_typealias_visit(fd, depth + 1,
840 &node->u.typealias.target, &node->u.typealias.alias
841 event->declaration_scope);
842 if (ret)
843 return ret;
844 break;
845 case NODE_CTF_EXPRESSION:
846 {
847 char *left;
848
849 left = concatenate_unary_strings(&node->u.ctf_expression.left);
850 if (!strcmp(left, "name")) {
851 char *right;
852
853 if (CTF_EVENT_FIELD_IS_SET(event, name))
854 return -EPERM;
855 right = concatenate_unary_strings(&node->u.ctf_expression.right);
856 if (!right) {
857 fprintf(stderr, "[error] %s: unexpected unary expression for event name\n", __func__);
858 return -EINVAL;
859 }
860 event->name = g_quark_from_string(right);
861 g_free(right);
862 CTF_EVENT_SET_FIELD(event, name);
863 } else if (!strcmp(left, "id")) {
864 if (CTF_EVENT_FIELD_IS_SET(event, id))
865 return -EPERM;
866 ret = get_unary_unsigned(&node->u.ctf_expression.right, &event->id);
867 if (ret) {
868 fprintf(stderr, "[error] %s: unexpected unary expression for event id\n", __func__);
869 return -EINVAL;
870 }
871 CTF_EVENT_SET_FIELD(event, id);
872 } else if (!strcmp(left, "stream_id")) {
873 if (CTF_EVENT_FIELD_IS_SET(event, stream_id))
874 return -EPERM;
875 ret = get_unary_unsigned(&node->u.ctf_expression.right, &event->stream_id);
876 if (ret) {
877 fprintf(stderr, "[error] %s: unexpected unary expression for event stream_id\n", __func__);
878 return -EINVAL;
879 }
880 event->stream = trace_stream_lookup(trace, event->stream_id);
881 if (!event->stream) {
882 fprintf(stderr, "[error] %s: stream id %" PRIu64 " cannot be found\n", __func__, event->stream_id);
883 return -EINVAL;
884 }
885 CTF_EVENT_SET_FIELD(event, stream_id);
886 } else if (!strcmp(left, "context")) {
887 struct declaration *declaration;
888
889 if (!event->definition_scope)
890 return -EPERM;
891 declaration = ctf_declaration_specifier_visit(fd, depth,
892 &node->u.ctf_expression.right,
893 event->declaration_scope);
894 if (!declaration)
895 return -EPERM;
896 if (declaration->type->id != CTF_TYPE_STRUCT)
897 return -EPERM;
898 event->context_decl = container_of(declaration, struct declaration_struct, p);
899 } else if (!strcmp(left, "fields")) {
900 struct declaration *declaration;
901
902 if (!event->definition_scope)
903 return -EPERM;
904 declaration = ctf_declaration_specifier_visit(fd, depth,
905 &node->u.ctf_expression.right,
906 event->declaration_scope);
907 if (!declaration)
908 return -EPERM;
909 if (declaration->type->id != CTF_TYPE_STRUCT)
910 return -EPERM;
911 event->fields_decl = container_of(declaration, struct declaration_struct, p);
912 }
913 g_free(left);
914 break;
915 }
916 default:
917 return -EPERM;
918 /* TODO: declaration specifier should be added. */
919 }
920
921 return 0;
922 }
923
924 static
925 int ctf_event_visit(FILE *fd, int depth, struct ctf_node *node,
926 struct declaration_scope *parent_declaration_scope, struct ctf_trace *trace)
927 {
928 int ret = 0;
929 struct ctf_node *iter;
930 struct ctf_event *event;
931 struct definition_scope *parent_def_scope;
932
933 event = g_new0(struct ctf_event, 1);
934 event->declaration_scope = new_declaration_scope(parent_declaration_scope);
935 cds_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
936 ret = ctf_event_declaration_visit(fd, depth + 1, iter, event, trace);
937 if (ret)
938 goto error;
939 }
940 if (!CTF_EVENT_FIELD_IS_SET(event, name)) {
941 ret = -EPERM;
942 goto error;
943 }
944 if (!CTF_EVENT_FIELD_IS_SET(event, id)) {
945 ret = -EPERM;
946 goto error;
947 }
948 if (!CTF_EVENT_FIELD_IS_SET(event, stream_id)) {
949 ret = -EPERM;
950 goto error;
951 }
952 if (event->stream->events_by_id->len <= event->id)
953 g_ptr_array_set_size(event->stream->events_by_id, event->id + 1);
954 g_ptr_array_index(event->stream->events_by_id, event->id) = event;
955 g_hash_table_insert(event->stream->event_quark_to_id,
956 (gpointer)(unsigned long) event->name,
957 &event->id);
958 parent_def_scope = stream->definition_scope;
959 if (event->context_decl) {
960 event->context =
961 event->context_decl->definition_new(event->context_decl,
962 parent_def_scope, 0, 0);
963 set_dynamic_definition_scope(&event->context->p,
964 event->context->scope,
965 "event.context");
966 parent_def_scope = event->context->scope;
967 declaration_unref(event->context_decl);
968 }
969 if (event->fields_decl) {
970 event->fields =
971 event->fields_decl->definition_new(event->fields_decl,
972 parent_def_scope, 0, 0);
973 set_dynamic_definition_scope(&event->fields->p,
974 event->fields->scope,
975 "event.fields");
976 parent_def_scope = event->fields->scope;
977 declaration_unref(event->fields_decl);
978 }
979 return 0;
980
981 error:
982 declaration_unref(event->fields_decl);
983 declaration_unref(event->context_decl);
984 free_definition_scope(event->definition_scope);
985 free_declaration_scope(event->declaration_scope);
986 g_free(event);
987 return ret;
988 }
989
990
991 static
992 int ctf_stream_declaration_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_stream *stream, struct ctf_trace *trace)
993 {
994 int ret = 0;
995
996 switch (node->type) {
997 case NODE_TYPEDEF:
998 ret = ctf_typedef_visit(fd, depth + 1,
999 &node->u._typedef.declaration_specifier,
1000 &node->u._typedef.type_declarators,
1001 stream->declaration_scope);
1002 if (ret)
1003 return ret;
1004 break;
1005 case NODE_TYPEALIAS:
1006 ret = ctf_typealias_visit(fd, depth + 1,
1007 &node->u.typealias.target, &node->u.typealias.alias
1008 stream->declaration_scope);
1009 if (ret)
1010 return ret;
1011 break;
1012 case NODE_CTF_EXPRESSION:
1013 {
1014 char *left;
1015
1016 left = concatenate_unary_strings(&node->u.ctf_expression.left);
1017 if (!strcmp(left, "stream_id")) {
1018 if (CTF_EVENT_FIELD_IS_SET(event, stream_id))
1019 return -EPERM;
1020 ret = get_unary_unsigned(&node->u.ctf_expression.right, &event->stream_id);
1021 if (ret) {
1022 fprintf(stderr, "[error] %s: unexpected unary expression for event stream_id\n", __func__);
1023 return -EINVAL;
1024 }
1025 CTF_EVENT_SET_FIELD(event, stream_id);
1026 } else if (!strcmp(left, "event.header")) {
1027 struct declaration *declaration;
1028
1029 declaration = ctf_declaration_specifier_visit(fd, depth,
1030 &node->u.ctf_expression.right,
1031 stream->declaration_scope, stream->definition_scope);
1032 if (!declaration)
1033 return -EPERM;
1034 if (declaration->type->id != CTF_TYPE_STRUCT)
1035 return -EPERM;
1036 stream->event_header_decl = container_of(declaration, struct declaration_struct, p);
1037 } else if (!strcmp(left, "event.context")) {
1038 struct declaration *declaration;
1039
1040 declaration = ctf_declaration_specifier_visit(fd, depth,
1041 &node->u.ctf_expression.right,
1042 stream->declaration_scope);
1043 if (!declaration)
1044 return -EPERM;
1045 if (declaration->type->id != CTF_TYPE_STRUCT)
1046 return -EPERM;
1047 stream->event_context_decl = container_of(declaration, struct declaration_struct, p);
1048 } else if (!strcmp(left, "packet.context")) {
1049 struct declaration *declaration;
1050
1051 declaration = ctf_declaration_specifier_visit(fd, depth,
1052 &node->u.ctf_expression.right,
1053 stream->declaration_scope);
1054 if (!declaration)
1055 return -EPERM;
1056 if (declaration->type->id != CTF_TYPE_STRUCT)
1057 return -EPERM;
1058 stream->packet_context_decl = container_of(declaration, struct declaration_struct, p);
1059 }
1060 g_free(left);
1061 break;
1062 }
1063 default:
1064 return -EPERM;
1065 /* TODO: declaration specifier should be added. */
1066 }
1067
1068 return 0;
1069 }
1070
1071 static
1072 int ctf_stream_visit(FILE *fd, int depth, struct ctf_node *node,
1073 struct declaration_scope *parent_declaration_scope, struct ctf_trace *trace)
1074 {
1075 int ret = 0;
1076 struct ctf_node *iter;
1077 struct ctf_stream *stream;
1078 struct definition_scope *parent_def_scope;
1079
1080 stream = g_new0(struct ctf_stream, 1);
1081 stream->declaration_scope = new_declaration_scope(parent_declaration_scope);
1082 stream->events_by_id = g_ptr_array_new();
1083 stream->event_quark_to_id = g_hash_table_new(g_int_hash, g_int_equal);
1084 cds_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
1085 ret = ctf_stream_declaration_visit(fd, depth + 1, iter, stream, trace);
1086 if (ret)
1087 goto error;
1088 }
1089 if (!CTF_EVENT_FIELD_IS_SET(stream, stream_id)) {
1090 ret = -EPERM;
1091 goto error;
1092 }
1093 if (trace->streams->len <= stream->stream_id)
1094 g_ptr_array_set_size(trace->streams, stream->stream_id + 1);
1095 g_ptr_array_index(trace->streams, stream->stream_id) = stream;
1096
1097 parent_def_scope = NULL;
1098 if (stream->packet_context_decl) {
1099 stream->packet_context =
1100 stream->packet_context_decl->definition_new(stream->packet_context_decl,
1101 parent_def_scope, 0, 0);
1102 set_dynamic_definition_scope(&stream->packet_context->p,
1103 stream->packet_context->scope,
1104 "stream.packet.context");
1105 parent_def_scope = stream->packet_context->scope;
1106 declaration_unref(stream->packet_context_decl);
1107 }
1108 if (stream->event_header_decl) {
1109 stream->event_header =
1110 stream->event_header_decl->definition_new(stream->event_header_decl,
1111 parent_def_scope, 0, 0);
1112 set_dynamic_definition_scope(&stream->event_header->p,
1113 stream->event_header->scope,
1114 "stream.event.header");
1115 parent_def_scope = stream->event_header->scope;
1116 declaration_unref(stream->event_header_decl);
1117 }
1118 if (stream->event_context_decl) {
1119 stream->event_context =
1120 stream->event_context_decl->definition_new(stream->event_context_decl,
1121 parent_def_scope, 0, 0);
1122 set_dynamic_definition_scope(&stream->event_context->p,
1123 stream->event_context->scope,
1124 "stream.event.context");
1125 parent_def_scope = stream->event_context->scope;
1126 declaration_unref(stream->event_context_decl);
1127 }
1128 stream->definition_scope = parent_def_scope;
1129
1130 return 0;
1131
1132 error:
1133 declaration_unref(stream->event_header);
1134 declaration_unref(stream->event_context);
1135 declaration_unref(stream->packet_context);
1136 g_ptr_array_free(stream->events_by_id, TRUE);
1137 g_hash_table_free(stream->event_quark_to_id);
1138 free_definition_scope(stream->definition_scope);
1139 free_declaration_scope(stream->declaration_scope);
1140 g_free(stream);
1141 return ret;
1142 }
1143
1144 static
1145 int ctf_trace_declaration_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace *trace)
1146 {
1147 int ret = 0;
1148
1149 switch (node->type) {
1150 case NODE_TYPEDEF:
1151 ret = ctf_typedef_visit(fd, depth + 1,
1152 &node->u._typedef.declaration_specifier,
1153 &node->u._typedef.type_declarators,
1154 trace->declaration_scope);
1155 if (ret)
1156 return ret;
1157 break;
1158 case NODE_TYPEALIAS:
1159 ret = ctf_typealias_visit(fd, depth + 1,
1160 &node->u.typealias.target, &node->u.typealias.alias
1161 trace->declaration_scope);
1162 if (ret)
1163 return ret;
1164 break;
1165 case NODE_CTF_EXPRESSION:
1166 {
1167 char *left;
1168
1169 left = concatenate_unary_strings(&node->u.ctf_expression.left);
1170 if (!strcmp(left, "major")) {
1171 if (CTF_EVENT_FIELD_IS_SET(trace, major))
1172 return -EPERM;
1173 ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->major);
1174 if (ret) {
1175 fprintf(stderr, "[error] %s: unexpected unary expression for trace major number\n", __func__);
1176 return -EINVAL;
1177 }
1178 CTF_EVENT_SET_FIELD(trace, major);
1179 } else if (!strcmp(left, "minor")) {
1180 if (CTF_EVENT_FIELD_IS_SET(trace, minor))
1181 return -EPERM;
1182 ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->minor);
1183 if (ret) {
1184 fprintf(stderr, "[error] %s: unexpected unary expression for trace minor number\n", __func__);
1185 return -EINVAL;
1186 }
1187 CTF_EVENT_SET_FIELD(trace, minor);
1188 } else if (!strcmp(left, "word_size")) {
1189 if (CTF_EVENT_FIELD_IS_SET(trace, word_size))
1190 return -EPERM;
1191 ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->word_size);
1192 if (ret) {
1193 fprintf(stderr, "[error] %s: unexpected unary expression for trace word_size\n", __func__);
1194 return -EINVAL;
1195 }
1196 CTF_EVENT_SET_FIELD(trace, word_size);
1197 } else if (!strcmp(left, "uuid")) {
1198 if (CTF_EVENT_FIELD_IS_SET(trace, uuid))
1199 return -EPERM;
1200 ret = get_unary_uuid(&node->u.ctf_expression.right, &trace->uuid);
1201 if (ret) {
1202 fprintf(stderr, "[error] %s: unexpected unary expression for trace uuid\n", __func__);
1203 return -EINVAL;
1204 }
1205 CTF_EVENT_SET_FIELD(trace, uuid);
1206 }
1207 g_free(left);
1208 break;
1209 }
1210 default:
1211 return -EPERM;
1212 /* TODO: declaration specifier should be added. */
1213 }
1214
1215 return 0;
1216 }
1217
1218 static
1219 int ctf_trace_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace *trace)
1220 {
1221 int ret = 0;
1222 struct ctf_node *iter;
1223
1224 if (trace->declaration_scope)
1225 return -EEXIST;
1226 trace->declaration_scope = new_declaration_scope(trace->root_declaration_scope);
1227 trace->definition_scope = new_dynamic_definition_scope(trace->root_definition_scope);
1228 trace->streams = g_ptr_array_new();
1229 cds_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
1230 ret = ctf_trace_declaration_visit(fd, depth + 1, iter, trace);
1231 if (ret)
1232 goto error;
1233 }
1234 if (!CTF_EVENT_FIELD_IS_SET(trace, major)) {
1235 ret = -EPERM;
1236 goto error;
1237 }
1238 if (!CTF_EVENT_FIELD_IS_SET(trace, minor)) {
1239 ret = -EPERM;
1240 goto error;
1241 }
1242 if (!CTF_EVENT_FIELD_IS_SET(trace, uuid)) {
1243 ret = -EPERM;
1244 goto error;
1245 }
1246 if (!CTF_EVENT_FIELD_IS_SET(trace, word_size)) {
1247 ret = -EPERM;
1248 goto error;
1249 }
1250 return 0;
1251
1252 error:
1253 g_ptr_array_free(trace->streams, TRUE);
1254 free_definition_scope(stream->definition_scope);
1255 free_declaration_scope(stream->declaration_scope);
1256 return ret;
1257 }
1258
1259 int _ctf_visitor(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace *trace)
1260 {
1261 int ret = 0;
1262 struct ctf_node *iter;
1263
1264 switch (node->type) {
1265 case NODE_ROOT:
1266 cds_list_for_each_entry(iter, &node->u.root._typedef,
1267 siblings) {
1268 ret = ctf_typedef_visit(fd, depth + 1,
1269 &iter->u._typedef.declaration_specifier,
1270 &iter->u._typedef.type_declarators,
1271 trace->root_declaration_scope);
1272 if (ret)
1273 return ret;
1274 }
1275 cds_list_for_each_entry(iter, &node->u.root.typealias,
1276 siblings) {
1277 ret = ctf_typealias_visit(fd, depth + 1,
1278 &iter->u.typealias.target, &iter->u.typealias.alias
1279 trace->root_declaration_scope);
1280 if (ret)
1281 return ret;
1282 }
1283 cds_list_for_each_entry(iter, &node->u.root.declaration_specifier, siblings) {
1284 ret = ctf_declaration_specifier_visit(fd, depth, iter,
1285 trace->root_declaration_scope);
1286 if (ret)
1287 return ret;
1288 }
1289 cds_list_for_each_entry(iter, &node->u.root.trace, siblings) {
1290 ret = ctf_trace_visit(fd, depth + 1, iter, trace);
1291 if (ret)
1292 return ret;
1293 }
1294 cds_list_for_each_entry(iter, &node->u.root.stream, siblings) {
1295 ret = ctf_stream_visit(fd, depth + 1, iter,
1296 trace->root_declaration_scope, trace);
1297 if (ret)
1298 return ret;
1299 }
1300 cds_list_for_each_entry(iter, &node->u.root.event, siblings) {
1301 ret = ctf_event_visit(fd, depth + 1, iter,
1302 trace->root_declaration_scope, trace);
1303 if (ret)
1304 return ret;
1305 }
1306 break;
1307 case NODE_UNKNOWN:
1308 default:
1309 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
1310 (int) node->type);
1311 return -EINVAL;
1312 }
1313 return ret;
1314 }
This page took 0.064501 seconds and 5 git commands to generate.