3 * SPDX-License-Identifier: MIT
5 * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
7 * Common Trace Format Metadata Grammar.
10 #define BT_LOG_OUTPUT_LEVEL ctf_plugin_metadata_log_level
11 #define BT_LOG_TAG "PLUGIN/CTF/META/PARSER"
12 #include "logging.hpp"
23 #include "common/list.h"
24 #include "common/assert.h"
25 #include "scanner.hpp"
27 #include "objstack.hpp"
29 #include "parser-wrap.hpp"
32 * Avoid warning about "yynerrs" being unused, seen with bison 3.5.1 + clang 15
35 BT_DIAG_IGNORE_UNUSED_BUT_SET_VARIABLE
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;
51 int yylex(union YYSTYPE *yyval, yyscan_t yyscanner);
53 int yylex_init_extra(struct ctf_scanner *scanner, yyscan_t * ptr_yy_globals);
55 int yylex_destroy(yyscan_t yyscanner);
57 void yyrestart(FILE * in_str, yyscan_t yyscanner);
59 int yyget_lineno(yyscan_t yyscanner);
61 char *yyget_text(yyscan_t yyscanner);
64 * Static node for out of memory errors. Only "type" is used. lineno is
65 * always left at 0. The rest of the node content can be overwritten,
68 static struct ctf_node error_node = {
78 const char *node_type(struct ctf_node *node)
81 #define ENTRY(S) case S: return #S;
82 FOREACH_CTF_NODES(ENTRY)
89 void setstring(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src)
91 lvalp->s = (char *) objstack_alloc(scanner->objstack, strlen(src) + 1);
92 strcpy(lvalp->s, src);
96 int str_check(size_t str_len, size_t offset, size_t len)
99 if (offset + len < offset)
101 if (offset + len > str_len)
107 int bt_isodigit(int c)
125 int parse_base_sequence(const char *src, size_t len, size_t pos,
126 char *buffer, size_t *buf_len, int base)
128 const size_t max_char = 3;
131 while (!str_check(len, pos, 1) && nr_char < max_char) {
136 buffer[nr_char++] = c;
139 } else if (base == 16) {
141 buffer[nr_char++] = c;
146 /* Unsupported base */
150 BT_ASSERT_DBG(nr_char > 0);
151 buffer[nr_char] = '\0';
157 int import_basic_string(struct ctf_scanner *scanner, YYSTYPE *lvalp,
158 size_t len, const char *src, char delim)
160 size_t pos = 0, dpos = 0;
162 if (str_check(len, pos, 1))
164 if (src[pos++] != delim)
167 while (src[pos] != delim) {
170 if (str_check(len, pos, 1))
174 if (str_check(len, pos, 1))
224 if (parse_base_sequence(src, len, pos - 1,
225 oct_buffer, &oct_len, 8))
227 c = strtoul(&oct_buffer[0], NULL, 8);
236 if (parse_base_sequence(src, len, pos,
237 hex_buffer, &hex_len, 16))
239 c = strtoul(&hex_buffer[0], NULL, 16);
247 if (str_check(len, dpos, 1))
249 lvalp->s[dpos++] = c;
252 if (str_check(len, dpos, 1))
254 lvalp->s[dpos++] = '\0';
256 if (str_check(len, pos, 1))
258 if (src[pos++] != delim)
261 if (str_check(len, pos, 1))
263 if (src[pos] != '\0')
268 int import_string(struct ctf_scanner *scanner, YYSTYPE *lvalp,
269 const char *src, char delim)
273 len = strlen(src) + 1;
274 lvalp->s = (char *) objstack_alloc(scanner->objstack, len);
276 // TODO: import wide string
277 _BT_LOGE_APPEND_CAUSE_LINENO(yyget_lineno(scanner),
278 "wide characters are not supported as of this version: "
279 "scanner-addr=%p", scanner);
282 return import_basic_string(scanner, lvalp, len, src, delim);
286 static void init_scope(struct ctf_scanner_scope *scope,
287 struct ctf_scanner_scope *parent)
289 scope->parent = parent;
290 scope->classes = g_hash_table_new_full(g_str_hash, g_str_equal,
294 static void finalize_scope(struct ctf_scanner_scope *scope)
296 g_hash_table_destroy(scope->classes);
299 static void push_scope(struct ctf_scanner *scanner)
301 struct ctf_scanner_scope *ns;
303 BT_LOGT("Pushing scope: scanner-addr=%p", scanner);
304 ns = (ctf_scanner_scope *) malloc(sizeof(struct ctf_scanner_scope));
305 init_scope(ns, scanner->cs);
309 static void pop_scope(struct ctf_scanner *scanner)
311 struct ctf_scanner_scope *os;
313 BT_LOGT("Popping scope: scanner-addr=%p", scanner);
315 scanner->cs = os->parent;
320 static int lookup_type(struct ctf_scanner_scope *s, const char *id)
324 ret = GPOINTER_TO_INT(g_hash_table_lookup(s->classes, id));
325 BT_LOGT("Looked up type: scanner-addr=%p, id=\"%s\", ret=%d",
331 int is_type(struct ctf_scanner *scanner, const char *id)
333 struct ctf_scanner_scope *it;
336 for (it = scanner->cs; it; it = it->parent) {
337 if (lookup_type(it, id)) {
342 BT_LOGT("Found if ID is type: scanner-addr=%p, id=\"%s\", ret=%d",
347 static void add_type(struct ctf_scanner *scanner, char *id)
349 BT_LOGT("Adding type: scanner-addr=%p, id=\"%s\"",
351 if (lookup_type(scanner->cs, id))
353 g_hash_table_insert(scanner->cs->classes, id, id);
356 static struct ctf_node *make_node(struct ctf_scanner *scanner,
359 struct ctf_node *node;
361 node = (ctf_node *) objstack_alloc(scanner->objstack, sizeof(*node));
363 _BT_LOGE_APPEND_CAUSE_LINENO(yyget_lineno(scanner->scanner),
364 "failed to allocate one stack entry: "
365 "scanner-addr=%p", scanner);
369 node->lineno = yyget_lineno(scanner->scanner);
370 BT_INIT_LIST_HEAD(&node->tmp_head);
371 bt_list_add(&node->siblings, &node->tmp_head);
375 node->type = NODE_ERROR;
376 BT_LOGE("Trying to create root node: scanner-addr=%p",
380 BT_INIT_LIST_HEAD(&node->u.event.declaration_list);
383 BT_INIT_LIST_HEAD(&node->u.stream.declaration_list);
386 BT_INIT_LIST_HEAD(&node->u.env.declaration_list);
389 BT_INIT_LIST_HEAD(&node->u.trace.declaration_list);
392 BT_INIT_LIST_HEAD(&node->u.clock.declaration_list);
395 BT_INIT_LIST_HEAD(&node->u.callsite.declaration_list);
397 case NODE_CTF_EXPRESSION:
398 BT_INIT_LIST_HEAD(&node->u.ctf_expression.left);
399 BT_INIT_LIST_HEAD(&node->u.ctf_expression.right);
401 case NODE_UNARY_EXPRESSION:
404 BT_INIT_LIST_HEAD(&node->u.field_class_def.field_class_declarators);
406 case NODE_TYPEALIAS_TARGET:
407 BT_INIT_LIST_HEAD(&node->u.field_class_alias_target.field_class_declarators);
409 case NODE_TYPEALIAS_ALIAS:
410 BT_INIT_LIST_HEAD(&node->u.field_class_alias_name.field_class_declarators);
414 case NODE_TYPE_SPECIFIER:
416 case NODE_TYPE_SPECIFIER_LIST:
417 BT_INIT_LIST_HEAD(&node->u.field_class_specifier_list.head);
421 case NODE_TYPE_DECLARATOR:
422 BT_INIT_LIST_HEAD(&node->u.field_class_declarator.pointers);
424 case NODE_FLOATING_POINT:
425 BT_INIT_LIST_HEAD(&node->u.floating_point.expressions);
428 BT_INIT_LIST_HEAD(&node->u.integer.expressions);
431 BT_INIT_LIST_HEAD(&node->u.string.expressions);
433 case NODE_ENUMERATOR:
434 BT_INIT_LIST_HEAD(&node->u.enumerator.values);
437 BT_INIT_LIST_HEAD(&node->u._enum.enumerator_list);
439 case NODE_STRUCT_OR_VARIANT_DECLARATION:
440 BT_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.field_class_declarators);
443 BT_INIT_LIST_HEAD(&node->u.variant.declaration_list);
446 BT_INIT_LIST_HEAD(&node->u._struct.declaration_list);
447 BT_INIT_LIST_HEAD(&node->u._struct.min_align);
451 node->type = NODE_ERROR;
452 BT_LOGE("Unknown node type: scanner-addr=%p, node-type=%d",
460 static int reparent_ctf_expression(struct ctf_node *node,
461 struct ctf_node *parent)
463 switch (parent->type) {
465 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
468 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
471 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
474 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
477 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
480 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
482 case NODE_FLOATING_POINT:
483 _bt_list_splice_tail(&node->tmp_head, &parent->u.floating_point.expressions);
486 _bt_list_splice_tail(&node->tmp_head, &parent->u.integer.expressions);
489 _bt_list_splice_tail(&node->tmp_head, &parent->u.string.expressions);
493 case NODE_CTF_EXPRESSION:
495 case NODE_TYPEALIAS_TARGET:
496 case NODE_TYPEALIAS_ALIAS:
498 case NODE_TYPE_SPECIFIER:
499 case NODE_TYPE_SPECIFIER_LIST:
501 case NODE_TYPE_DECLARATOR:
502 case NODE_ENUMERATOR:
504 case NODE_STRUCT_OR_VARIANT_DECLARATION:
507 case NODE_UNARY_EXPRESSION:
512 BT_LOGE("Unknown node type: node-type=%d", parent->type);
518 static int reparent_typedef(struct ctf_node *node, struct ctf_node *parent)
520 switch (parent->type) {
522 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
525 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
528 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
531 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
534 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
537 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
540 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
543 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
546 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
549 case NODE_FLOATING_POINT:
552 case NODE_CTF_EXPRESSION:
554 case NODE_TYPEALIAS_TARGET:
555 case NODE_TYPEALIAS_ALIAS:
557 case NODE_TYPE_SPECIFIER:
558 case NODE_TYPE_SPECIFIER_LIST:
560 case NODE_TYPE_DECLARATOR:
561 case NODE_ENUMERATOR:
563 case NODE_STRUCT_OR_VARIANT_DECLARATION:
564 case NODE_UNARY_EXPRESSION:
569 BT_LOGE("Unknown node type: node-type=%d", parent->type);
575 static int reparent_field_class_alias(struct ctf_node *node, struct ctf_node *parent)
577 switch (parent->type) {
579 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
582 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
585 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
588 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
591 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
594 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
597 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
600 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
603 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
606 case NODE_FLOATING_POINT:
609 case NODE_CTF_EXPRESSION:
611 case NODE_TYPEALIAS_TARGET:
612 case NODE_TYPEALIAS_ALIAS:
614 case NODE_TYPE_SPECIFIER:
615 case NODE_TYPE_SPECIFIER_LIST:
617 case NODE_TYPE_DECLARATOR:
618 case NODE_ENUMERATOR:
620 case NODE_STRUCT_OR_VARIANT_DECLARATION:
621 case NODE_UNARY_EXPRESSION:
626 BT_LOGE("Unknown node type: node-type=%d", parent->type);
632 static int reparent_field_class_specifier(struct ctf_node *node,
633 struct ctf_node *parent)
635 switch (parent->type) {
636 case NODE_TYPE_SPECIFIER_LIST:
637 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_specifier_list.head);
640 case NODE_TYPE_SPECIFIER:
650 case NODE_TYPEALIAS_TARGET:
651 case NODE_TYPEALIAS_ALIAS:
652 case NODE_TYPE_DECLARATOR:
654 case NODE_STRUCT_OR_VARIANT_DECLARATION:
656 case NODE_FLOATING_POINT:
659 case NODE_CTF_EXPRESSION:
661 case NODE_ENUMERATOR:
662 case NODE_UNARY_EXPRESSION:
667 BT_LOGE("Unknown node type: node-type=%d", parent->type);
673 static int reparent_field_class_specifier_list(struct ctf_node *node,
674 struct ctf_node *parent)
676 switch (parent->type) {
678 bt_list_add_tail(&node->siblings, &parent->u.root.declaration_list);
681 bt_list_add_tail(&node->siblings, &parent->u.event.declaration_list);
684 bt_list_add_tail(&node->siblings, &parent->u.stream.declaration_list);
687 bt_list_add_tail(&node->siblings, &parent->u.env.declaration_list);
690 bt_list_add_tail(&node->siblings, &parent->u.trace.declaration_list);
693 bt_list_add_tail(&node->siblings, &parent->u.clock.declaration_list);
696 bt_list_add_tail(&node->siblings, &parent->u.callsite.declaration_list);
699 bt_list_add_tail(&node->siblings, &parent->u.variant.declaration_list);
702 bt_list_add_tail(&node->siblings, &parent->u._struct.declaration_list);
705 parent->u.field_class_def.field_class_specifier_list = node;
707 case NODE_TYPEALIAS_TARGET:
708 parent->u.field_class_alias_target.field_class_specifier_list = node;
710 case NODE_TYPEALIAS_ALIAS:
711 parent->u.field_class_alias_name.field_class_specifier_list = node;
714 parent->u._enum.container_field_class = node;
716 case NODE_STRUCT_OR_VARIANT_DECLARATION:
717 parent->u.struct_or_variant_declaration.field_class_specifier_list = node;
719 case NODE_TYPE_DECLARATOR:
720 case NODE_TYPE_SPECIFIER:
722 case NODE_FLOATING_POINT:
725 case NODE_CTF_EXPRESSION:
727 case NODE_ENUMERATOR:
728 case NODE_UNARY_EXPRESSION:
733 BT_LOGE("Unknown node type: node-type=%d", parent->type);
739 static int reparent_field_class_declarator(struct ctf_node *node,
740 struct ctf_node *parent)
742 switch (parent->type) {
743 case NODE_TYPE_DECLARATOR:
744 parent->u.field_class_declarator.type = TYPEDEC_NESTED;
745 parent->u.field_class_declarator.u.nested.field_class_declarator = node;
747 case NODE_STRUCT_OR_VARIANT_DECLARATION:
748 _bt_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.field_class_declarators);
751 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_def.field_class_declarators);
753 case NODE_TYPEALIAS_TARGET:
754 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_alias_target.field_class_declarators);
756 case NODE_TYPEALIAS_ALIAS:
757 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_alias_name.field_class_declarators);
771 case NODE_FLOATING_POINT:
774 case NODE_CTF_EXPRESSION:
775 case NODE_TYPE_SPECIFIER:
776 case NODE_TYPE_SPECIFIER_LIST:
778 case NODE_ENUMERATOR:
779 case NODE_UNARY_EXPRESSION:
784 BT_LOGE("Unknown node type: node-type=%d", parent->type);
793 * Link node to parent. Returns 0 on success, -EPERM if it is not permitted to
794 * create the link declared by the input, -ENOENT if node or parent is NULL,
795 * -EINVAL if there is an internal structure problem.
797 static int set_parent_node(struct ctf_node *node,
798 struct ctf_node *parent)
800 if (!node || !parent)
803 /* Note: Linking to parent will be done only by an external visitor */
805 switch (node->type) {
807 BT_LOGE_STR("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_LOGE("Unknown node type: node-type=%d", parent->type);
931 void yyerror(struct ctf_scanner *scanner, yyscan_t yyscanner, const char *str)
933 _BT_LOGE_APPEND_CAUSE_LINENO(yyget_lineno(scanner->scanner),
934 "%s: token=\"%s\"", 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 yyrestart(input, scanner->scanner);
966 return yyparse(scanner, scanner->scanner);
969 struct ctf_scanner *ctf_scanner_alloc(void)
971 struct ctf_scanner *scanner;
974 scanner = (ctf_scanner *) malloc(sizeof(*scanner));
977 memset(scanner, 0, sizeof(*scanner));
978 ret = yylex_init_extra(scanner, &scanner->scanner);
980 BT_LOGE("yylex_init_extra() failed: ret=%d", ret);
981 goto cleanup_scanner;
983 scanner->objstack = objstack_create();
984 if (!scanner->objstack)
986 scanner->ast = ctf_ast_alloc(scanner);
988 goto cleanup_objstack;
989 init_scope(&scanner->root_scope, NULL);
990 scanner->cs = &scanner->root_scope;
995 objstack_destroy(scanner->objstack);
997 ret = yylex_destroy(scanner->scanner);
999 BT_LOGE("yylex_destroy() failed: scanner-addr=%p, ret=%d",
1006 void ctf_scanner_free(struct ctf_scanner *scanner)
1013 struct ctf_scanner_scope *scope = scanner->cs;
1016 struct ctf_scanner_scope *parent = scope->parent;
1017 finalize_scope(scope);
1020 * The root scope is allocated within the ctf_scanner structure,
1021 * do doesn't need freeing. All others are allocated on their
1024 if (scope != &scanner->root_scope)
1030 objstack_destroy(scanner->objstack);
1031 ret = yylex_destroy(scanner->scanner);
1033 BT_LOGE("yylex_destroy() failed: scanner-addr=%p, ret=%d",
1039 * The bison-provided version of strlen (yystrlen) generates a benign
1040 * -Wnull-dereference warning. That version is used when building on cygwin,
1041 * for example, but you can also enable it by hand (to test) by removing the
1042 * preprocessor conditional around it.
1044 * Define yystrlen such that it will always use strlen. As far as we know,
1045 * strlen provided by all the platforms we use is reliable.
1047 #define yystrlen strlen
1052 * This ends up in parser.h and makes sure those who want to include it pass
1053 * through parser-wrap.h.
1056 #ifndef ALLOW_INCLUDE_PARSER_H
1057 # error "Don't include parser.h directly, include parser-wrap.h instead."
1063 void setstring(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src);
1066 int import_string(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src, char delim);
1072 %parse-param {struct ctf_scanner *scanner}
1073 %parse-param {yyscan_t yyscanner}
1074 %lex-param {yyscan_t yyscanner}
1076 * Expect two shift-reduce conflicts. Caused by enum name-opt : type {}
1077 * vs struct { int :value; } (unnamed bit-field). The default is to
1078 * shift, so whenever we encounter an enumeration, we are doing the
1079 * proper thing (shift). It is illegal to declare an enumeration
1080 * "bit-field", so it is OK if this situation ends up in a parsing
1085 %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
1086 %token <s> IDENTIFIER ID_TYPE
1091 unsigned long long ull;
1097 %type <s> CTF_STRING_LITERAL CTF_CHARACTER_LITERAL
1101 %type <ull> CTF_INTEGER_LITERAL
1102 %type <n> postfix_expression unary_expression unary_expression_or_range
1104 %type <n> declaration
1105 %type <n> event_declaration
1106 %type <n> stream_declaration
1107 %type <n> env_declaration
1108 %type <n> trace_declaration
1109 %type <n> clock_declaration
1110 %type <n> callsite_declaration
1111 %type <n> integer_declaration_specifiers
1112 %type <n> declaration_specifiers
1113 %type <n> alias_declaration_specifiers
1115 %type <n> field_class_declarator_list
1116 %type <n> integer_field_class_specifier
1117 %type <n> field_class_specifier
1118 %type <n> struct_class_specifier
1119 %type <n> variant_field_class_specifier
1120 %type <n> enum_field_class_specifier
1121 %type <n> struct_or_variant_declaration_list
1122 %type <n> struct_or_variant_declaration
1123 %type <n> struct_or_variant_declarator_list
1124 %type <n> struct_or_variant_declarator
1125 %type <n> enumerator_list
1126 %type <n> enumerator
1127 %type <n> abstract_declarator_list
1128 %type <n> abstract_declarator
1129 %type <n> direct_abstract_declarator
1130 %type <n> alias_abstract_declarator_list
1131 %type <n> alias_abstract_declarator
1132 %type <n> direct_alias_abstract_declarator
1133 %type <n> declarator
1134 %type <n> direct_declarator
1135 %type <n> field_class_declarator
1136 %type <n> direct_field_class_declarator
1138 %type <n> ctf_assignment_expression_list
1139 %type <n> ctf_assignment_expression
1146 if (set_parent_node($1, &ctf_scanner_get_ast(scanner)->root))
1147 reparent_error(scanner, "error reparenting to root");
1151 if (set_parent_node($2, &ctf_scanner_get_ast(scanner)->root))
1152 reparent_error(scanner, "error reparenting to root");
1181 | CTF_FLOATING_POINT
1214 /* 2: Phrase structure grammar */
1219 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1220 $$->u.unary_expression.type = UNARY_STRING;
1221 $$->u.unary_expression.u.string = yylval.s;
1225 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1226 $$->u.unary_expression.type = UNARY_STRING;
1227 $$->u.unary_expression.u.string = yylval.s;
1231 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1232 $$->u.unary_expression.type = UNARY_STRING;
1233 $$->u.unary_expression.u.string = yylval.s;
1235 | CTF_INTEGER_LITERAL
1237 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1238 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1239 $$->u.unary_expression.u.unsigned_constant = $1;
1241 | CTF_STRING_LITERAL
1243 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1244 $$->u.unary_expression.type = UNARY_STRING;
1245 $$->u.unary_expression.u.string = $1;
1247 | CTF_CHARACTER_LITERAL
1249 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1250 $$->u.unary_expression.type = UNARY_STRING;
1251 $$->u.unary_expression.u.string = $1;
1253 | CTF_LPAREN unary_expression CTF_RPAREN
1257 | postfix_expression CTF_LSBRAC unary_expression CTF_RSBRAC
1259 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1260 $$->u.unary_expression.type = UNARY_SBRAC;
1261 $$->u.unary_expression.u.sbrac_exp = $3;
1262 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1263 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1265 | postfix_expression CTF_DOT IDENTIFIER
1267 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1268 $$->u.unary_expression.type = UNARY_STRING;
1269 $$->u.unary_expression.u.string = yylval.s;
1270 $$->u.unary_expression.link = UNARY_DOTLINK;
1271 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1272 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1274 | postfix_expression CTF_DOT ID_TYPE
1276 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1277 $$->u.unary_expression.type = UNARY_STRING;
1278 $$->u.unary_expression.u.string = yylval.s;
1279 $$->u.unary_expression.link = UNARY_DOTLINK;
1280 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1281 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1283 | postfix_expression CTF_DOT keywords
1285 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1286 $$->u.unary_expression.type = UNARY_STRING;
1287 $$->u.unary_expression.u.string = yylval.s;
1288 $$->u.unary_expression.link = UNARY_DOTLINK;
1289 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1290 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1292 | postfix_expression CTF_RARROW IDENTIFIER
1294 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1295 $$->u.unary_expression.type = UNARY_STRING;
1296 $$->u.unary_expression.u.string = yylval.s;
1297 $$->u.unary_expression.link = UNARY_ARROWLINK;
1298 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1299 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1301 | postfix_expression CTF_RARROW ID_TYPE
1303 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1304 $$->u.unary_expression.type = UNARY_STRING;
1305 $$->u.unary_expression.u.string = yylval.s;
1306 $$->u.unary_expression.link = UNARY_ARROWLINK;
1307 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1308 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1315 | CTF_PLUS postfix_expression
1318 if ($$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
1319 && $$->u.unary_expression.type != UNARY_SIGNED_CONSTANT) {
1320 reparent_error(scanner, "expecting numeric constant");
1323 | CTF_MINUS postfix_expression
1326 if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1327 $$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
1328 $$->u.unary_expression.u.signed_constant =
1329 -($$->u.unary_expression.u.unsigned_constant);
1330 } else if ($$->u.unary_expression.type == UNARY_SIGNED_CONSTANT) {
1331 $$->u.unary_expression.u.signed_constant =
1332 -($$->u.unary_expression.u.signed_constant);
1334 reparent_error(scanner, "expecting numeric constant");
1339 unary_expression_or_range:
1340 unary_expression CTF_DOTDOTDOT unary_expression
1343 _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
1344 $3->u.unary_expression.link = UNARY_DOTDOTDOT;
1350 /* 2.2: Declarations */
1353 declaration_specifiers CTF_SEMICOLON
1357 | stream_declaration
1365 | callsite_declaration
1367 | declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
1369 struct ctf_node *list;
1371 $$ = make_node(scanner, NODE_TYPEDEF);
1372 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1373 $$->u.field_class_def.field_class_specifier_list = list;
1374 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1375 _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1376 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1378 | CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
1380 struct ctf_node *list;
1382 $$ = make_node(scanner, NODE_TYPEDEF);
1383 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1384 $$->u.field_class_def.field_class_specifier_list = list;
1385 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1386 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1388 | declaration_specifiers CTF_TYPEDEF field_class_declarator_list CTF_SEMICOLON
1390 struct ctf_node *list;
1392 $$ = make_node(scanner, NODE_TYPEDEF);
1393 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1394 $$->u.field_class_def.field_class_specifier_list = list;
1395 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1396 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1398 | CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
1400 struct ctf_node *list;
1402 $$ = make_node(scanner, NODE_TYPEALIAS);
1403 $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1404 $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1406 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1407 $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
1408 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1409 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
1411 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1412 $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
1413 _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1414 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
1419 event_declaration_begin event_declaration_end
1421 $$ = make_node(scanner, NODE_EVENT);
1423 | event_declaration_begin ctf_assignment_expression_list event_declaration_end
1425 $$ = make_node(scanner, NODE_EVENT);
1426 if (set_parent_node($2, $$))
1427 reparent_error(scanner, "event_declaration");
1431 event_declaration_begin:
1433 { push_scope(scanner); }
1436 event_declaration_end:
1437 CTF_RBRAC CTF_SEMICOLON
1438 { pop_scope(scanner); }
1443 stream_declaration_begin stream_declaration_end
1445 $$ = make_node(scanner, NODE_STREAM);
1447 | stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
1449 $$ = make_node(scanner, NODE_STREAM);
1450 if (set_parent_node($2, $$))
1451 reparent_error(scanner, "stream_declaration");
1455 stream_declaration_begin:
1456 CTF_STREAM CTF_LBRAC
1457 { push_scope(scanner); }
1460 stream_declaration_end:
1461 CTF_RBRAC CTF_SEMICOLON
1462 { pop_scope(scanner); }
1466 env_declaration_begin env_declaration_end
1468 $$ = make_node(scanner, NODE_ENV);
1470 | env_declaration_begin ctf_assignment_expression_list env_declaration_end
1472 $$ = make_node(scanner, NODE_ENV);
1473 if (set_parent_node($2, $$))
1474 reparent_error(scanner, "env declaration");
1478 env_declaration_begin:
1480 { push_scope(scanner); }
1483 env_declaration_end:
1484 CTF_RBRAC CTF_SEMICOLON
1485 { pop_scope(scanner); }
1489 trace_declaration_begin trace_declaration_end
1491 $$ = make_node(scanner, NODE_TRACE);
1493 | trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
1495 $$ = make_node(scanner, NODE_TRACE);
1496 if (set_parent_node($2, $$))
1497 reparent_error(scanner, "trace_declaration");
1501 trace_declaration_begin:
1503 { push_scope(scanner); }
1506 trace_declaration_end:
1507 CTF_RBRAC CTF_SEMICOLON
1508 { pop_scope(scanner); }
1512 CTF_CLOCK clock_declaration_begin clock_declaration_end
1514 $$ = make_node(scanner, NODE_CLOCK);
1516 | CTF_CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
1518 $$ = make_node(scanner, NODE_CLOCK);
1519 if (set_parent_node($3, $$))
1520 reparent_error(scanner, "trace_declaration");
1524 clock_declaration_begin:
1526 { push_scope(scanner); }
1529 clock_declaration_end:
1530 CTF_RBRAC CTF_SEMICOLON
1531 { pop_scope(scanner); }
1534 callsite_declaration:
1535 CTF_CALLSITE callsite_declaration_begin callsite_declaration_end
1537 $$ = make_node(scanner, NODE_CALLSITE);
1539 | CTF_CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
1541 $$ = make_node(scanner, NODE_CALLSITE);
1542 if (set_parent_node($3, $$))
1543 reparent_error(scanner, "trace_declaration");
1547 callsite_declaration_begin:
1549 { push_scope(scanner); }
1552 callsite_declaration_end:
1553 CTF_RBRAC CTF_SEMICOLON
1554 { pop_scope(scanner); }
1557 integer_declaration_specifiers:
1560 struct ctf_node *node;
1562 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1563 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1564 node->u.field_class_specifier.type = TYPESPEC_CONST;
1565 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1567 | integer_field_class_specifier
1569 struct ctf_node *node;
1571 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1573 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1575 | integer_declaration_specifiers CTF_CONST
1577 struct ctf_node *node;
1580 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1581 node->u.field_class_specifier.type = TYPESPEC_CONST;
1582 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1584 | integer_declaration_specifiers integer_field_class_specifier
1587 bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
1591 declaration_specifiers:
1594 struct ctf_node *node;
1596 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1597 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1598 node->u.field_class_specifier.type = TYPESPEC_CONST;
1599 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1601 | field_class_specifier
1603 struct ctf_node *node;
1605 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1607 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1609 | declaration_specifiers CTF_CONST
1611 struct ctf_node *node;
1614 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1615 node->u.field_class_specifier.type = TYPESPEC_CONST;
1616 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1618 | declaration_specifiers field_class_specifier
1621 bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
1625 field_class_declarator_list:
1626 field_class_declarator
1628 | field_class_declarator_list CTF_COMMA field_class_declarator
1631 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1635 integer_field_class_specifier:
1638 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1639 $$->u.field_class_specifier.type = TYPESPEC_CHAR;
1643 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1644 $$->u.field_class_specifier.type = TYPESPEC_SHORT;
1648 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1649 $$->u.field_class_specifier.type = TYPESPEC_INT;
1653 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1654 $$->u.field_class_specifier.type = TYPESPEC_LONG;
1658 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1659 $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
1663 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1664 $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
1668 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1669 $$->u.field_class_specifier.type = TYPESPEC_BOOL;
1673 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1674 $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
1675 $$->u.field_class_specifier.id_type = yylval.s;
1677 | CTF_INTEGER CTF_LBRAC CTF_RBRAC
1679 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1680 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1681 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1683 | CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1685 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1686 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1687 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1688 if (set_parent_node($3, $$->u.field_class_specifier.node))
1689 reparent_error(scanner, "integer reparent error");
1693 field_class_specifier:
1696 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1697 $$->u.field_class_specifier.type = TYPESPEC_VOID;
1701 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1702 $$->u.field_class_specifier.type = TYPESPEC_CHAR;
1706 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1707 $$->u.field_class_specifier.type = TYPESPEC_SHORT;
1711 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1712 $$->u.field_class_specifier.type = TYPESPEC_INT;
1716 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1717 $$->u.field_class_specifier.type = TYPESPEC_LONG;
1721 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1722 $$->u.field_class_specifier.type = TYPESPEC_FLOAT;
1726 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1727 $$->u.field_class_specifier.type = TYPESPEC_DOUBLE;
1731 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1732 $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
1736 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1737 $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
1741 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1742 $$->u.field_class_specifier.type = TYPESPEC_BOOL;
1746 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1747 $$->u.field_class_specifier.type = TYPESPEC_COMPLEX;
1751 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1752 $$->u.field_class_specifier.type = TYPESPEC_IMAGINARY;
1756 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1757 $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
1758 $$->u.field_class_specifier.id_type = yylval.s;
1760 | CTF_FLOATING_POINT CTF_LBRAC CTF_RBRAC
1762 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1763 $$->u.field_class_specifier.type = TYPESPEC_FLOATING_POINT;
1764 $$->u.field_class_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1766 | CTF_FLOATING_POINT CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1768 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1769 $$->u.field_class_specifier.type = TYPESPEC_FLOATING_POINT;
1770 $$->u.field_class_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1771 if (set_parent_node($3, $$->u.field_class_specifier.node))
1772 reparent_error(scanner, "floating point reparent error");
1774 | CTF_INTEGER CTF_LBRAC CTF_RBRAC
1776 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1777 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1778 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1780 | CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1782 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1783 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1784 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1785 if (set_parent_node($3, $$->u.field_class_specifier.node))
1786 reparent_error(scanner, "integer reparent error");
1790 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1791 $$->u.field_class_specifier.type = TYPESPEC_STRING;
1792 $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1794 | CTF_STRING CTF_LBRAC CTF_RBRAC
1796 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1797 $$->u.field_class_specifier.type = TYPESPEC_STRING;
1798 $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1800 | CTF_STRING CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1802 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1803 $$->u.field_class_specifier.type = TYPESPEC_STRING;
1804 $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1805 if (set_parent_node($3, $$->u.field_class_specifier.node))
1806 reparent_error(scanner, "string reparent error");
1808 | CTF_ENUM enum_field_class_specifier
1810 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1811 $$->u.field_class_specifier.type = TYPESPEC_ENUM;
1812 $$->u.field_class_specifier.node = $2;
1814 | CTF_VARIANT variant_field_class_specifier
1816 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1817 $$->u.field_class_specifier.type = TYPESPEC_VARIANT;
1818 $$->u.field_class_specifier.node = $2;
1820 | CTF_STRUCT struct_class_specifier
1822 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1823 $$->u.field_class_specifier.type = TYPESPEC_STRUCT;
1824 $$->u.field_class_specifier.node = $2;
1828 struct_class_specifier:
1829 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1831 $$ = make_node(scanner, NODE_STRUCT);
1832 $$->u._struct.has_body = 1;
1833 if ($2 && set_parent_node($2, $$))
1834 reparent_error(scanner, "struct reparent error");
1836 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1838 $$ = make_node(scanner, NODE_STRUCT);
1839 $$->u._struct.has_body = 1;
1840 $$->u._struct.name = $1;
1841 if ($3 && set_parent_node($3, $$))
1842 reparent_error(scanner, "struct reparent error");
1844 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1846 $$ = make_node(scanner, NODE_STRUCT);
1847 $$->u._struct.has_body = 1;
1848 $$->u._struct.name = $1;
1849 if ($3 && set_parent_node($3, $$))
1850 reparent_error(scanner, "struct reparent error");
1854 $$ = make_node(scanner, NODE_STRUCT);
1855 $$->u._struct.has_body = 0;
1856 $$->u._struct.name = $1;
1860 $$ = make_node(scanner, NODE_STRUCT);
1861 $$->u._struct.has_body = 0;
1862 $$->u._struct.name = $1;
1864 | struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1866 $$ = make_node(scanner, NODE_STRUCT);
1867 $$->u._struct.has_body = 1;
1868 bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
1869 if ($2 && set_parent_node($2, $$))
1870 reparent_error(scanner, "struct reparent error");
1872 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1874 $$ = make_node(scanner, NODE_STRUCT);
1875 $$->u._struct.has_body = 1;
1876 $$->u._struct.name = $1;
1877 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1878 if ($3 && set_parent_node($3, $$))
1879 reparent_error(scanner, "struct reparent error");
1881 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1883 $$ = make_node(scanner, NODE_STRUCT);
1884 $$->u._struct.has_body = 1;
1885 $$->u._struct.name = $1;
1886 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1887 if ($3 && set_parent_node($3, $$))
1888 reparent_error(scanner, "struct reparent error");
1892 struct_declaration_begin:
1894 { push_scope(scanner); }
1897 struct_declaration_end:
1899 { pop_scope(scanner); }
1902 variant_field_class_specifier:
1903 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1905 $$ = make_node(scanner, NODE_VARIANT);
1906 $$->u.variant.has_body = 1;
1907 if ($2 && set_parent_node($2, $$))
1908 reparent_error(scanner, "variant reparent error");
1910 | CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1912 $$ = make_node(scanner, NODE_VARIANT);
1913 $$->u.variant.has_body = 1;
1914 $$->u.variant.choice = $2;
1915 if ($5 && set_parent_node($5, $$))
1916 reparent_error(scanner, "variant reparent error");
1918 | CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1920 $$ = make_node(scanner, NODE_VARIANT);
1921 $$->u.variant.has_body = 1;
1922 $$->u.variant.choice = $2;
1923 if ($5 && set_parent_node($5, $$))
1924 reparent_error(scanner, "variant reparent error");
1926 | IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1928 $$ = make_node(scanner, NODE_VARIANT);
1929 $$->u.variant.has_body = 1;
1930 $$->u.variant.name = $1;
1931 if ($3 && set_parent_node($3, $$))
1932 reparent_error(scanner, "variant reparent error");
1934 | IDENTIFIER CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1936 $$ = make_node(scanner, NODE_VARIANT);
1937 $$->u.variant.has_body = 1;
1938 $$->u.variant.name = $1;
1939 $$->u.variant.choice = $3;
1940 if ($6 && set_parent_node($6, $$))
1941 reparent_error(scanner, "variant reparent error");
1943 | IDENTIFIER CTF_LT IDENTIFIER CTF_GT
1945 $$ = make_node(scanner, NODE_VARIANT);
1946 $$->u.variant.has_body = 0;
1947 $$->u.variant.name = $1;
1948 $$->u.variant.choice = $3;
1950 | IDENTIFIER CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1952 $$ = make_node(scanner, NODE_VARIANT);
1953 $$->u.variant.has_body = 1;
1954 $$->u.variant.name = $1;
1955 $$->u.variant.choice = $3;
1956 if ($6 && set_parent_node($6, $$))
1957 reparent_error(scanner, "variant reparent error");
1959 | IDENTIFIER CTF_LT ID_TYPE CTF_GT
1961 $$ = make_node(scanner, NODE_VARIANT);
1962 $$->u.variant.has_body = 0;
1963 $$->u.variant.name = $1;
1964 $$->u.variant.choice = $3;
1966 | ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1968 $$ = make_node(scanner, NODE_VARIANT);
1969 $$->u.variant.has_body = 1;
1970 $$->u.variant.name = $1;
1971 if ($3 && set_parent_node($3, $$))
1972 reparent_error(scanner, "variant reparent error");
1974 | ID_TYPE CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1976 $$ = make_node(scanner, NODE_VARIANT);
1977 $$->u.variant.has_body = 1;
1978 $$->u.variant.name = $1;
1979 $$->u.variant.choice = $3;
1980 if ($6 && set_parent_node($6, $$))
1981 reparent_error(scanner, "variant reparent error");
1983 | ID_TYPE CTF_LT IDENTIFIER CTF_GT
1985 $$ = make_node(scanner, NODE_VARIANT);
1986 $$->u.variant.has_body = 0;
1987 $$->u.variant.name = $1;
1988 $$->u.variant.choice = $3;
1990 | ID_TYPE CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1992 $$ = make_node(scanner, NODE_VARIANT);
1993 $$->u.variant.has_body = 1;
1994 $$->u.variant.name = $1;
1995 $$->u.variant.choice = $3;
1996 if ($6 && set_parent_node($6, $$))
1997 reparent_error(scanner, "variant reparent error");
1999 | ID_TYPE CTF_LT ID_TYPE CTF_GT
2001 $$ = make_node(scanner, NODE_VARIANT);
2002 $$->u.variant.has_body = 0;
2003 $$->u.variant.name = $1;
2004 $$->u.variant.choice = $3;
2008 variant_declaration_begin:
2010 { push_scope(scanner); }
2013 variant_declaration_end:
2015 { pop_scope(scanner); }
2018 enum_field_class_specifier:
2019 CTF_LBRAC enumerator_list CTF_RBRAC
2021 $$ = make_node(scanner, NODE_ENUM);
2022 $$->u._enum.has_body = 1;
2023 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
2025 | CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2027 $$ = make_node(scanner, NODE_ENUM);
2028 $$->u._enum.has_body = 1;
2029 ($$)->u._enum.container_field_class = $2;
2030 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2032 | IDENTIFIER CTF_LBRAC enumerator_list CTF_RBRAC
2034 $$ = make_node(scanner, NODE_ENUM);
2035 $$->u._enum.has_body = 1;
2036 $$->u._enum.enum_id = $1;
2037 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2039 | IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2041 $$ = make_node(scanner, NODE_ENUM);
2042 $$->u._enum.has_body = 1;
2043 $$->u._enum.enum_id = $1;
2044 ($$)->u._enum.container_field_class = $3;
2045 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2047 | ID_TYPE CTF_LBRAC enumerator_list CTF_RBRAC
2049 $$ = make_node(scanner, NODE_ENUM);
2050 $$->u._enum.has_body = 1;
2051 $$->u._enum.enum_id = $1;
2052 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2054 | ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2056 $$ = make_node(scanner, NODE_ENUM);
2057 $$->u._enum.has_body = 1;
2058 $$->u._enum.enum_id = $1;
2059 ($$)->u._enum.container_field_class = $3;
2060 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2062 | CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2064 $$ = make_node(scanner, NODE_ENUM);
2065 $$->u._enum.has_body = 1;
2066 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
2068 | CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2070 $$ = make_node(scanner, NODE_ENUM);
2071 $$->u._enum.has_body = 1;
2072 ($$)->u._enum.container_field_class = $2;
2073 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2075 | IDENTIFIER CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2077 $$ = make_node(scanner, NODE_ENUM);
2078 $$->u._enum.has_body = 1;
2079 $$->u._enum.enum_id = $1;
2080 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2082 | IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2084 $$ = make_node(scanner, NODE_ENUM);
2085 $$->u._enum.has_body = 1;
2086 $$->u._enum.enum_id = $1;
2087 ($$)->u._enum.container_field_class = $3;
2088 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2092 $$ = make_node(scanner, NODE_ENUM);
2093 $$->u._enum.has_body = 0;
2094 $$->u._enum.enum_id = $1;
2096 | ID_TYPE CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2098 $$ = make_node(scanner, NODE_ENUM);
2099 $$->u._enum.has_body = 1;
2100 $$->u._enum.enum_id = $1;
2101 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2103 | ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2105 $$ = make_node(scanner, NODE_ENUM);
2106 $$->u._enum.has_body = 1;
2107 $$->u._enum.enum_id = $1;
2108 ($$)->u._enum.container_field_class = $3;
2109 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2113 $$ = make_node(scanner, NODE_ENUM);
2114 $$->u._enum.has_body = 0;
2115 $$->u._enum.enum_id = $1;
2119 struct_or_variant_declaration_list:
2122 | struct_or_variant_declaration_list struct_or_variant_declaration
2126 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2129 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
2134 struct_or_variant_declaration:
2135 declaration_specifiers struct_or_variant_declarator_list CTF_SEMICOLON
2137 struct ctf_node *list;
2139 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2140 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2141 $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
2142 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2143 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.field_class_declarators);
2145 | declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
2147 struct ctf_node *list;
2149 $$ = make_node(scanner, NODE_TYPEDEF);
2150 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2151 $$->u.field_class_def.field_class_specifier_list = list;
2152 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2153 _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2154 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2156 | CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
2158 struct ctf_node *list;
2160 $$ = make_node(scanner, NODE_TYPEDEF);
2161 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2162 $$->u.field_class_def.field_class_specifier_list = list;
2163 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2164 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2166 | declaration_specifiers CTF_TYPEDEF field_class_declarator_list CTF_SEMICOLON
2168 struct ctf_node *list;
2170 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2171 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2172 $$ = make_node(scanner, NODE_TYPEDEF);
2173 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2174 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2176 | CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
2178 struct ctf_node *list;
2180 $$ = make_node(scanner, NODE_TYPEALIAS);
2181 $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2182 $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2184 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2185 $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
2186 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2187 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
2189 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2190 $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
2191 _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2192 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
2196 alias_declaration_specifiers:
2199 struct ctf_node *node;
2201 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2202 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2203 node->u.field_class_specifier.type = TYPESPEC_CONST;
2204 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2206 | field_class_specifier
2208 struct ctf_node *node;
2210 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2212 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2216 struct ctf_node *node;
2218 add_type(scanner, $1);
2219 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2220 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2221 node->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
2222 node->u.field_class_specifier.id_type = yylval.s;
2223 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2225 | alias_declaration_specifiers CTF_CONST
2227 struct ctf_node *node;
2230 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2231 node->u.field_class_specifier.type = TYPESPEC_CONST;
2232 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2234 | alias_declaration_specifiers field_class_specifier
2237 bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
2239 | alias_declaration_specifiers IDENTIFIER
2241 struct ctf_node *node;
2243 add_type(scanner, $2);
2245 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2246 node->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
2247 node->u.field_class_specifier.id_type = yylval.s;
2248 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2252 struct_or_variant_declarator_list:
2253 struct_or_variant_declarator
2255 | struct_or_variant_declarator_list CTF_COMMA struct_or_variant_declarator
2258 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2262 struct_or_variant_declarator:
2265 | CTF_COLON unary_expression
2267 | declarator CTF_COLON unary_expression
2270 if (set_parent_node($3, $1))
2271 reparent_error(scanner, "struct_or_variant_declarator");
2278 | enumerator_list CTF_COMMA enumerator
2281 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2288 $$ = make_node(scanner, NODE_ENUMERATOR);
2289 $$->u.enumerator.id = $1;
2293 $$ = make_node(scanner, NODE_ENUMERATOR);
2294 $$->u.enumerator.id = $1;
2298 $$ = make_node(scanner, NODE_ENUMERATOR);
2299 $$->u.enumerator.id = $1;
2301 | CTF_STRING_LITERAL
2303 $$ = make_node(scanner, NODE_ENUMERATOR);
2304 $$->u.enumerator.id = $1;
2306 | IDENTIFIER CTF_EQUAL unary_expression_or_range
2308 $$ = make_node(scanner, NODE_ENUMERATOR);
2309 $$->u.enumerator.id = $1;
2310 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2312 | ID_TYPE CTF_EQUAL unary_expression_or_range
2314 $$ = make_node(scanner, NODE_ENUMERATOR);
2315 $$->u.enumerator.id = $1;
2316 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2318 | keywords CTF_EQUAL unary_expression_or_range
2320 $$ = make_node(scanner, NODE_ENUMERATOR);
2321 $$->u.enumerator.id = $1;
2322 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2324 | CTF_STRING_LITERAL CTF_EQUAL unary_expression_or_range
2326 $$ = make_node(scanner, NODE_ENUMERATOR);
2327 $$->u.enumerator.id = $1;
2328 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2332 abstract_declarator_list:
2335 | abstract_declarator_list CTF_COMMA abstract_declarator
2338 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2342 abstract_declarator:
2343 direct_abstract_declarator
2345 | pointer direct_abstract_declarator
2348 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2352 direct_abstract_declarator:
2355 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2356 $$->u.field_class_declarator.type = TYPEDEC_ID;
2361 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2362 $$->u.field_class_declarator.type = TYPEDEC_ID;
2363 $$->u.field_class_declarator.u.id = $1;
2365 | CTF_LPAREN abstract_declarator CTF_RPAREN
2367 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2368 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2369 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2371 | direct_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2373 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2374 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2375 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2376 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2377 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2379 | direct_abstract_declarator CTF_LSBRAC CTF_RSBRAC
2381 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2382 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2383 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2384 $$->u.field_class_declarator.u.nested.abstract_array = 1;
2388 alias_abstract_declarator_list:
2389 alias_abstract_declarator
2391 | alias_abstract_declarator_list CTF_COMMA alias_abstract_declarator
2394 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2398 alias_abstract_declarator:
2399 direct_alias_abstract_declarator
2401 | pointer direct_alias_abstract_declarator
2404 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2408 direct_alias_abstract_declarator:
2411 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2412 $$->u.field_class_declarator.type = TYPEDEC_ID;
2415 | CTF_LPAREN alias_abstract_declarator CTF_RPAREN
2417 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2418 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2419 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2421 | direct_alias_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2423 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2424 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2425 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2426 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2427 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2429 | direct_alias_abstract_declarator CTF_LSBRAC CTF_RSBRAC
2431 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2432 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2433 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2434 $$->u.field_class_declarator.u.nested.abstract_array = 1;
2441 | pointer direct_declarator
2444 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2451 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2452 $$->u.field_class_declarator.type = TYPEDEC_ID;
2453 $$->u.field_class_declarator.u.id = $1;
2455 | CTF_LPAREN declarator CTF_RPAREN
2457 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2458 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2459 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2461 | direct_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2463 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2464 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2465 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2466 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2467 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2471 field_class_declarator:
2472 direct_field_class_declarator
2474 | pointer direct_field_class_declarator
2477 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2481 direct_field_class_declarator:
2484 add_type(scanner, $1);
2485 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2486 $$->u.field_class_declarator.type = TYPEDEC_ID;
2487 $$->u.field_class_declarator.u.id = $1;
2489 | CTF_LPAREN field_class_declarator CTF_RPAREN
2491 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2492 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2493 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2495 | direct_field_class_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2497 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2498 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2499 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2500 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2501 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2508 $$ = make_node(scanner, NODE_POINTER);
2512 $$ = make_node(scanner, NODE_POINTER);
2513 bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
2515 | CTF_STAR type_qualifier_list pointer
2517 $$ = make_node(scanner, NODE_POINTER);
2518 $$->u.pointer.const_qualifier = 1;
2519 bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
2523 type_qualifier_list:
2524 /* pointer assumes only const type qualifier */
2526 | type_qualifier_list CTF_CONST
2529 /* 2.3: CTF-specific declarations */
2531 ctf_assignment_expression_list:
2532 ctf_assignment_expression CTF_SEMICOLON
2534 | ctf_assignment_expression_list ctf_assignment_expression CTF_SEMICOLON
2537 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2541 ctf_assignment_expression:
2542 unary_expression CTF_EQUAL unary_expression
2545 * Because we have left and right, cannot use
2548 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2549 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2550 if ($1->u.unary_expression.type != UNARY_STRING)
2551 reparent_error(scanner, "ctf_assignment_expression left expects string");
2552 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
2554 | unary_expression CTF_TYPEASSIGN declaration_specifiers /* Only allow struct */
2557 * Because we have left and right, cannot use
2560 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2561 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2562 if ($1->u.unary_expression.type != UNARY_STRING)
2563 reparent_error(scanner, "ctf_assignment_expression left expects string");
2564 bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
2566 | declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list
2568 struct ctf_node *list;
2570 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2571 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2572 _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2573 $$ = make_node(scanner, NODE_TYPEDEF);
2574 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2575 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2577 | CTF_TYPEDEF declaration_specifiers field_class_declarator_list
2579 struct ctf_node *list;
2581 $$ = make_node(scanner, NODE_TYPEDEF);
2582 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2583 $$->u.field_class_def.field_class_specifier_list = list;
2584 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2585 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2587 | declaration_specifiers CTF_TYPEDEF field_class_declarator_list
2589 struct ctf_node *list;
2591 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2592 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2593 $$ = make_node(scanner, NODE_TYPEDEF);
2594 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2595 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2597 | CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
2599 struct ctf_node *list;
2601 $$ = make_node(scanner, NODE_TYPEALIAS);
2602 $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2603 $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2605 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2606 $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
2607 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2608 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
2610 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2611 $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
2612 _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2613 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);