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_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_SPEC(currentCtfScanner->logger, "Trying to reparent root node.");
810 if (parent->type == NODE_ROOT) {
811 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.event);
817 if (parent->type == NODE_ROOT) {
818 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.stream);
824 if (parent->type == NODE_ROOT) {
825 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.env);
831 if (parent->type == NODE_ROOT) {
832 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.trace);
838 if (parent->type == NODE_ROOT) {
839 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.clock);
845 if (parent->type == NODE_ROOT) {
846 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.callsite);
852 case NODE_CTF_EXPRESSION:
853 return reparent_ctf_expression(node, parent);
854 case NODE_UNARY_EXPRESSION:
855 if (parent->type == NODE_TYPE_DECLARATOR)
856 parent->u.field_class_declarator.bitfield_len = node;
862 return reparent_typedef(node, parent);
863 case NODE_TYPEALIAS_TARGET:
864 if (parent->type == NODE_TYPEALIAS)
865 parent->u.field_class_alias.target = node;
869 case NODE_TYPEALIAS_ALIAS:
870 if (parent->type == NODE_TYPEALIAS)
871 parent->u.field_class_alias.alias = node;
876 return reparent_field_class_alias(node, parent);
879 if (parent->type == NODE_TYPE_DECLARATOR) {
880 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_declarator.pointers);
884 case NODE_TYPE_DECLARATOR:
885 return reparent_field_class_declarator(node, parent);
887 case NODE_TYPE_SPECIFIER_LIST:
888 return reparent_field_class_specifier_list(node, parent);
890 case NODE_TYPE_SPECIFIER:
891 return reparent_field_class_specifier(node, parent);
893 case NODE_FLOATING_POINT:
899 return -EINVAL; /* Dealt with internally within grammar */
901 case NODE_ENUMERATOR:
902 if (parent->type == NODE_ENUM) {
903 _bt_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
908 case NODE_STRUCT_OR_VARIANT_DECLARATION:
909 switch (parent->type) {
911 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
914 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
923 BT_CPPLOGE_SPEC(currentCtfScanner->logger, "Unknown node type: node-type={}", parent->type);
930 void yyerror(struct ctf_scanner *scanner, yyscan_t yyscanner, const char *str)
932 _BT_CPPLOGE_APPEND_CAUSE_LINENO(currentCtfScanner->logger,
933 yyget_lineno(scanner->scanner),
934 "{}: token=\"{}\"", str, yyget_text(scanner->scanner));
937 #define reparent_error(scanner, str) \
939 yyerror(scanner, scanner->scanner, YY_("reparent_error: " str)); \
943 static struct ctf_ast *ctf_ast_alloc(struct ctf_scanner *scanner)
947 ast = (ctf_ast *) objstack_alloc(scanner->objstack, sizeof(*ast));
950 ast->root.type = NODE_ROOT;
951 BT_INIT_LIST_HEAD(&ast->root.tmp_head);
952 BT_INIT_LIST_HEAD(&ast->root.u.root.declaration_list);
953 BT_INIT_LIST_HEAD(&ast->root.u.root.trace);
954 BT_INIT_LIST_HEAD(&ast->root.u.root.env);
955 BT_INIT_LIST_HEAD(&ast->root.u.root.stream);
956 BT_INIT_LIST_HEAD(&ast->root.u.root.event);
957 BT_INIT_LIST_HEAD(&ast->root.u.root.clock);
958 BT_INIT_LIST_HEAD(&ast->root.u.root.callsite);
962 int ctf_scanner_append_ast(struct ctf_scanner *scanner, FILE *input)
964 /* Start processing new stream */
965 struct ClearCurrentCtfScanner {
966 ~ClearCurrentCtfScanner() {
967 currentCtfScanner = nullptr;
971 currentCtfScanner = scanner;
972 yyrestart(input, scanner->scanner);
973 return yyparse(scanner, scanner->scanner);
976 struct ctf_scanner *ctf_scanner_alloc(const bt2c::Logger &parentLogger)
978 ctf_scanner *scanner = new ctf_scanner {parentLogger};
979 int ret = yylex_init_extra(scanner, &scanner->scanner);
981 BT_CPPLOGE_SPEC(scanner->logger, "yylex_init_extra() failed: ret={}", ret);
982 goto cleanup_scanner;
984 scanner->objstack = objstack_create(scanner->logger);
985 if (!scanner->objstack)
987 scanner->ast = ctf_ast_alloc(scanner);
989 goto cleanup_objstack;
990 init_scope(&scanner->root_scope, NULL);
991 scanner->cs = &scanner->root_scope;
996 objstack_destroy(scanner->objstack);
998 ret = yylex_destroy(scanner->scanner);
1000 BT_CPPLOGE_SPEC(scanner->logger, "yylex_destroy() failed: scanner-addr={}, ret={}",
1001 fmt::ptr(scanner), ret);
1007 void ctf_scanner_free(struct ctf_scanner *scanner)
1014 struct ctf_scanner_scope *scope = scanner->cs;
1017 struct ctf_scanner_scope *parent = scope->parent;
1018 finalize_scope(scope);
1021 * The root scope is allocated within the ctf_scanner structure,
1022 * do doesn't need freeing. All others are allocated on their
1025 if (scope != &scanner->root_scope)
1031 objstack_destroy(scanner->objstack);
1032 ret = yylex_destroy(scanner->scanner);
1034 BT_CPPLOGE_SPEC(currentCtfScanner->logger, "yylex_destroy() failed: scanner-addr={}, ret={}",
1035 fmt::ptr(scanner), ret);
1040 * The bison-provided version of strlen (yystrlen) generates a benign
1041 * -Wnull-dereference warning. That version is used when building on cygwin,
1042 * for example, but you can also enable it by hand (to test) by removing the
1043 * preprocessor conditional around it.
1045 * Define yystrlen such that it will always use strlen. As far as we know,
1046 * strlen provided by all the platforms we use is reliable.
1048 #define yystrlen strlen
1053 * This ends up in parser.h and makes sure those who want to include it pass
1054 * through parser-wrap.h.
1057 #ifndef ALLOW_INCLUDE_PARSER_H
1058 # error "Don't include parser.h directly, include parser-wrap.h instead."
1061 #include "plugins/ctf/common/src/metadata/tsdl/scanner.hpp"
1065 void setstring(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src);
1067 int import_string(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src, char delim);
1073 %parse-param {struct ctf_scanner *scanner}
1074 %parse-param {yyscan_t yyscanner}
1075 %lex-param {yyscan_t yyscanner}
1077 * Expect two shift-reduce conflicts. Caused by enum name-opt : type {}
1078 * vs struct { int :value; } (unnamed bit-field). The default is to
1079 * shift, so whenever we encounter an enumeration, we are doing the
1080 * proper thing (shift). It is illegal to declare an enumeration
1081 * "bit-field", so it is OK if this situation ends up in a parsing
1086 %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
1087 %token <s> IDENTIFIER ID_TYPE
1092 unsigned long long ull;
1098 %type <s> CTF_STRING_LITERAL CTF_CHARACTER_LITERAL
1102 %type <ull> CTF_INTEGER_LITERAL
1103 %type <n> postfix_expression unary_expression unary_expression_or_range
1105 %type <n> declaration
1106 %type <n> event_declaration
1107 %type <n> stream_declaration
1108 %type <n> env_declaration
1109 %type <n> trace_declaration
1110 %type <n> clock_declaration
1111 %type <n> callsite_declaration
1112 %type <n> integer_declaration_specifiers
1113 %type <n> declaration_specifiers
1114 %type <n> alias_declaration_specifiers
1116 %type <n> field_class_declarator_list
1117 %type <n> integer_field_class_specifier
1118 %type <n> field_class_specifier
1119 %type <n> struct_class_specifier
1120 %type <n> variant_field_class_specifier
1121 %type <n> enum_field_class_specifier
1122 %type <n> struct_or_variant_declaration_list
1123 %type <n> struct_or_variant_declaration
1124 %type <n> struct_or_variant_declarator_list
1125 %type <n> struct_or_variant_declarator
1126 %type <n> enumerator_list
1127 %type <n> enumerator
1128 %type <n> abstract_declarator_list
1129 %type <n> abstract_declarator
1130 %type <n> direct_abstract_declarator
1131 %type <n> alias_abstract_declarator_list
1132 %type <n> alias_abstract_declarator
1133 %type <n> direct_alias_abstract_declarator
1134 %type <n> declarator
1135 %type <n> direct_declarator
1136 %type <n> field_class_declarator
1137 %type <n> direct_field_class_declarator
1139 %type <n> ctf_assignment_expression_list
1140 %type <n> ctf_assignment_expression
1147 if (set_parent_node($1, &ctf_scanner_get_ast(scanner)->root))
1148 reparent_error(scanner, "error reparenting to root");
1152 if (set_parent_node($2, &ctf_scanner_get_ast(scanner)->root))
1153 reparent_error(scanner, "error reparenting to root");
1182 | CTF_FLOATING_POINT
1215 /* 2: Phrase structure grammar */
1220 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1221 $$->u.unary_expression.type = UNARY_STRING;
1222 $$->u.unary_expression.u.string = yylval.s;
1226 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1227 $$->u.unary_expression.type = UNARY_STRING;
1228 $$->u.unary_expression.u.string = yylval.s;
1232 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1233 $$->u.unary_expression.type = UNARY_STRING;
1234 $$->u.unary_expression.u.string = yylval.s;
1236 | CTF_INTEGER_LITERAL
1238 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1239 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1240 $$->u.unary_expression.u.unsigned_constant = $1;
1242 | CTF_STRING_LITERAL
1244 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1245 $$->u.unary_expression.type = UNARY_STRING;
1246 $$->u.unary_expression.u.string = $1;
1248 | CTF_CHARACTER_LITERAL
1250 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1251 $$->u.unary_expression.type = UNARY_STRING;
1252 $$->u.unary_expression.u.string = $1;
1254 | CTF_LPAREN unary_expression CTF_RPAREN
1258 | postfix_expression CTF_LSBRAC unary_expression CTF_RSBRAC
1260 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1261 $$->u.unary_expression.type = UNARY_SBRAC;
1262 $$->u.unary_expression.u.sbrac_exp = $3;
1263 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1264 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1266 | postfix_expression CTF_DOT IDENTIFIER
1268 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1269 $$->u.unary_expression.type = UNARY_STRING;
1270 $$->u.unary_expression.u.string = yylval.s;
1271 $$->u.unary_expression.link = UNARY_DOTLINK;
1272 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1273 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1275 | postfix_expression CTF_DOT ID_TYPE
1277 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1278 $$->u.unary_expression.type = UNARY_STRING;
1279 $$->u.unary_expression.u.string = yylval.s;
1280 $$->u.unary_expression.link = UNARY_DOTLINK;
1281 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1282 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1284 | postfix_expression CTF_DOT keywords
1286 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1287 $$->u.unary_expression.type = UNARY_STRING;
1288 $$->u.unary_expression.u.string = yylval.s;
1289 $$->u.unary_expression.link = UNARY_DOTLINK;
1290 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1291 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1293 | postfix_expression CTF_RARROW IDENTIFIER
1295 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1296 $$->u.unary_expression.type = UNARY_STRING;
1297 $$->u.unary_expression.u.string = yylval.s;
1298 $$->u.unary_expression.link = UNARY_ARROWLINK;
1299 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1300 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1302 | postfix_expression CTF_RARROW ID_TYPE
1304 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1305 $$->u.unary_expression.type = UNARY_STRING;
1306 $$->u.unary_expression.u.string = yylval.s;
1307 $$->u.unary_expression.link = UNARY_ARROWLINK;
1308 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1309 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1316 | CTF_PLUS postfix_expression
1319 if ($$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
1320 && $$->u.unary_expression.type != UNARY_SIGNED_CONSTANT) {
1321 reparent_error(scanner, "expecting numeric constant");
1324 | CTF_MINUS postfix_expression
1327 if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1328 $$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
1329 $$->u.unary_expression.u.signed_constant =
1330 -($$->u.unary_expression.u.unsigned_constant);
1331 } else if ($$->u.unary_expression.type == UNARY_SIGNED_CONSTANT) {
1332 $$->u.unary_expression.u.signed_constant =
1333 -($$->u.unary_expression.u.signed_constant);
1335 reparent_error(scanner, "expecting numeric constant");
1340 unary_expression_or_range:
1341 unary_expression CTF_DOTDOTDOT unary_expression
1344 _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
1345 $3->u.unary_expression.link = UNARY_DOTDOTDOT;
1351 /* 2.2: Declarations */
1354 declaration_specifiers CTF_SEMICOLON
1358 | stream_declaration
1366 | callsite_declaration
1368 | declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
1370 struct ctf_node *list;
1372 $$ = make_node(scanner, NODE_TYPEDEF);
1373 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1374 $$->u.field_class_def.field_class_specifier_list = list;
1375 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1376 _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1377 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1379 | CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
1381 struct ctf_node *list;
1383 $$ = make_node(scanner, NODE_TYPEDEF);
1384 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1385 $$->u.field_class_def.field_class_specifier_list = list;
1386 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1387 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1389 | declaration_specifiers CTF_TYPEDEF field_class_declarator_list CTF_SEMICOLON
1391 struct ctf_node *list;
1393 $$ = make_node(scanner, NODE_TYPEDEF);
1394 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1395 $$->u.field_class_def.field_class_specifier_list = list;
1396 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1397 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1399 | CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
1401 struct ctf_node *list;
1403 $$ = make_node(scanner, NODE_TYPEALIAS);
1404 $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1405 $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1407 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1408 $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
1409 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1410 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
1412 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1413 $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
1414 _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1415 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
1420 event_declaration_begin event_declaration_end
1422 $$ = make_node(scanner, NODE_EVENT);
1424 | event_declaration_begin ctf_assignment_expression_list event_declaration_end
1426 $$ = make_node(scanner, NODE_EVENT);
1427 if (set_parent_node($2, $$))
1428 reparent_error(scanner, "event_declaration");
1432 event_declaration_begin:
1434 { push_scope(scanner); }
1437 event_declaration_end:
1438 CTF_RBRAC CTF_SEMICOLON
1439 { pop_scope(scanner); }
1444 stream_declaration_begin stream_declaration_end
1446 $$ = make_node(scanner, NODE_STREAM);
1448 | stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
1450 $$ = make_node(scanner, NODE_STREAM);
1451 if (set_parent_node($2, $$))
1452 reparent_error(scanner, "stream_declaration");
1456 stream_declaration_begin:
1457 CTF_STREAM CTF_LBRAC
1458 { push_scope(scanner); }
1461 stream_declaration_end:
1462 CTF_RBRAC CTF_SEMICOLON
1463 { pop_scope(scanner); }
1467 env_declaration_begin env_declaration_end
1469 $$ = make_node(scanner, NODE_ENV);
1471 | env_declaration_begin ctf_assignment_expression_list env_declaration_end
1473 $$ = make_node(scanner, NODE_ENV);
1474 if (set_parent_node($2, $$))
1475 reparent_error(scanner, "env declaration");
1479 env_declaration_begin:
1481 { push_scope(scanner); }
1484 env_declaration_end:
1485 CTF_RBRAC CTF_SEMICOLON
1486 { pop_scope(scanner); }
1490 trace_declaration_begin trace_declaration_end
1492 $$ = make_node(scanner, NODE_TRACE);
1494 | trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
1496 $$ = make_node(scanner, NODE_TRACE);
1497 if (set_parent_node($2, $$))
1498 reparent_error(scanner, "trace_declaration");
1502 trace_declaration_begin:
1504 { push_scope(scanner); }
1507 trace_declaration_end:
1508 CTF_RBRAC CTF_SEMICOLON
1509 { pop_scope(scanner); }
1513 CTF_CLOCK clock_declaration_begin clock_declaration_end
1515 $$ = make_node(scanner, NODE_CLOCK);
1517 | CTF_CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
1519 $$ = make_node(scanner, NODE_CLOCK);
1520 if (set_parent_node($3, $$))
1521 reparent_error(scanner, "trace_declaration");
1525 clock_declaration_begin:
1527 { push_scope(scanner); }
1530 clock_declaration_end:
1531 CTF_RBRAC CTF_SEMICOLON
1532 { pop_scope(scanner); }
1535 callsite_declaration:
1536 CTF_CALLSITE callsite_declaration_begin callsite_declaration_end
1538 $$ = make_node(scanner, NODE_CALLSITE);
1540 | CTF_CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
1542 $$ = make_node(scanner, NODE_CALLSITE);
1543 if (set_parent_node($3, $$))
1544 reparent_error(scanner, "trace_declaration");
1548 callsite_declaration_begin:
1550 { push_scope(scanner); }
1553 callsite_declaration_end:
1554 CTF_RBRAC CTF_SEMICOLON
1555 { pop_scope(scanner); }
1558 integer_declaration_specifiers:
1561 struct ctf_node *node;
1563 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1564 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1565 node->u.field_class_specifier.type = TYPESPEC_CONST;
1566 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1568 | integer_field_class_specifier
1570 struct ctf_node *node;
1572 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1574 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1576 | integer_declaration_specifiers CTF_CONST
1578 struct ctf_node *node;
1581 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1582 node->u.field_class_specifier.type = TYPESPEC_CONST;
1583 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1585 | integer_declaration_specifiers integer_field_class_specifier
1588 bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
1592 declaration_specifiers:
1595 struct ctf_node *node;
1597 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1598 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1599 node->u.field_class_specifier.type = TYPESPEC_CONST;
1600 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1602 | field_class_specifier
1604 struct ctf_node *node;
1606 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1608 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1610 | declaration_specifiers CTF_CONST
1612 struct ctf_node *node;
1615 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1616 node->u.field_class_specifier.type = TYPESPEC_CONST;
1617 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1619 | declaration_specifiers field_class_specifier
1622 bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
1626 field_class_declarator_list:
1627 field_class_declarator
1629 | field_class_declarator_list CTF_COMMA field_class_declarator
1632 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1636 integer_field_class_specifier:
1639 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1640 $$->u.field_class_specifier.type = TYPESPEC_CHAR;
1644 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1645 $$->u.field_class_specifier.type = TYPESPEC_SHORT;
1649 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1650 $$->u.field_class_specifier.type = TYPESPEC_INT;
1654 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1655 $$->u.field_class_specifier.type = TYPESPEC_LONG;
1659 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1660 $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
1664 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1665 $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
1669 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1670 $$->u.field_class_specifier.type = TYPESPEC_BOOL;
1674 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1675 $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
1676 $$->u.field_class_specifier.id_type = yylval.s;
1678 | CTF_INTEGER CTF_LBRAC CTF_RBRAC
1680 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1681 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1682 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1684 | CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1686 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1687 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1688 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1689 if (set_parent_node($3, $$->u.field_class_specifier.node))
1690 reparent_error(scanner, "integer reparent error");
1694 field_class_specifier:
1697 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1698 $$->u.field_class_specifier.type = TYPESPEC_VOID;
1702 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1703 $$->u.field_class_specifier.type = TYPESPEC_CHAR;
1707 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1708 $$->u.field_class_specifier.type = TYPESPEC_SHORT;
1712 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1713 $$->u.field_class_specifier.type = TYPESPEC_INT;
1717 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1718 $$->u.field_class_specifier.type = TYPESPEC_LONG;
1722 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1723 $$->u.field_class_specifier.type = TYPESPEC_FLOAT;
1727 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1728 $$->u.field_class_specifier.type = TYPESPEC_DOUBLE;
1732 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1733 $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
1737 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1738 $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
1742 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1743 $$->u.field_class_specifier.type = TYPESPEC_BOOL;
1747 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1748 $$->u.field_class_specifier.type = TYPESPEC_COMPLEX;
1752 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1753 $$->u.field_class_specifier.type = TYPESPEC_IMAGINARY;
1757 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1758 $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
1759 $$->u.field_class_specifier.id_type = yylval.s;
1761 | CTF_FLOATING_POINT CTF_LBRAC CTF_RBRAC
1763 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1764 $$->u.field_class_specifier.type = TYPESPEC_FLOATING_POINT;
1765 $$->u.field_class_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1767 | CTF_FLOATING_POINT CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1769 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1770 $$->u.field_class_specifier.type = TYPESPEC_FLOATING_POINT;
1771 $$->u.field_class_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1772 if (set_parent_node($3, $$->u.field_class_specifier.node))
1773 reparent_error(scanner, "floating point reparent error");
1775 | CTF_INTEGER CTF_LBRAC CTF_RBRAC
1777 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1778 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1779 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1781 | CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1783 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1784 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1785 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1786 if (set_parent_node($3, $$->u.field_class_specifier.node))
1787 reparent_error(scanner, "integer reparent error");
1791 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1792 $$->u.field_class_specifier.type = TYPESPEC_STRING;
1793 $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1795 | CTF_STRING CTF_LBRAC CTF_RBRAC
1797 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1798 $$->u.field_class_specifier.type = TYPESPEC_STRING;
1799 $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1801 | CTF_STRING CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1803 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1804 $$->u.field_class_specifier.type = TYPESPEC_STRING;
1805 $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1806 if (set_parent_node($3, $$->u.field_class_specifier.node))
1807 reparent_error(scanner, "string reparent error");
1809 | CTF_ENUM enum_field_class_specifier
1811 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1812 $$->u.field_class_specifier.type = TYPESPEC_ENUM;
1813 $$->u.field_class_specifier.node = $2;
1815 | CTF_VARIANT variant_field_class_specifier
1817 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1818 $$->u.field_class_specifier.type = TYPESPEC_VARIANT;
1819 $$->u.field_class_specifier.node = $2;
1821 | CTF_STRUCT struct_class_specifier
1823 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1824 $$->u.field_class_specifier.type = TYPESPEC_STRUCT;
1825 $$->u.field_class_specifier.node = $2;
1829 struct_class_specifier:
1830 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1832 $$ = make_node(scanner, NODE_STRUCT);
1833 $$->u._struct.has_body = 1;
1834 if ($2 && set_parent_node($2, $$))
1835 reparent_error(scanner, "struct reparent error");
1837 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1839 $$ = make_node(scanner, NODE_STRUCT);
1840 $$->u._struct.has_body = 1;
1841 $$->u._struct.name = $1;
1842 if ($3 && set_parent_node($3, $$))
1843 reparent_error(scanner, "struct reparent error");
1845 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1847 $$ = make_node(scanner, NODE_STRUCT);
1848 $$->u._struct.has_body = 1;
1849 $$->u._struct.name = $1;
1850 if ($3 && set_parent_node($3, $$))
1851 reparent_error(scanner, "struct reparent error");
1855 $$ = make_node(scanner, NODE_STRUCT);
1856 $$->u._struct.has_body = 0;
1857 $$->u._struct.name = $1;
1861 $$ = make_node(scanner, NODE_STRUCT);
1862 $$->u._struct.has_body = 0;
1863 $$->u._struct.name = $1;
1865 | struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1867 $$ = make_node(scanner, NODE_STRUCT);
1868 $$->u._struct.has_body = 1;
1869 bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
1870 if ($2 && set_parent_node($2, $$))
1871 reparent_error(scanner, "struct reparent error");
1873 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1875 $$ = make_node(scanner, NODE_STRUCT);
1876 $$->u._struct.has_body = 1;
1877 $$->u._struct.name = $1;
1878 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1879 if ($3 && set_parent_node($3, $$))
1880 reparent_error(scanner, "struct reparent error");
1882 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1884 $$ = make_node(scanner, NODE_STRUCT);
1885 $$->u._struct.has_body = 1;
1886 $$->u._struct.name = $1;
1887 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1888 if ($3 && set_parent_node($3, $$))
1889 reparent_error(scanner, "struct reparent error");
1893 struct_declaration_begin:
1895 { push_scope(scanner); }
1898 struct_declaration_end:
1900 { pop_scope(scanner); }
1903 variant_field_class_specifier:
1904 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1906 $$ = make_node(scanner, NODE_VARIANT);
1907 $$->u.variant.has_body = 1;
1908 if ($2 && set_parent_node($2, $$))
1909 reparent_error(scanner, "variant reparent error");
1911 | CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1913 $$ = make_node(scanner, NODE_VARIANT);
1914 $$->u.variant.has_body = 1;
1915 $$->u.variant.choice = $2;
1916 if ($5 && set_parent_node($5, $$))
1917 reparent_error(scanner, "variant reparent error");
1919 | CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1921 $$ = make_node(scanner, NODE_VARIANT);
1922 $$->u.variant.has_body = 1;
1923 $$->u.variant.choice = $2;
1924 if ($5 && set_parent_node($5, $$))
1925 reparent_error(scanner, "variant reparent error");
1927 | IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1929 $$ = make_node(scanner, NODE_VARIANT);
1930 $$->u.variant.has_body = 1;
1931 $$->u.variant.name = $1;
1932 if ($3 && set_parent_node($3, $$))
1933 reparent_error(scanner, "variant reparent error");
1935 | IDENTIFIER CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1937 $$ = make_node(scanner, NODE_VARIANT);
1938 $$->u.variant.has_body = 1;
1939 $$->u.variant.name = $1;
1940 $$->u.variant.choice = $3;
1941 if ($6 && set_parent_node($6, $$))
1942 reparent_error(scanner, "variant reparent error");
1944 | IDENTIFIER CTF_LT IDENTIFIER CTF_GT
1946 $$ = make_node(scanner, NODE_VARIANT);
1947 $$->u.variant.has_body = 0;
1948 $$->u.variant.name = $1;
1949 $$->u.variant.choice = $3;
1951 | IDENTIFIER CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1953 $$ = make_node(scanner, NODE_VARIANT);
1954 $$->u.variant.has_body = 1;
1955 $$->u.variant.name = $1;
1956 $$->u.variant.choice = $3;
1957 if ($6 && set_parent_node($6, $$))
1958 reparent_error(scanner, "variant reparent error");
1960 | IDENTIFIER CTF_LT ID_TYPE CTF_GT
1962 $$ = make_node(scanner, NODE_VARIANT);
1963 $$->u.variant.has_body = 0;
1964 $$->u.variant.name = $1;
1965 $$->u.variant.choice = $3;
1967 | ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1969 $$ = make_node(scanner, NODE_VARIANT);
1970 $$->u.variant.has_body = 1;
1971 $$->u.variant.name = $1;
1972 if ($3 && set_parent_node($3, $$))
1973 reparent_error(scanner, "variant reparent error");
1975 | ID_TYPE CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1977 $$ = make_node(scanner, NODE_VARIANT);
1978 $$->u.variant.has_body = 1;
1979 $$->u.variant.name = $1;
1980 $$->u.variant.choice = $3;
1981 if ($6 && set_parent_node($6, $$))
1982 reparent_error(scanner, "variant reparent error");
1984 | ID_TYPE CTF_LT IDENTIFIER CTF_GT
1986 $$ = make_node(scanner, NODE_VARIANT);
1987 $$->u.variant.has_body = 0;
1988 $$->u.variant.name = $1;
1989 $$->u.variant.choice = $3;
1991 | ID_TYPE CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1993 $$ = make_node(scanner, NODE_VARIANT);
1994 $$->u.variant.has_body = 1;
1995 $$->u.variant.name = $1;
1996 $$->u.variant.choice = $3;
1997 if ($6 && set_parent_node($6, $$))
1998 reparent_error(scanner, "variant reparent error");
2000 | ID_TYPE CTF_LT ID_TYPE CTF_GT
2002 $$ = make_node(scanner, NODE_VARIANT);
2003 $$->u.variant.has_body = 0;
2004 $$->u.variant.name = $1;
2005 $$->u.variant.choice = $3;
2009 variant_declaration_begin:
2011 { push_scope(scanner); }
2014 variant_declaration_end:
2016 { pop_scope(scanner); }
2019 enum_field_class_specifier:
2020 CTF_LBRAC enumerator_list CTF_RBRAC
2022 $$ = make_node(scanner, NODE_ENUM);
2023 $$->u._enum.has_body = 1;
2024 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
2026 | CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2028 $$ = make_node(scanner, NODE_ENUM);
2029 $$->u._enum.has_body = 1;
2030 ($$)->u._enum.container_field_class = $2;
2031 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2033 | IDENTIFIER CTF_LBRAC enumerator_list CTF_RBRAC
2035 $$ = make_node(scanner, NODE_ENUM);
2036 $$->u._enum.has_body = 1;
2037 $$->u._enum.enum_id = $1;
2038 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2040 | IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2042 $$ = make_node(scanner, NODE_ENUM);
2043 $$->u._enum.has_body = 1;
2044 $$->u._enum.enum_id = $1;
2045 ($$)->u._enum.container_field_class = $3;
2046 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2048 | ID_TYPE CTF_LBRAC enumerator_list CTF_RBRAC
2050 $$ = make_node(scanner, NODE_ENUM);
2051 $$->u._enum.has_body = 1;
2052 $$->u._enum.enum_id = $1;
2053 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2055 | ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2057 $$ = make_node(scanner, NODE_ENUM);
2058 $$->u._enum.has_body = 1;
2059 $$->u._enum.enum_id = $1;
2060 ($$)->u._enum.container_field_class = $3;
2061 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2063 | CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2065 $$ = make_node(scanner, NODE_ENUM);
2066 $$->u._enum.has_body = 1;
2067 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
2069 | CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2071 $$ = make_node(scanner, NODE_ENUM);
2072 $$->u._enum.has_body = 1;
2073 ($$)->u._enum.container_field_class = $2;
2074 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2076 | IDENTIFIER CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2078 $$ = make_node(scanner, NODE_ENUM);
2079 $$->u._enum.has_body = 1;
2080 $$->u._enum.enum_id = $1;
2081 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2083 | IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2085 $$ = make_node(scanner, NODE_ENUM);
2086 $$->u._enum.has_body = 1;
2087 $$->u._enum.enum_id = $1;
2088 ($$)->u._enum.container_field_class = $3;
2089 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2093 $$ = make_node(scanner, NODE_ENUM);
2094 $$->u._enum.has_body = 0;
2095 $$->u._enum.enum_id = $1;
2097 | ID_TYPE CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2099 $$ = make_node(scanner, NODE_ENUM);
2100 $$->u._enum.has_body = 1;
2101 $$->u._enum.enum_id = $1;
2102 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2104 | ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2106 $$ = make_node(scanner, NODE_ENUM);
2107 $$->u._enum.has_body = 1;
2108 $$->u._enum.enum_id = $1;
2109 ($$)->u._enum.container_field_class = $3;
2110 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2114 $$ = make_node(scanner, NODE_ENUM);
2115 $$->u._enum.has_body = 0;
2116 $$->u._enum.enum_id = $1;
2120 struct_or_variant_declaration_list:
2123 | struct_or_variant_declaration_list struct_or_variant_declaration
2127 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2130 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
2135 struct_or_variant_declaration:
2136 declaration_specifiers struct_or_variant_declarator_list CTF_SEMICOLON
2138 struct ctf_node *list;
2140 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2141 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2142 $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
2143 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2144 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.field_class_declarators);
2146 | declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
2148 struct ctf_node *list;
2150 $$ = make_node(scanner, NODE_TYPEDEF);
2151 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2152 $$->u.field_class_def.field_class_specifier_list = list;
2153 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2154 _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2155 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2157 | CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
2159 struct ctf_node *list;
2161 $$ = make_node(scanner, NODE_TYPEDEF);
2162 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2163 $$->u.field_class_def.field_class_specifier_list = list;
2164 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2165 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2167 | declaration_specifiers CTF_TYPEDEF field_class_declarator_list CTF_SEMICOLON
2169 struct ctf_node *list;
2171 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2172 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2173 $$ = make_node(scanner, NODE_TYPEDEF);
2174 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2175 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2177 | CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
2179 struct ctf_node *list;
2181 $$ = make_node(scanner, NODE_TYPEALIAS);
2182 $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2183 $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2185 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2186 $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
2187 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2188 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
2190 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2191 $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
2192 _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2193 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
2197 alias_declaration_specifiers:
2200 struct ctf_node *node;
2202 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2203 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2204 node->u.field_class_specifier.type = TYPESPEC_CONST;
2205 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2207 | field_class_specifier
2209 struct ctf_node *node;
2211 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2213 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2217 struct ctf_node *node;
2219 add_type(scanner, $1);
2220 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2221 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2222 node->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
2223 node->u.field_class_specifier.id_type = yylval.s;
2224 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2226 | alias_declaration_specifiers CTF_CONST
2228 struct ctf_node *node;
2231 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2232 node->u.field_class_specifier.type = TYPESPEC_CONST;
2233 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2235 | alias_declaration_specifiers field_class_specifier
2238 bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
2240 | alias_declaration_specifiers IDENTIFIER
2242 struct ctf_node *node;
2244 add_type(scanner, $2);
2246 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2247 node->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
2248 node->u.field_class_specifier.id_type = yylval.s;
2249 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2253 struct_or_variant_declarator_list:
2254 struct_or_variant_declarator
2256 | struct_or_variant_declarator_list CTF_COMMA struct_or_variant_declarator
2259 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2263 struct_or_variant_declarator:
2266 | CTF_COLON unary_expression
2268 | declarator CTF_COLON unary_expression
2271 if (set_parent_node($3, $1))
2272 reparent_error(scanner, "struct_or_variant_declarator");
2279 | enumerator_list CTF_COMMA enumerator
2282 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2289 $$ = make_node(scanner, NODE_ENUMERATOR);
2290 $$->u.enumerator.id = $1;
2294 $$ = make_node(scanner, NODE_ENUMERATOR);
2295 $$->u.enumerator.id = $1;
2299 $$ = make_node(scanner, NODE_ENUMERATOR);
2300 $$->u.enumerator.id = $1;
2302 | CTF_STRING_LITERAL
2304 $$ = make_node(scanner, NODE_ENUMERATOR);
2305 $$->u.enumerator.id = $1;
2307 | IDENTIFIER CTF_EQUAL unary_expression_or_range
2309 $$ = make_node(scanner, NODE_ENUMERATOR);
2310 $$->u.enumerator.id = $1;
2311 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2313 | ID_TYPE CTF_EQUAL unary_expression_or_range
2315 $$ = make_node(scanner, NODE_ENUMERATOR);
2316 $$->u.enumerator.id = $1;
2317 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2319 | keywords CTF_EQUAL unary_expression_or_range
2321 $$ = make_node(scanner, NODE_ENUMERATOR);
2322 $$->u.enumerator.id = $1;
2323 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2325 | CTF_STRING_LITERAL CTF_EQUAL unary_expression_or_range
2327 $$ = make_node(scanner, NODE_ENUMERATOR);
2328 $$->u.enumerator.id = $1;
2329 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2333 abstract_declarator_list:
2336 | abstract_declarator_list CTF_COMMA abstract_declarator
2339 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2343 abstract_declarator:
2344 direct_abstract_declarator
2346 | pointer direct_abstract_declarator
2349 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2353 direct_abstract_declarator:
2356 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2357 $$->u.field_class_declarator.type = TYPEDEC_ID;
2362 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2363 $$->u.field_class_declarator.type = TYPEDEC_ID;
2364 $$->u.field_class_declarator.u.id = $1;
2366 | CTF_LPAREN abstract_declarator CTF_RPAREN
2368 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2369 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2370 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2372 | direct_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2374 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2375 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2376 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2377 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2378 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2380 | direct_abstract_declarator CTF_LSBRAC CTF_RSBRAC
2382 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2383 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2384 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2385 $$->u.field_class_declarator.u.nested.abstract_array = 1;
2389 alias_abstract_declarator_list:
2390 alias_abstract_declarator
2392 | alias_abstract_declarator_list CTF_COMMA alias_abstract_declarator
2395 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2399 alias_abstract_declarator:
2400 direct_alias_abstract_declarator
2402 | pointer direct_alias_abstract_declarator
2405 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2409 direct_alias_abstract_declarator:
2412 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2413 $$->u.field_class_declarator.type = TYPEDEC_ID;
2416 | CTF_LPAREN alias_abstract_declarator CTF_RPAREN
2418 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2419 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2420 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2422 | direct_alias_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2424 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2425 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2426 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2427 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2428 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2430 | direct_alias_abstract_declarator CTF_LSBRAC CTF_RSBRAC
2432 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2433 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2434 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2435 $$->u.field_class_declarator.u.nested.abstract_array = 1;
2442 | pointer direct_declarator
2445 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2452 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2453 $$->u.field_class_declarator.type = TYPEDEC_ID;
2454 $$->u.field_class_declarator.u.id = $1;
2456 | CTF_LPAREN declarator CTF_RPAREN
2458 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2459 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2460 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2462 | direct_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2464 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2465 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2466 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2467 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2468 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2472 field_class_declarator:
2473 direct_field_class_declarator
2475 | pointer direct_field_class_declarator
2478 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2482 direct_field_class_declarator:
2485 add_type(scanner, $1);
2486 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2487 $$->u.field_class_declarator.type = TYPEDEC_ID;
2488 $$->u.field_class_declarator.u.id = $1;
2490 | CTF_LPAREN field_class_declarator CTF_RPAREN
2492 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2493 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2494 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2496 | direct_field_class_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2498 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2499 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2500 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2501 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2502 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2509 $$ = make_node(scanner, NODE_POINTER);
2513 $$ = make_node(scanner, NODE_POINTER);
2514 bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
2516 | CTF_STAR type_qualifier_list pointer
2518 $$ = make_node(scanner, NODE_POINTER);
2519 $$->u.pointer.const_qualifier = 1;
2520 bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
2524 type_qualifier_list:
2525 /* pointer assumes only const type qualifier */
2527 | type_qualifier_list CTF_CONST
2530 /* 2.3: CTF-specific declarations */
2532 ctf_assignment_expression_list:
2533 ctf_assignment_expression CTF_SEMICOLON
2535 | ctf_assignment_expression_list ctf_assignment_expression CTF_SEMICOLON
2538 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2542 ctf_assignment_expression:
2543 unary_expression CTF_EQUAL unary_expression
2546 * Because we have left and right, cannot use
2549 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2550 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2551 if ($1->u.unary_expression.type != UNARY_STRING)
2552 reparent_error(scanner, "ctf_assignment_expression left expects string");
2553 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
2555 | unary_expression CTF_TYPEASSIGN declaration_specifiers /* Only allow struct */
2558 * Because we have left and right, cannot use
2561 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2562 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2563 if ($1->u.unary_expression.type != UNARY_STRING)
2564 reparent_error(scanner, "ctf_assignment_expression left expects string");
2565 bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
2567 | declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list
2569 struct ctf_node *list;
2571 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2572 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2573 _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2574 $$ = make_node(scanner, NODE_TYPEDEF);
2575 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2576 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2578 | CTF_TYPEDEF declaration_specifiers field_class_declarator_list
2580 struct ctf_node *list;
2582 $$ = make_node(scanner, NODE_TYPEDEF);
2583 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2584 $$->u.field_class_def.field_class_specifier_list = list;
2585 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2586 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2588 | declaration_specifiers CTF_TYPEDEF field_class_declarator_list
2590 struct ctf_node *list;
2592 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2593 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2594 $$ = make_node(scanner, NODE_TYPEDEF);
2595 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2596 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2598 | CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
2600 struct ctf_node *list;
2602 $$ = make_node(scanner, NODE_TYPEALIAS);
2603 $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2604 $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2606 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2607 $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
2608 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2609 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
2611 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2612 $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
2613 _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2614 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);