3 * SPDX-License-Identifier: MIT
5 * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
7 * Common Trace Format Metadata Grammar.
10 #include "plugins/ctf/common/src/metadata/tsdl/logging.hpp"
12 #include "common/list.h"
13 #include "common/assert.h"
15 #include "plugins/ctf/common/src/metadata/tsdl/scanner.hpp"
16 #include "plugins/ctf/common/src/metadata/tsdl/ast.hpp"
17 #include "plugins/ctf/common/src/metadata/tsdl/objstack.hpp"
18 #include "plugins/ctf/common/src/metadata/tsdl/parser-wrap.hpp"
21 * Avoid warning about "yynerrs" being unused, seen with bison 3.5.1 + clang 15
24 BT_DIAG_IGNORE_UNUSED_BUT_SET_VARIABLE
26 thread_local const ctf_scanner *currentCtfScanner;
28 #define YYFPRINTF(_stream, _fmt, args...) \
30 int size = snprintf(NULL, 0, (_fmt), ##args); \
31 std::string str(size, '\0'); \
32 int written = snprintf(&str[0], size + 1, (_fmt), ##args); \
33 BT_ASSERT(size == written); \
34 BT_CPPLOGT_STR_SPEC(currentCtfScanner->logger, str.c_str()); \
37 /* Join two lists, put "add" at the end of "head". */
39 _bt_list_splice_tail (struct bt_list_head *add, struct bt_list_head *head)
41 /* Do nothing if the list which gets added is empty. */
42 if (add != add->next) {
43 add->next->prev = head->prev;
44 add->prev->next = head;
45 head->prev->next = add->next;
46 head->prev = add->prev;
50 int yylex(union YYSTYPE *yyval, yyscan_t yyscanner);
51 int yylex_init_extra(struct ctf_scanner *scanner, yyscan_t * ptr_yy_globals);
52 int yylex_destroy(yyscan_t yyscanner);
53 void yyrestart(FILE * in_str, yyscan_t yyscanner);
54 int yyget_lineno(yyscan_t yyscanner);
55 char *yyget_text(yyscan_t yyscanner);
58 * Static node for out of memory errors. Only "type" is used. lineno is
59 * always left at 0. The rest of the node content can be overwritten,
62 static struct ctf_node error_node = {
71 const char *node_type(struct ctf_node *node)
74 #define ENTRY(S) case S: return #S;
75 FOREACH_CTF_NODES(ENTRY)
82 void setstring(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src)
84 lvalp->s = (char *) objstack_alloc(scanner->objstack, strlen(src) + 1);
85 strcpy(lvalp->s, src);
89 int str_check(size_t str_len, size_t offset, size_t len)
92 if (offset + len < offset)
94 if (offset + len > str_len)
100 int bt_isodigit(int c)
118 int parse_base_sequence(const char *src, size_t len, size_t pos,
119 char *buffer, size_t *buf_len, int base)
121 const size_t max_char = 3;
124 while (!str_check(len, pos, 1) && nr_char < max_char) {
129 buffer[nr_char++] = c;
132 } else if (base == 16) {
134 buffer[nr_char++] = c;
139 /* Unsupported base */
143 BT_ASSERT_DBG(nr_char > 0);
144 buffer[nr_char] = '\0';
150 int import_basic_string(struct ctf_scanner *scanner, YYSTYPE *lvalp,
151 size_t len, const char *src, char delim)
153 size_t pos = 0, dpos = 0;
155 if (str_check(len, pos, 1))
157 if (src[pos++] != delim)
160 while (src[pos] != delim) {
163 if (str_check(len, pos, 1))
167 if (str_check(len, pos, 1))
217 if (parse_base_sequence(src, len, pos - 1,
218 oct_buffer, &oct_len, 8))
220 c = strtoul(&oct_buffer[0], NULL, 8);
229 if (parse_base_sequence(src, len, pos,
230 hex_buffer, &hex_len, 16))
232 c = strtoul(&hex_buffer[0], NULL, 16);
240 if (str_check(len, dpos, 1))
242 lvalp->s[dpos++] = c;
245 if (str_check(len, dpos, 1))
247 lvalp->s[dpos++] = '\0';
249 if (str_check(len, pos, 1))
251 if (src[pos++] != delim)
254 if (str_check(len, pos, 1))
256 if (src[pos] != '\0')
261 int import_string(struct ctf_scanner *scanner, YYSTYPE *lvalp,
262 const char *src, char delim)
266 len = strlen(src) + 1;
267 lvalp->s = (char *) objstack_alloc(scanner->objstack, len);
269 // TODO: import wide string
270 _BT_CPPLOGE_APPEND_CAUSE_LINENO(currentCtfScanner->logger,
271 yyget_lineno(scanner),
272 "wide characters are not supported as of this version: "
273 "scanner-addr={}", fmt::ptr(scanner));
276 return import_basic_string(scanner, lvalp, len, src, delim);
280 static void init_scope(struct ctf_scanner_scope *scope,
281 struct ctf_scanner_scope *parent)
283 scope->parent = parent;
284 scope->classes = g_hash_table_new_full(g_str_hash, g_str_equal,
288 static void finalize_scope(struct ctf_scanner_scope *scope)
290 g_hash_table_destroy(scope->classes);
293 static void push_scope(struct ctf_scanner *scanner)
295 struct ctf_scanner_scope *ns;
297 BT_CPPLOGT_SPEC(currentCtfScanner->logger,
298 "Pushing scope: scanner-addr={}", fmt::ptr(scanner));
299 ns = (ctf_scanner_scope *) malloc(sizeof(struct ctf_scanner_scope));
300 init_scope(ns, scanner->cs);
304 static void pop_scope(struct ctf_scanner *scanner)
306 struct ctf_scanner_scope *os;
308 BT_CPPLOGT_SPEC(currentCtfScanner->logger,
309 "Popping scope: scanner-addr={}", fmt::ptr(scanner));
311 scanner->cs = os->parent;
316 static int lookup_type(struct ctf_scanner_scope *s, const char *id)
320 ret = GPOINTER_TO_INT(g_hash_table_lookup(s->classes, id));
321 BT_CPPLOGT_SPEC(currentCtfScanner->logger,
322 "Looked up type: scanner-addr={}, id=\"{}\", ret={}",
323 fmt::ptr(s), id, ret);
327 int is_type(struct ctf_scanner *scanner, const char *id)
329 struct ctf_scanner_scope *it;
332 for (it = scanner->cs; it; it = it->parent) {
333 if (lookup_type(it, id)) {
338 BT_CPPLOGT_SPEC(currentCtfScanner->logger,
339 "Found if ID is type: scanner-addr={}, id=\"{}\", ret={}",
340 fmt::ptr(scanner), id, ret);
344 static void add_type(struct ctf_scanner *scanner, char *id)
346 BT_CPPLOGT_SPEC(currentCtfScanner->logger,
347 "Adding type: scanner-addr={}, id=\"{}\"", fmt::ptr(scanner),
349 if (lookup_type(scanner->cs, id))
351 g_hash_table_insert(scanner->cs->classes, id, id);
354 static struct ctf_node *make_node(struct ctf_scanner *scanner,
357 struct ctf_node *node;
359 node = (ctf_node *) objstack_alloc(scanner->objstack, sizeof(*node));
361 _BT_CPPLOGE_APPEND_CAUSE_LINENO(currentCtfScanner->logger,
362 yyget_lineno(scanner->scanner),
363 "failed to allocate one stack entry: "
364 "scanner-addr={}", fmt::ptr(scanner));
368 node->lineno = yyget_lineno(scanner->scanner);
369 BT_INIT_LIST_HEAD(&node->tmp_head);
370 bt_list_add(&node->siblings, &node->tmp_head);
374 node->type = NODE_ERROR;
375 BT_CPPLOGE_SPEC(currentCtfScanner->logger, "Trying to create root node: scanner-addr={}",
379 BT_INIT_LIST_HEAD(&node->u.event.declaration_list);
382 BT_INIT_LIST_HEAD(&node->u.stream.declaration_list);
385 BT_INIT_LIST_HEAD(&node->u.env.declaration_list);
388 BT_INIT_LIST_HEAD(&node->u.trace.declaration_list);
391 BT_INIT_LIST_HEAD(&node->u.clock.declaration_list);
394 BT_INIT_LIST_HEAD(&node->u.callsite.declaration_list);
396 case NODE_CTF_EXPRESSION:
397 BT_INIT_LIST_HEAD(&node->u.ctf_expression.left);
398 BT_INIT_LIST_HEAD(&node->u.ctf_expression.right);
400 case NODE_UNARY_EXPRESSION:
403 BT_INIT_LIST_HEAD(&node->u.field_class_def.field_class_declarators);
405 case NODE_TYPEALIAS_TARGET:
406 BT_INIT_LIST_HEAD(&node->u.field_class_alias_target.field_class_declarators);
408 case NODE_TYPEALIAS_ALIAS:
409 BT_INIT_LIST_HEAD(&node->u.field_class_alias_name.field_class_declarators);
413 case NODE_TYPE_SPECIFIER:
415 case NODE_TYPE_SPECIFIER_LIST:
416 BT_INIT_LIST_HEAD(&node->u.field_class_specifier_list.head);
420 case NODE_TYPE_DECLARATOR:
421 BT_INIT_LIST_HEAD(&node->u.field_class_declarator.pointers);
423 case NODE_FLOATING_POINT:
424 BT_INIT_LIST_HEAD(&node->u.floating_point.expressions);
427 BT_INIT_LIST_HEAD(&node->u.integer.expressions);
430 BT_INIT_LIST_HEAD(&node->u.string.expressions);
432 case NODE_ENUMERATOR:
433 BT_INIT_LIST_HEAD(&node->u.enumerator.values);
436 BT_INIT_LIST_HEAD(&node->u._enum.enumerator_list);
438 case NODE_STRUCT_OR_VARIANT_DECLARATION:
439 BT_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.field_class_declarators);
442 BT_INIT_LIST_HEAD(&node->u.variant.declaration_list);
445 BT_INIT_LIST_HEAD(&node->u._struct.declaration_list);
446 BT_INIT_LIST_HEAD(&node->u._struct.min_align);
450 node->type = NODE_ERROR;
451 BT_CPPLOGE_SPEC(currentCtfScanner->logger, "Unknown node type: scanner-addr={}, node-type={}",
452 fmt::ptr(scanner), type);
459 static int reparent_ctf_expression(struct ctf_node *node,
460 struct ctf_node *parent)
462 switch (parent->type) {
464 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
467 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
470 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
473 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
476 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
479 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
481 case NODE_FLOATING_POINT:
482 _bt_list_splice_tail(&node->tmp_head, &parent->u.floating_point.expressions);
485 _bt_list_splice_tail(&node->tmp_head, &parent->u.integer.expressions);
488 _bt_list_splice_tail(&node->tmp_head, &parent->u.string.expressions);
492 case NODE_CTF_EXPRESSION:
494 case NODE_TYPEALIAS_TARGET:
495 case NODE_TYPEALIAS_ALIAS:
497 case NODE_TYPE_SPECIFIER:
498 case NODE_TYPE_SPECIFIER_LIST:
500 case NODE_TYPE_DECLARATOR:
501 case NODE_ENUMERATOR:
503 case NODE_STRUCT_OR_VARIANT_DECLARATION:
506 case NODE_UNARY_EXPRESSION:
511 BT_CPPLOGE_SPEC(currentCtfScanner->logger, "Unknown node type: node-type={}", parent->type);
517 static int reparent_typedef(struct ctf_node *node, struct ctf_node *parent)
519 switch (parent->type) {
521 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
524 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
527 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
530 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
533 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
536 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
539 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
542 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
545 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
548 case NODE_FLOATING_POINT:
551 case NODE_CTF_EXPRESSION:
553 case NODE_TYPEALIAS_TARGET:
554 case NODE_TYPEALIAS_ALIAS:
556 case NODE_TYPE_SPECIFIER:
557 case NODE_TYPE_SPECIFIER_LIST:
559 case NODE_TYPE_DECLARATOR:
560 case NODE_ENUMERATOR:
562 case NODE_STRUCT_OR_VARIANT_DECLARATION:
563 case NODE_UNARY_EXPRESSION:
568 BT_CPPLOGE_SPEC(currentCtfScanner->logger, "Unknown node type: node-type={}", parent->type);
574 static int reparent_field_class_alias(struct ctf_node *node, struct ctf_node *parent)
576 switch (parent->type) {
578 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
581 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
584 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
587 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
590 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
593 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
596 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
599 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
602 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
605 case NODE_FLOATING_POINT:
608 case NODE_CTF_EXPRESSION:
610 case NODE_TYPEALIAS_TARGET:
611 case NODE_TYPEALIAS_ALIAS:
613 case NODE_TYPE_SPECIFIER:
614 case NODE_TYPE_SPECIFIER_LIST:
616 case NODE_TYPE_DECLARATOR:
617 case NODE_ENUMERATOR:
619 case NODE_STRUCT_OR_VARIANT_DECLARATION:
620 case NODE_UNARY_EXPRESSION:
625 BT_CPPLOGE_SPEC(currentCtfScanner->logger, "Unknown node type: node-type={}", parent->type);
631 static int reparent_field_class_specifier(struct ctf_node *node,
632 struct ctf_node *parent)
634 switch (parent->type) {
635 case NODE_TYPE_SPECIFIER_LIST:
636 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_specifier_list.head);
639 case NODE_TYPE_SPECIFIER:
649 case NODE_TYPEALIAS_TARGET:
650 case NODE_TYPEALIAS_ALIAS:
651 case NODE_TYPE_DECLARATOR:
653 case NODE_STRUCT_OR_VARIANT_DECLARATION:
655 case NODE_FLOATING_POINT:
658 case NODE_CTF_EXPRESSION:
660 case NODE_ENUMERATOR:
661 case NODE_UNARY_EXPRESSION:
666 BT_CPPLOGE_SPEC(currentCtfScanner->logger, "Unknown node type: node-type={}", parent->type);
672 static int reparent_field_class_specifier_list(struct ctf_node *node,
673 struct ctf_node *parent)
675 switch (parent->type) {
677 bt_list_add_tail(&node->siblings, &parent->u.root.declaration_list);
680 bt_list_add_tail(&node->siblings, &parent->u.event.declaration_list);
683 bt_list_add_tail(&node->siblings, &parent->u.stream.declaration_list);
686 bt_list_add_tail(&node->siblings, &parent->u.env.declaration_list);
689 bt_list_add_tail(&node->siblings, &parent->u.trace.declaration_list);
692 bt_list_add_tail(&node->siblings, &parent->u.clock.declaration_list);
695 bt_list_add_tail(&node->siblings, &parent->u.callsite.declaration_list);
698 bt_list_add_tail(&node->siblings, &parent->u.variant.declaration_list);
701 bt_list_add_tail(&node->siblings, &parent->u._struct.declaration_list);
704 parent->u.field_class_def.field_class_specifier_list = node;
706 case NODE_TYPEALIAS_TARGET:
707 parent->u.field_class_alias_target.field_class_specifier_list = node;
709 case NODE_TYPEALIAS_ALIAS:
710 parent->u.field_class_alias_name.field_class_specifier_list = node;
713 parent->u._enum.container_field_class = node;
715 case NODE_STRUCT_OR_VARIANT_DECLARATION:
716 parent->u.struct_or_variant_declaration.field_class_specifier_list = node;
718 case NODE_TYPE_DECLARATOR:
719 case NODE_TYPE_SPECIFIER:
721 case NODE_FLOATING_POINT:
724 case NODE_CTF_EXPRESSION:
726 case NODE_ENUMERATOR:
727 case NODE_UNARY_EXPRESSION:
732 BT_CPPLOGE_SPEC(currentCtfScanner->logger, "Unknown node type: node-type={}", parent->type);
738 static int reparent_field_class_declarator(struct ctf_node *node,
739 struct ctf_node *parent)
741 switch (parent->type) {
742 case NODE_TYPE_DECLARATOR:
743 parent->u.field_class_declarator.type = TYPEDEC_NESTED;
744 parent->u.field_class_declarator.u.nested.field_class_declarator = node;
746 case NODE_STRUCT_OR_VARIANT_DECLARATION:
747 _bt_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.field_class_declarators);
750 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_def.field_class_declarators);
752 case NODE_TYPEALIAS_TARGET:
753 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_alias_target.field_class_declarators);
755 case NODE_TYPEALIAS_ALIAS:
756 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_alias_name.field_class_declarators);
770 case NODE_FLOATING_POINT:
773 case NODE_CTF_EXPRESSION:
774 case NODE_TYPE_SPECIFIER:
775 case NODE_TYPE_SPECIFIER_LIST:
777 case NODE_ENUMERATOR:
778 case NODE_UNARY_EXPRESSION:
783 BT_CPPLOGE_SPEC(currentCtfScanner->logger, "Unknown node type: node-type={}", parent->type);
792 * Link node to parent. Returns 0 on success, -EPERM if it is not permitted to
793 * create the link declared by the input, -ENOENT if node or parent is NULL,
794 * -EINVAL if there is an internal structure problem.
796 static int set_parent_node(struct ctf_node *node,
797 struct ctf_node *parent)
799 if (!node || !parent)
802 /* Note: Linking to parent will be done only by an external visitor */
804 switch (node->type) {
806 BT_CPPLOGE_STR_SPEC(currentCtfScanner->logger,
807 "Trying to reparent root node.");
811 if (parent->type == NODE_ROOT) {
812 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.event);
818 if (parent->type == NODE_ROOT) {
819 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.stream);
825 if (parent->type == NODE_ROOT) {
826 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.env);
832 if (parent->type == NODE_ROOT) {
833 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.trace);
839 if (parent->type == NODE_ROOT) {
840 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.clock);
846 if (parent->type == NODE_ROOT) {
847 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.callsite);
853 case NODE_CTF_EXPRESSION:
854 return reparent_ctf_expression(node, parent);
855 case NODE_UNARY_EXPRESSION:
856 if (parent->type == NODE_TYPE_DECLARATOR)
857 parent->u.field_class_declarator.bitfield_len = node;
863 return reparent_typedef(node, parent);
864 case NODE_TYPEALIAS_TARGET:
865 if (parent->type == NODE_TYPEALIAS)
866 parent->u.field_class_alias.target = node;
870 case NODE_TYPEALIAS_ALIAS:
871 if (parent->type == NODE_TYPEALIAS)
872 parent->u.field_class_alias.alias = node;
877 return reparent_field_class_alias(node, parent);
880 if (parent->type == NODE_TYPE_DECLARATOR) {
881 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_declarator.pointers);
885 case NODE_TYPE_DECLARATOR:
886 return reparent_field_class_declarator(node, parent);
888 case NODE_TYPE_SPECIFIER_LIST:
889 return reparent_field_class_specifier_list(node, parent);
891 case NODE_TYPE_SPECIFIER:
892 return reparent_field_class_specifier(node, parent);
894 case NODE_FLOATING_POINT:
900 return -EINVAL; /* Dealt with internally within grammar */
902 case NODE_ENUMERATOR:
903 if (parent->type == NODE_ENUM) {
904 _bt_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
909 case NODE_STRUCT_OR_VARIANT_DECLARATION:
910 switch (parent->type) {
912 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
915 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
924 BT_CPPLOGE_SPEC(currentCtfScanner->logger, "Unknown node type: node-type={}", parent->type);
931 void yyerror(struct ctf_scanner *scanner, yyscan_t yyscanner, const char *str)
933 _BT_CPPLOGE_APPEND_CAUSE_LINENO(currentCtfScanner->logger,
934 yyget_lineno(scanner->scanner),
935 "{}: token=\"{}\"", str, yyget_text(scanner->scanner));
938 #define reparent_error(scanner, str) \
940 yyerror(scanner, scanner->scanner, YY_("reparent_error: " str)); \
944 static struct ctf_ast *ctf_ast_alloc(struct ctf_scanner *scanner)
948 ast = (ctf_ast *) objstack_alloc(scanner->objstack, sizeof(*ast));
951 ast->root.type = NODE_ROOT;
952 BT_INIT_LIST_HEAD(&ast->root.tmp_head);
953 BT_INIT_LIST_HEAD(&ast->root.u.root.declaration_list);
954 BT_INIT_LIST_HEAD(&ast->root.u.root.trace);
955 BT_INIT_LIST_HEAD(&ast->root.u.root.env);
956 BT_INIT_LIST_HEAD(&ast->root.u.root.stream);
957 BT_INIT_LIST_HEAD(&ast->root.u.root.event);
958 BT_INIT_LIST_HEAD(&ast->root.u.root.clock);
959 BT_INIT_LIST_HEAD(&ast->root.u.root.callsite);
963 int ctf_scanner_append_ast(struct ctf_scanner *scanner, FILE *input)
965 /* Start processing new stream */
966 struct ClearCurrentCtfScanner {
967 ~ClearCurrentCtfScanner() {
968 currentCtfScanner = nullptr;
972 currentCtfScanner = scanner;
973 yyrestart(input, scanner->scanner);
974 return yyparse(scanner, scanner->scanner);
977 struct ctf_scanner *ctf_scanner_alloc(const bt2c::Logger &parentLogger)
979 ctf_scanner *scanner = new ctf_scanner {parentLogger};
980 int ret = yylex_init_extra(scanner, &scanner->scanner);
982 BT_CPPLOGE_SPEC(scanner->logger, "yylex_init_extra() failed: ret={}", ret);
983 goto cleanup_scanner;
985 scanner->objstack = objstack_create(scanner->logger);
986 if (!scanner->objstack)
988 scanner->ast = ctf_ast_alloc(scanner);
990 goto cleanup_objstack;
991 init_scope(&scanner->root_scope, NULL);
992 scanner->cs = &scanner->root_scope;
997 objstack_destroy(scanner->objstack);
999 ret = yylex_destroy(scanner->scanner);
1001 BT_CPPLOGE_SPEC(scanner->logger, "yylex_destroy() failed: scanner-addr={}, ret={}",
1002 fmt::ptr(scanner), ret);
1008 void ctf_scanner_free(struct ctf_scanner *scanner)
1015 struct ctf_scanner_scope *scope = scanner->cs;
1018 struct ctf_scanner_scope *parent = scope->parent;
1019 finalize_scope(scope);
1022 * The root scope is allocated within the ctf_scanner structure,
1023 * do doesn't need freeing. All others are allocated on their
1026 if (scope != &scanner->root_scope)
1032 objstack_destroy(scanner->objstack);
1033 ret = yylex_destroy(scanner->scanner);
1035 BT_CPPLOGE_SPEC(currentCtfScanner->logger, "yylex_destroy() failed: scanner-addr={}, ret={}",
1036 fmt::ptr(scanner), ret);
1041 * The bison-provided version of strlen (yystrlen) generates a benign
1042 * -Wnull-dereference warning. That version is used when building on cygwin,
1043 * for example, but you can also enable it by hand (to test) by removing the
1044 * preprocessor conditional around it.
1046 * Define yystrlen such that it will always use strlen. As far as we know,
1047 * strlen provided by all the platforms we use is reliable.
1049 #define yystrlen strlen
1054 * This ends up in parser.h and makes sure those who want to include it pass
1055 * through parser-wrap.h.
1058 #ifndef ALLOW_INCLUDE_PARSER_H
1059 # error "Don't include parser.h directly, include parser-wrap.h instead."
1062 #include "plugins/ctf/common/src/metadata/tsdl/scanner.hpp"
1066 void setstring(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src);
1068 int import_string(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src, char delim);
1074 %parse-param {struct ctf_scanner *scanner}
1075 %parse-param {yyscan_t yyscanner}
1076 %lex-param {yyscan_t yyscanner}
1078 * Expect two shift-reduce conflicts. Caused by enum name-opt : type {}
1079 * vs struct { int :value; } (unnamed bit-field). The default is to
1080 * shift, so whenever we encounter an enumeration, we are doing the
1081 * proper thing (shift). It is illegal to declare an enumeration
1082 * "bit-field", so it is OK if this situation ends up in a parsing
1087 %token CTF_INTEGER_LITERAL CTF_STRING_LITERAL CTF_CHARACTER_LITERAL CTF_LSBRAC CTF_RSBRAC CTF_LPAREN CTF_RPAREN CTF_LBRAC CTF_RBRAC CTF_RARROW CTF_STAR CTF_PLUS CTF_MINUS CTF_LT CTF_GT CTF_TYPEASSIGN CTF_COLON CTF_SEMICOLON CTF_DOTDOTDOT CTF_DOT CTF_EQUAL CTF_COMMA CTF_CONST CTF_CHAR CTF_DOUBLE CTF_ENUM CTF_ENV CTF_EVENT CTF_FLOATING_POINT CTF_FLOAT CTF_INTEGER CTF_INT CTF_LONG CTF_SHORT CTF_SIGNED CTF_STREAM CTF_STRING CTF_STRUCT CTF_TRACE CTF_CALLSITE CTF_CLOCK CTF_TYPEALIAS CTF_TYPEDEF CTF_UNSIGNED CTF_VARIANT CTF_VOID CTF_BOOL CTF_COMPLEX CTF_IMAGINARY CTF_TOK_ALIGN
1088 %token <s> IDENTIFIER ID_TYPE
1093 unsigned long long ull;
1099 %type <s> CTF_STRING_LITERAL CTF_CHARACTER_LITERAL
1103 %type <ull> CTF_INTEGER_LITERAL
1104 %type <n> postfix_expression unary_expression unary_expression_or_range
1106 %type <n> declaration
1107 %type <n> event_declaration
1108 %type <n> stream_declaration
1109 %type <n> env_declaration
1110 %type <n> trace_declaration
1111 %type <n> clock_declaration
1112 %type <n> callsite_declaration
1113 %type <n> integer_declaration_specifiers
1114 %type <n> declaration_specifiers
1115 %type <n> alias_declaration_specifiers
1117 %type <n> field_class_declarator_list
1118 %type <n> integer_field_class_specifier
1119 %type <n> field_class_specifier
1120 %type <n> struct_class_specifier
1121 %type <n> variant_field_class_specifier
1122 %type <n> enum_field_class_specifier
1123 %type <n> struct_or_variant_declaration_list
1124 %type <n> struct_or_variant_declaration
1125 %type <n> struct_or_variant_declarator_list
1126 %type <n> struct_or_variant_declarator
1127 %type <n> enumerator_list
1128 %type <n> enumerator
1129 %type <n> abstract_declarator_list
1130 %type <n> abstract_declarator
1131 %type <n> direct_abstract_declarator
1132 %type <n> alias_abstract_declarator_list
1133 %type <n> alias_abstract_declarator
1134 %type <n> direct_alias_abstract_declarator
1135 %type <n> declarator
1136 %type <n> direct_declarator
1137 %type <n> field_class_declarator
1138 %type <n> direct_field_class_declarator
1140 %type <n> ctf_assignment_expression_list
1141 %type <n> ctf_assignment_expression
1148 if (set_parent_node($1, &ctf_scanner_get_ast(scanner)->root))
1149 reparent_error(scanner, "error reparenting to root");
1153 if (set_parent_node($2, &ctf_scanner_get_ast(scanner)->root))
1154 reparent_error(scanner, "error reparenting to root");
1183 | CTF_FLOATING_POINT
1216 /* 2: Phrase structure grammar */
1221 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1222 $$->u.unary_expression.type = UNARY_STRING;
1223 $$->u.unary_expression.u.string = yylval.s;
1227 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1228 $$->u.unary_expression.type = UNARY_STRING;
1229 $$->u.unary_expression.u.string = yylval.s;
1233 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1234 $$->u.unary_expression.type = UNARY_STRING;
1235 $$->u.unary_expression.u.string = yylval.s;
1237 | CTF_INTEGER_LITERAL
1239 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1240 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1241 $$->u.unary_expression.u.unsigned_constant = $1;
1243 | CTF_STRING_LITERAL
1245 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1246 $$->u.unary_expression.type = UNARY_STRING;
1247 $$->u.unary_expression.u.string = $1;
1249 | CTF_CHARACTER_LITERAL
1251 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1252 $$->u.unary_expression.type = UNARY_STRING;
1253 $$->u.unary_expression.u.string = $1;
1255 | CTF_LPAREN unary_expression CTF_RPAREN
1259 | postfix_expression CTF_LSBRAC unary_expression CTF_RSBRAC
1261 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1262 $$->u.unary_expression.type = UNARY_SBRAC;
1263 $$->u.unary_expression.u.sbrac_exp = $3;
1264 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1265 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1267 | postfix_expression CTF_DOT IDENTIFIER
1269 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1270 $$->u.unary_expression.type = UNARY_STRING;
1271 $$->u.unary_expression.u.string = yylval.s;
1272 $$->u.unary_expression.link = UNARY_DOTLINK;
1273 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1274 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1276 | postfix_expression CTF_DOT ID_TYPE
1278 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1279 $$->u.unary_expression.type = UNARY_STRING;
1280 $$->u.unary_expression.u.string = yylval.s;
1281 $$->u.unary_expression.link = UNARY_DOTLINK;
1282 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1283 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1285 | postfix_expression CTF_DOT keywords
1287 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1288 $$->u.unary_expression.type = UNARY_STRING;
1289 $$->u.unary_expression.u.string = yylval.s;
1290 $$->u.unary_expression.link = UNARY_DOTLINK;
1291 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1292 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1294 | postfix_expression CTF_RARROW IDENTIFIER
1296 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1297 $$->u.unary_expression.type = UNARY_STRING;
1298 $$->u.unary_expression.u.string = yylval.s;
1299 $$->u.unary_expression.link = UNARY_ARROWLINK;
1300 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1301 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1303 | postfix_expression CTF_RARROW ID_TYPE
1305 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1306 $$->u.unary_expression.type = UNARY_STRING;
1307 $$->u.unary_expression.u.string = yylval.s;
1308 $$->u.unary_expression.link = UNARY_ARROWLINK;
1309 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1310 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1317 | CTF_PLUS postfix_expression
1320 if ($$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
1321 && $$->u.unary_expression.type != UNARY_SIGNED_CONSTANT) {
1322 reparent_error(scanner, "expecting numeric constant");
1325 | CTF_MINUS postfix_expression
1328 if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1329 $$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
1330 $$->u.unary_expression.u.signed_constant =
1331 -($$->u.unary_expression.u.unsigned_constant);
1332 } else if ($$->u.unary_expression.type == UNARY_SIGNED_CONSTANT) {
1333 $$->u.unary_expression.u.signed_constant =
1334 -($$->u.unary_expression.u.signed_constant);
1336 reparent_error(scanner, "expecting numeric constant");
1341 unary_expression_or_range:
1342 unary_expression CTF_DOTDOTDOT unary_expression
1345 _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
1346 $3->u.unary_expression.link = UNARY_DOTDOTDOT;
1352 /* 2.2: Declarations */
1355 declaration_specifiers CTF_SEMICOLON
1359 | stream_declaration
1367 | callsite_declaration
1369 | declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
1371 struct ctf_node *list;
1373 $$ = make_node(scanner, NODE_TYPEDEF);
1374 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1375 $$->u.field_class_def.field_class_specifier_list = list;
1376 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1377 _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1378 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1380 | CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
1382 struct ctf_node *list;
1384 $$ = make_node(scanner, NODE_TYPEDEF);
1385 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1386 $$->u.field_class_def.field_class_specifier_list = list;
1387 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1388 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1390 | declaration_specifiers CTF_TYPEDEF field_class_declarator_list CTF_SEMICOLON
1392 struct ctf_node *list;
1394 $$ = make_node(scanner, NODE_TYPEDEF);
1395 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1396 $$->u.field_class_def.field_class_specifier_list = list;
1397 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1398 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1400 | CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
1402 struct ctf_node *list;
1404 $$ = make_node(scanner, NODE_TYPEALIAS);
1405 $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1406 $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1408 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1409 $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
1410 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1411 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
1413 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1414 $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
1415 _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1416 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
1421 event_declaration_begin event_declaration_end
1423 $$ = make_node(scanner, NODE_EVENT);
1425 | event_declaration_begin ctf_assignment_expression_list event_declaration_end
1427 $$ = make_node(scanner, NODE_EVENT);
1428 if (set_parent_node($2, $$))
1429 reparent_error(scanner, "event_declaration");
1433 event_declaration_begin:
1435 { push_scope(scanner); }
1438 event_declaration_end:
1439 CTF_RBRAC CTF_SEMICOLON
1440 { pop_scope(scanner); }
1445 stream_declaration_begin stream_declaration_end
1447 $$ = make_node(scanner, NODE_STREAM);
1449 | stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
1451 $$ = make_node(scanner, NODE_STREAM);
1452 if (set_parent_node($2, $$))
1453 reparent_error(scanner, "stream_declaration");
1457 stream_declaration_begin:
1458 CTF_STREAM CTF_LBRAC
1459 { push_scope(scanner); }
1462 stream_declaration_end:
1463 CTF_RBRAC CTF_SEMICOLON
1464 { pop_scope(scanner); }
1468 env_declaration_begin env_declaration_end
1470 $$ = make_node(scanner, NODE_ENV);
1472 | env_declaration_begin ctf_assignment_expression_list env_declaration_end
1474 $$ = make_node(scanner, NODE_ENV);
1475 if (set_parent_node($2, $$))
1476 reparent_error(scanner, "env declaration");
1480 env_declaration_begin:
1482 { push_scope(scanner); }
1485 env_declaration_end:
1486 CTF_RBRAC CTF_SEMICOLON
1487 { pop_scope(scanner); }
1491 trace_declaration_begin trace_declaration_end
1493 $$ = make_node(scanner, NODE_TRACE);
1495 | trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
1497 $$ = make_node(scanner, NODE_TRACE);
1498 if (set_parent_node($2, $$))
1499 reparent_error(scanner, "trace_declaration");
1503 trace_declaration_begin:
1505 { push_scope(scanner); }
1508 trace_declaration_end:
1509 CTF_RBRAC CTF_SEMICOLON
1510 { pop_scope(scanner); }
1514 CTF_CLOCK clock_declaration_begin clock_declaration_end
1516 $$ = make_node(scanner, NODE_CLOCK);
1518 | CTF_CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
1520 $$ = make_node(scanner, NODE_CLOCK);
1521 if (set_parent_node($3, $$))
1522 reparent_error(scanner, "trace_declaration");
1526 clock_declaration_begin:
1528 { push_scope(scanner); }
1531 clock_declaration_end:
1532 CTF_RBRAC CTF_SEMICOLON
1533 { pop_scope(scanner); }
1536 callsite_declaration:
1537 CTF_CALLSITE callsite_declaration_begin callsite_declaration_end
1539 $$ = make_node(scanner, NODE_CALLSITE);
1541 | CTF_CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
1543 $$ = make_node(scanner, NODE_CALLSITE);
1544 if (set_parent_node($3, $$))
1545 reparent_error(scanner, "trace_declaration");
1549 callsite_declaration_begin:
1551 { push_scope(scanner); }
1554 callsite_declaration_end:
1555 CTF_RBRAC CTF_SEMICOLON
1556 { pop_scope(scanner); }
1559 integer_declaration_specifiers:
1562 struct ctf_node *node;
1564 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1565 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1566 node->u.field_class_specifier.type = TYPESPEC_CONST;
1567 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1569 | integer_field_class_specifier
1571 struct ctf_node *node;
1573 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1575 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1577 | integer_declaration_specifiers CTF_CONST
1579 struct ctf_node *node;
1582 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1583 node->u.field_class_specifier.type = TYPESPEC_CONST;
1584 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1586 | integer_declaration_specifiers integer_field_class_specifier
1589 bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
1593 declaration_specifiers:
1596 struct ctf_node *node;
1598 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1599 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1600 node->u.field_class_specifier.type = TYPESPEC_CONST;
1601 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1603 | field_class_specifier
1605 struct ctf_node *node;
1607 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1609 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1611 | declaration_specifiers CTF_CONST
1613 struct ctf_node *node;
1616 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1617 node->u.field_class_specifier.type = TYPESPEC_CONST;
1618 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1620 | declaration_specifiers field_class_specifier
1623 bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
1627 field_class_declarator_list:
1628 field_class_declarator
1630 | field_class_declarator_list CTF_COMMA field_class_declarator
1633 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1637 integer_field_class_specifier:
1640 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1641 $$->u.field_class_specifier.type = TYPESPEC_CHAR;
1645 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1646 $$->u.field_class_specifier.type = TYPESPEC_SHORT;
1650 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1651 $$->u.field_class_specifier.type = TYPESPEC_INT;
1655 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1656 $$->u.field_class_specifier.type = TYPESPEC_LONG;
1660 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1661 $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
1665 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1666 $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
1670 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1671 $$->u.field_class_specifier.type = TYPESPEC_BOOL;
1675 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1676 $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
1677 $$->u.field_class_specifier.id_type = yylval.s;
1679 | CTF_INTEGER CTF_LBRAC CTF_RBRAC
1681 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1682 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1683 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1685 | CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1687 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1688 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1689 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1690 if (set_parent_node($3, $$->u.field_class_specifier.node))
1691 reparent_error(scanner, "integer reparent error");
1695 field_class_specifier:
1698 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1699 $$->u.field_class_specifier.type = TYPESPEC_VOID;
1703 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1704 $$->u.field_class_specifier.type = TYPESPEC_CHAR;
1708 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1709 $$->u.field_class_specifier.type = TYPESPEC_SHORT;
1713 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1714 $$->u.field_class_specifier.type = TYPESPEC_INT;
1718 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1719 $$->u.field_class_specifier.type = TYPESPEC_LONG;
1723 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1724 $$->u.field_class_specifier.type = TYPESPEC_FLOAT;
1728 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1729 $$->u.field_class_specifier.type = TYPESPEC_DOUBLE;
1733 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1734 $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
1738 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1739 $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
1743 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1744 $$->u.field_class_specifier.type = TYPESPEC_BOOL;
1748 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1749 $$->u.field_class_specifier.type = TYPESPEC_COMPLEX;
1753 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1754 $$->u.field_class_specifier.type = TYPESPEC_IMAGINARY;
1758 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1759 $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
1760 $$->u.field_class_specifier.id_type = yylval.s;
1762 | CTF_FLOATING_POINT CTF_LBRAC CTF_RBRAC
1764 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1765 $$->u.field_class_specifier.type = TYPESPEC_FLOATING_POINT;
1766 $$->u.field_class_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1768 | CTF_FLOATING_POINT CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1770 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1771 $$->u.field_class_specifier.type = TYPESPEC_FLOATING_POINT;
1772 $$->u.field_class_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1773 if (set_parent_node($3, $$->u.field_class_specifier.node))
1774 reparent_error(scanner, "floating point reparent error");
1776 | CTF_INTEGER CTF_LBRAC CTF_RBRAC
1778 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1779 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1780 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1782 | CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1784 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1785 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1786 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1787 if (set_parent_node($3, $$->u.field_class_specifier.node))
1788 reparent_error(scanner, "integer reparent error");
1792 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1793 $$->u.field_class_specifier.type = TYPESPEC_STRING;
1794 $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1796 | CTF_STRING CTF_LBRAC CTF_RBRAC
1798 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1799 $$->u.field_class_specifier.type = TYPESPEC_STRING;
1800 $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1802 | CTF_STRING CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1804 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1805 $$->u.field_class_specifier.type = TYPESPEC_STRING;
1806 $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1807 if (set_parent_node($3, $$->u.field_class_specifier.node))
1808 reparent_error(scanner, "string reparent error");
1810 | CTF_ENUM enum_field_class_specifier
1812 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1813 $$->u.field_class_specifier.type = TYPESPEC_ENUM;
1814 $$->u.field_class_specifier.node = $2;
1816 | CTF_VARIANT variant_field_class_specifier
1818 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1819 $$->u.field_class_specifier.type = TYPESPEC_VARIANT;
1820 $$->u.field_class_specifier.node = $2;
1822 | CTF_STRUCT struct_class_specifier
1824 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1825 $$->u.field_class_specifier.type = TYPESPEC_STRUCT;
1826 $$->u.field_class_specifier.node = $2;
1830 struct_class_specifier:
1831 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1833 $$ = make_node(scanner, NODE_STRUCT);
1834 $$->u._struct.has_body = 1;
1835 if ($2 && set_parent_node($2, $$))
1836 reparent_error(scanner, "struct reparent error");
1838 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1840 $$ = make_node(scanner, NODE_STRUCT);
1841 $$->u._struct.has_body = 1;
1842 $$->u._struct.name = $1;
1843 if ($3 && set_parent_node($3, $$))
1844 reparent_error(scanner, "struct reparent error");
1846 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1848 $$ = make_node(scanner, NODE_STRUCT);
1849 $$->u._struct.has_body = 1;
1850 $$->u._struct.name = $1;
1851 if ($3 && set_parent_node($3, $$))
1852 reparent_error(scanner, "struct reparent error");
1856 $$ = make_node(scanner, NODE_STRUCT);
1857 $$->u._struct.has_body = 0;
1858 $$->u._struct.name = $1;
1862 $$ = make_node(scanner, NODE_STRUCT);
1863 $$->u._struct.has_body = 0;
1864 $$->u._struct.name = $1;
1866 | struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1868 $$ = make_node(scanner, NODE_STRUCT);
1869 $$->u._struct.has_body = 1;
1870 bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
1871 if ($2 && set_parent_node($2, $$))
1872 reparent_error(scanner, "struct reparent error");
1874 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1876 $$ = make_node(scanner, NODE_STRUCT);
1877 $$->u._struct.has_body = 1;
1878 $$->u._struct.name = $1;
1879 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1880 if ($3 && set_parent_node($3, $$))
1881 reparent_error(scanner, "struct reparent error");
1883 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1885 $$ = make_node(scanner, NODE_STRUCT);
1886 $$->u._struct.has_body = 1;
1887 $$->u._struct.name = $1;
1888 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1889 if ($3 && set_parent_node($3, $$))
1890 reparent_error(scanner, "struct reparent error");
1894 struct_declaration_begin:
1896 { push_scope(scanner); }
1899 struct_declaration_end:
1901 { pop_scope(scanner); }
1904 variant_field_class_specifier:
1905 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1907 $$ = make_node(scanner, NODE_VARIANT);
1908 $$->u.variant.has_body = 1;
1909 if ($2 && set_parent_node($2, $$))
1910 reparent_error(scanner, "variant reparent error");
1912 | CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1914 $$ = make_node(scanner, NODE_VARIANT);
1915 $$->u.variant.has_body = 1;
1916 $$->u.variant.choice = $2;
1917 if ($5 && set_parent_node($5, $$))
1918 reparent_error(scanner, "variant reparent error");
1920 | CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1922 $$ = make_node(scanner, NODE_VARIANT);
1923 $$->u.variant.has_body = 1;
1924 $$->u.variant.choice = $2;
1925 if ($5 && set_parent_node($5, $$))
1926 reparent_error(scanner, "variant reparent error");
1928 | IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1930 $$ = make_node(scanner, NODE_VARIANT);
1931 $$->u.variant.has_body = 1;
1932 $$->u.variant.name = $1;
1933 if ($3 && set_parent_node($3, $$))
1934 reparent_error(scanner, "variant reparent error");
1936 | IDENTIFIER CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1938 $$ = make_node(scanner, NODE_VARIANT);
1939 $$->u.variant.has_body = 1;
1940 $$->u.variant.name = $1;
1941 $$->u.variant.choice = $3;
1942 if ($6 && set_parent_node($6, $$))
1943 reparent_error(scanner, "variant reparent error");
1945 | IDENTIFIER CTF_LT IDENTIFIER CTF_GT
1947 $$ = make_node(scanner, NODE_VARIANT);
1948 $$->u.variant.has_body = 0;
1949 $$->u.variant.name = $1;
1950 $$->u.variant.choice = $3;
1952 | IDENTIFIER CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1954 $$ = make_node(scanner, NODE_VARIANT);
1955 $$->u.variant.has_body = 1;
1956 $$->u.variant.name = $1;
1957 $$->u.variant.choice = $3;
1958 if ($6 && set_parent_node($6, $$))
1959 reparent_error(scanner, "variant reparent error");
1961 | IDENTIFIER CTF_LT ID_TYPE CTF_GT
1963 $$ = make_node(scanner, NODE_VARIANT);
1964 $$->u.variant.has_body = 0;
1965 $$->u.variant.name = $1;
1966 $$->u.variant.choice = $3;
1968 | ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1970 $$ = make_node(scanner, NODE_VARIANT);
1971 $$->u.variant.has_body = 1;
1972 $$->u.variant.name = $1;
1973 if ($3 && set_parent_node($3, $$))
1974 reparent_error(scanner, "variant reparent error");
1976 | ID_TYPE CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1978 $$ = make_node(scanner, NODE_VARIANT);
1979 $$->u.variant.has_body = 1;
1980 $$->u.variant.name = $1;
1981 $$->u.variant.choice = $3;
1982 if ($6 && set_parent_node($6, $$))
1983 reparent_error(scanner, "variant reparent error");
1985 | ID_TYPE CTF_LT IDENTIFIER CTF_GT
1987 $$ = make_node(scanner, NODE_VARIANT);
1988 $$->u.variant.has_body = 0;
1989 $$->u.variant.name = $1;
1990 $$->u.variant.choice = $3;
1992 | ID_TYPE CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1994 $$ = make_node(scanner, NODE_VARIANT);
1995 $$->u.variant.has_body = 1;
1996 $$->u.variant.name = $1;
1997 $$->u.variant.choice = $3;
1998 if ($6 && set_parent_node($6, $$))
1999 reparent_error(scanner, "variant reparent error");
2001 | ID_TYPE CTF_LT ID_TYPE CTF_GT
2003 $$ = make_node(scanner, NODE_VARIANT);
2004 $$->u.variant.has_body = 0;
2005 $$->u.variant.name = $1;
2006 $$->u.variant.choice = $3;
2010 variant_declaration_begin:
2012 { push_scope(scanner); }
2015 variant_declaration_end:
2017 { pop_scope(scanner); }
2020 enum_field_class_specifier:
2021 CTF_LBRAC enumerator_list CTF_RBRAC
2023 $$ = make_node(scanner, NODE_ENUM);
2024 $$->u._enum.has_body = 1;
2025 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
2027 | CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2029 $$ = make_node(scanner, NODE_ENUM);
2030 $$->u._enum.has_body = 1;
2031 ($$)->u._enum.container_field_class = $2;
2032 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2034 | IDENTIFIER CTF_LBRAC enumerator_list CTF_RBRAC
2036 $$ = make_node(scanner, NODE_ENUM);
2037 $$->u._enum.has_body = 1;
2038 $$->u._enum.enum_id = $1;
2039 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2041 | IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2043 $$ = make_node(scanner, NODE_ENUM);
2044 $$->u._enum.has_body = 1;
2045 $$->u._enum.enum_id = $1;
2046 ($$)->u._enum.container_field_class = $3;
2047 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2049 | ID_TYPE CTF_LBRAC enumerator_list CTF_RBRAC
2051 $$ = make_node(scanner, NODE_ENUM);
2052 $$->u._enum.has_body = 1;
2053 $$->u._enum.enum_id = $1;
2054 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2056 | ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2058 $$ = make_node(scanner, NODE_ENUM);
2059 $$->u._enum.has_body = 1;
2060 $$->u._enum.enum_id = $1;
2061 ($$)->u._enum.container_field_class = $3;
2062 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2064 | CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2066 $$ = make_node(scanner, NODE_ENUM);
2067 $$->u._enum.has_body = 1;
2068 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
2070 | CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2072 $$ = make_node(scanner, NODE_ENUM);
2073 $$->u._enum.has_body = 1;
2074 ($$)->u._enum.container_field_class = $2;
2075 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2077 | IDENTIFIER CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2079 $$ = make_node(scanner, NODE_ENUM);
2080 $$->u._enum.has_body = 1;
2081 $$->u._enum.enum_id = $1;
2082 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2084 | IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2086 $$ = make_node(scanner, NODE_ENUM);
2087 $$->u._enum.has_body = 1;
2088 $$->u._enum.enum_id = $1;
2089 ($$)->u._enum.container_field_class = $3;
2090 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2094 $$ = make_node(scanner, NODE_ENUM);
2095 $$->u._enum.has_body = 0;
2096 $$->u._enum.enum_id = $1;
2098 | ID_TYPE CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2100 $$ = make_node(scanner, NODE_ENUM);
2101 $$->u._enum.has_body = 1;
2102 $$->u._enum.enum_id = $1;
2103 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2105 | ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2107 $$ = make_node(scanner, NODE_ENUM);
2108 $$->u._enum.has_body = 1;
2109 $$->u._enum.enum_id = $1;
2110 ($$)->u._enum.container_field_class = $3;
2111 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2115 $$ = make_node(scanner, NODE_ENUM);
2116 $$->u._enum.has_body = 0;
2117 $$->u._enum.enum_id = $1;
2121 struct_or_variant_declaration_list:
2124 | struct_or_variant_declaration_list struct_or_variant_declaration
2128 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2131 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
2136 struct_or_variant_declaration:
2137 declaration_specifiers struct_or_variant_declarator_list CTF_SEMICOLON
2139 struct ctf_node *list;
2141 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2142 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2143 $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
2144 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2145 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.field_class_declarators);
2147 | declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
2149 struct ctf_node *list;
2151 $$ = make_node(scanner, NODE_TYPEDEF);
2152 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2153 $$->u.field_class_def.field_class_specifier_list = list;
2154 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2155 _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2156 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2158 | CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
2160 struct ctf_node *list;
2162 $$ = make_node(scanner, NODE_TYPEDEF);
2163 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2164 $$->u.field_class_def.field_class_specifier_list = list;
2165 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2166 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2168 | declaration_specifiers CTF_TYPEDEF field_class_declarator_list CTF_SEMICOLON
2170 struct ctf_node *list;
2172 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2173 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2174 $$ = make_node(scanner, NODE_TYPEDEF);
2175 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2176 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2178 | CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
2180 struct ctf_node *list;
2182 $$ = make_node(scanner, NODE_TYPEALIAS);
2183 $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2184 $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2186 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2187 $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
2188 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2189 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
2191 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2192 $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
2193 _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2194 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
2198 alias_declaration_specifiers:
2201 struct ctf_node *node;
2203 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2204 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2205 node->u.field_class_specifier.type = TYPESPEC_CONST;
2206 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2208 | field_class_specifier
2210 struct ctf_node *node;
2212 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2214 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2218 struct ctf_node *node;
2220 add_type(scanner, $1);
2221 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2222 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2223 node->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
2224 node->u.field_class_specifier.id_type = yylval.s;
2225 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2227 | alias_declaration_specifiers CTF_CONST
2229 struct ctf_node *node;
2232 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2233 node->u.field_class_specifier.type = TYPESPEC_CONST;
2234 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2236 | alias_declaration_specifiers field_class_specifier
2239 bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
2241 | alias_declaration_specifiers IDENTIFIER
2243 struct ctf_node *node;
2245 add_type(scanner, $2);
2247 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2248 node->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
2249 node->u.field_class_specifier.id_type = yylval.s;
2250 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2254 struct_or_variant_declarator_list:
2255 struct_or_variant_declarator
2257 | struct_or_variant_declarator_list CTF_COMMA struct_or_variant_declarator
2260 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2264 struct_or_variant_declarator:
2267 | CTF_COLON unary_expression
2269 | declarator CTF_COLON unary_expression
2272 if (set_parent_node($3, $1))
2273 reparent_error(scanner, "struct_or_variant_declarator");
2280 | enumerator_list CTF_COMMA enumerator
2283 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2290 $$ = make_node(scanner, NODE_ENUMERATOR);
2291 $$->u.enumerator.id = $1;
2295 $$ = make_node(scanner, NODE_ENUMERATOR);
2296 $$->u.enumerator.id = $1;
2300 $$ = make_node(scanner, NODE_ENUMERATOR);
2301 $$->u.enumerator.id = $1;
2303 | CTF_STRING_LITERAL
2305 $$ = make_node(scanner, NODE_ENUMERATOR);
2306 $$->u.enumerator.id = $1;
2308 | IDENTIFIER CTF_EQUAL unary_expression_or_range
2310 $$ = make_node(scanner, NODE_ENUMERATOR);
2311 $$->u.enumerator.id = $1;
2312 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2314 | ID_TYPE CTF_EQUAL unary_expression_or_range
2316 $$ = make_node(scanner, NODE_ENUMERATOR);
2317 $$->u.enumerator.id = $1;
2318 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2320 | keywords CTF_EQUAL unary_expression_or_range
2322 $$ = make_node(scanner, NODE_ENUMERATOR);
2323 $$->u.enumerator.id = $1;
2324 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2326 | CTF_STRING_LITERAL CTF_EQUAL unary_expression_or_range
2328 $$ = make_node(scanner, NODE_ENUMERATOR);
2329 $$->u.enumerator.id = $1;
2330 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2334 abstract_declarator_list:
2337 | abstract_declarator_list CTF_COMMA abstract_declarator
2340 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2344 abstract_declarator:
2345 direct_abstract_declarator
2347 | pointer direct_abstract_declarator
2350 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2354 direct_abstract_declarator:
2357 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2358 $$->u.field_class_declarator.type = TYPEDEC_ID;
2363 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2364 $$->u.field_class_declarator.type = TYPEDEC_ID;
2365 $$->u.field_class_declarator.u.id = $1;
2367 | CTF_LPAREN abstract_declarator CTF_RPAREN
2369 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2370 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2371 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2373 | direct_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2375 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2376 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2377 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2378 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2379 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2381 | direct_abstract_declarator CTF_LSBRAC CTF_RSBRAC
2383 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2384 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2385 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2386 $$->u.field_class_declarator.u.nested.abstract_array = 1;
2390 alias_abstract_declarator_list:
2391 alias_abstract_declarator
2393 | alias_abstract_declarator_list CTF_COMMA alias_abstract_declarator
2396 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2400 alias_abstract_declarator:
2401 direct_alias_abstract_declarator
2403 | pointer direct_alias_abstract_declarator
2406 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2410 direct_alias_abstract_declarator:
2413 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2414 $$->u.field_class_declarator.type = TYPEDEC_ID;
2417 | CTF_LPAREN alias_abstract_declarator CTF_RPAREN
2419 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2420 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2421 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2423 | direct_alias_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2425 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2426 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2427 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2428 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2429 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2431 | direct_alias_abstract_declarator CTF_LSBRAC CTF_RSBRAC
2433 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2434 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2435 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2436 $$->u.field_class_declarator.u.nested.abstract_array = 1;
2443 | pointer direct_declarator
2446 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2453 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2454 $$->u.field_class_declarator.type = TYPEDEC_ID;
2455 $$->u.field_class_declarator.u.id = $1;
2457 | CTF_LPAREN declarator CTF_RPAREN
2459 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2460 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2461 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2463 | direct_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2465 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2466 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2467 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2468 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2469 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2473 field_class_declarator:
2474 direct_field_class_declarator
2476 | pointer direct_field_class_declarator
2479 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2483 direct_field_class_declarator:
2486 add_type(scanner, $1);
2487 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2488 $$->u.field_class_declarator.type = TYPEDEC_ID;
2489 $$->u.field_class_declarator.u.id = $1;
2491 | CTF_LPAREN field_class_declarator CTF_RPAREN
2493 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2494 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2495 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2497 | direct_field_class_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2499 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2500 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2501 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2502 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2503 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2510 $$ = make_node(scanner, NODE_POINTER);
2514 $$ = make_node(scanner, NODE_POINTER);
2515 bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
2517 | CTF_STAR type_qualifier_list pointer
2519 $$ = make_node(scanner, NODE_POINTER);
2520 $$->u.pointer.const_qualifier = 1;
2521 bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
2525 type_qualifier_list:
2526 /* pointer assumes only const type qualifier */
2528 | type_qualifier_list CTF_CONST
2531 /* 2.3: CTF-specific declarations */
2533 ctf_assignment_expression_list:
2534 ctf_assignment_expression CTF_SEMICOLON
2536 | ctf_assignment_expression_list ctf_assignment_expression CTF_SEMICOLON
2539 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2543 ctf_assignment_expression:
2544 unary_expression CTF_EQUAL unary_expression
2547 * Because we have left and right, cannot use
2550 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2551 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2552 if ($1->u.unary_expression.type != UNARY_STRING)
2553 reparent_error(scanner, "ctf_assignment_expression left expects string");
2554 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
2556 | unary_expression CTF_TYPEASSIGN declaration_specifiers /* Only allow struct */
2559 * Because we have left and right, cannot use
2562 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2563 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2564 if ($1->u.unary_expression.type != UNARY_STRING)
2565 reparent_error(scanner, "ctf_assignment_expression left expects string");
2566 bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
2568 | declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list
2570 struct ctf_node *list;
2572 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2573 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2574 _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2575 $$ = make_node(scanner, NODE_TYPEDEF);
2576 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2577 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2579 | CTF_TYPEDEF declaration_specifiers field_class_declarator_list
2581 struct ctf_node *list;
2583 $$ = make_node(scanner, NODE_TYPEDEF);
2584 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2585 $$->u.field_class_def.field_class_specifier_list = list;
2586 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2587 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2589 | declaration_specifiers CTF_TYPEDEF field_class_declarator_list
2591 struct ctf_node *list;
2593 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2594 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2595 $$ = make_node(scanner, NODE_TYPEDEF);
2596 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2597 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2599 | CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
2601 struct ctf_node *list;
2603 $$ = make_node(scanner, NODE_TYPEALIAS);
2604 $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2605 $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2607 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2608 $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
2609 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2610 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
2612 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2613 $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
2614 _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2615 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);