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;
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_LOGE_APPEND_CAUSE_LINENO(yyget_lineno(scanner),
271 "wide characters are not supported as of this version: "
272 "scanner-addr=%p", scanner);
275 return import_basic_string(scanner, lvalp, len, src, delim);
279 static void init_scope(struct ctf_scanner_scope *scope,
280 struct ctf_scanner_scope *parent)
282 scope->parent = parent;
283 scope->classes = g_hash_table_new_full(g_str_hash, g_str_equal,
287 static void finalize_scope(struct ctf_scanner_scope *scope)
289 g_hash_table_destroy(scope->classes);
292 static void push_scope(struct ctf_scanner *scanner)
294 struct ctf_scanner_scope *ns;
296 BT_LOGT("Pushing scope: scanner-addr=%p", scanner);
297 ns = (ctf_scanner_scope *) malloc(sizeof(struct ctf_scanner_scope));
298 init_scope(ns, scanner->cs);
302 static void pop_scope(struct ctf_scanner *scanner)
304 struct ctf_scanner_scope *os;
306 BT_LOGT("Popping scope: scanner-addr=%p", scanner);
308 scanner->cs = os->parent;
313 static int lookup_type(struct ctf_scanner_scope *s, const char *id)
317 ret = GPOINTER_TO_INT(g_hash_table_lookup(s->classes, id));
318 BT_LOGT("Looked up type: scanner-addr=%p, id=\"%s\", ret=%d",
323 int is_type(struct ctf_scanner *scanner, const char *id)
325 struct ctf_scanner_scope *it;
328 for (it = scanner->cs; it; it = it->parent) {
329 if (lookup_type(it, id)) {
334 BT_LOGT("Found if ID is type: scanner-addr=%p, id=\"%s\", ret=%d",
339 static void add_type(struct ctf_scanner *scanner, char *id)
341 BT_LOGT("Adding type: scanner-addr=%p, id=\"%s\"",
343 if (lookup_type(scanner->cs, id))
345 g_hash_table_insert(scanner->cs->classes, id, id);
348 static struct ctf_node *make_node(struct ctf_scanner *scanner,
351 struct ctf_node *node;
353 node = (ctf_node *) objstack_alloc(scanner->objstack, sizeof(*node));
355 _BT_LOGE_APPEND_CAUSE_LINENO(yyget_lineno(scanner->scanner),
356 "failed to allocate one stack entry: "
357 "scanner-addr=%p", scanner);
361 node->lineno = yyget_lineno(scanner->scanner);
362 BT_INIT_LIST_HEAD(&node->tmp_head);
363 bt_list_add(&node->siblings, &node->tmp_head);
367 node->type = NODE_ERROR;
368 BT_LOGE("Trying to create root node: scanner-addr=%p",
372 BT_INIT_LIST_HEAD(&node->u.event.declaration_list);
375 BT_INIT_LIST_HEAD(&node->u.stream.declaration_list);
378 BT_INIT_LIST_HEAD(&node->u.env.declaration_list);
381 BT_INIT_LIST_HEAD(&node->u.trace.declaration_list);
384 BT_INIT_LIST_HEAD(&node->u.clock.declaration_list);
387 BT_INIT_LIST_HEAD(&node->u.callsite.declaration_list);
389 case NODE_CTF_EXPRESSION:
390 BT_INIT_LIST_HEAD(&node->u.ctf_expression.left);
391 BT_INIT_LIST_HEAD(&node->u.ctf_expression.right);
393 case NODE_UNARY_EXPRESSION:
396 BT_INIT_LIST_HEAD(&node->u.field_class_def.field_class_declarators);
398 case NODE_TYPEALIAS_TARGET:
399 BT_INIT_LIST_HEAD(&node->u.field_class_alias_target.field_class_declarators);
401 case NODE_TYPEALIAS_ALIAS:
402 BT_INIT_LIST_HEAD(&node->u.field_class_alias_name.field_class_declarators);
406 case NODE_TYPE_SPECIFIER:
408 case NODE_TYPE_SPECIFIER_LIST:
409 BT_INIT_LIST_HEAD(&node->u.field_class_specifier_list.head);
413 case NODE_TYPE_DECLARATOR:
414 BT_INIT_LIST_HEAD(&node->u.field_class_declarator.pointers);
416 case NODE_FLOATING_POINT:
417 BT_INIT_LIST_HEAD(&node->u.floating_point.expressions);
420 BT_INIT_LIST_HEAD(&node->u.integer.expressions);
423 BT_INIT_LIST_HEAD(&node->u.string.expressions);
425 case NODE_ENUMERATOR:
426 BT_INIT_LIST_HEAD(&node->u.enumerator.values);
429 BT_INIT_LIST_HEAD(&node->u._enum.enumerator_list);
431 case NODE_STRUCT_OR_VARIANT_DECLARATION:
432 BT_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.field_class_declarators);
435 BT_INIT_LIST_HEAD(&node->u.variant.declaration_list);
438 BT_INIT_LIST_HEAD(&node->u._struct.declaration_list);
439 BT_INIT_LIST_HEAD(&node->u._struct.min_align);
443 node->type = NODE_ERROR;
444 BT_LOGE("Unknown node type: scanner-addr=%p, node-type=%d",
452 static int reparent_ctf_expression(struct ctf_node *node,
453 struct ctf_node *parent)
455 switch (parent->type) {
457 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
460 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
463 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
466 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
469 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
472 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
474 case NODE_FLOATING_POINT:
475 _bt_list_splice_tail(&node->tmp_head, &parent->u.floating_point.expressions);
478 _bt_list_splice_tail(&node->tmp_head, &parent->u.integer.expressions);
481 _bt_list_splice_tail(&node->tmp_head, &parent->u.string.expressions);
485 case NODE_CTF_EXPRESSION:
487 case NODE_TYPEALIAS_TARGET:
488 case NODE_TYPEALIAS_ALIAS:
490 case NODE_TYPE_SPECIFIER:
491 case NODE_TYPE_SPECIFIER_LIST:
493 case NODE_TYPE_DECLARATOR:
494 case NODE_ENUMERATOR:
496 case NODE_STRUCT_OR_VARIANT_DECLARATION:
499 case NODE_UNARY_EXPRESSION:
504 BT_LOGE("Unknown node type: node-type=%d", parent->type);
510 static int reparent_typedef(struct ctf_node *node, struct ctf_node *parent)
512 switch (parent->type) {
514 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
517 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
520 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
523 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
526 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
529 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
532 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
535 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
538 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
541 case NODE_FLOATING_POINT:
544 case NODE_CTF_EXPRESSION:
546 case NODE_TYPEALIAS_TARGET:
547 case NODE_TYPEALIAS_ALIAS:
549 case NODE_TYPE_SPECIFIER:
550 case NODE_TYPE_SPECIFIER_LIST:
552 case NODE_TYPE_DECLARATOR:
553 case NODE_ENUMERATOR:
555 case NODE_STRUCT_OR_VARIANT_DECLARATION:
556 case NODE_UNARY_EXPRESSION:
561 BT_LOGE("Unknown node type: node-type=%d", parent->type);
567 static int reparent_field_class_alias(struct ctf_node *node, struct ctf_node *parent)
569 switch (parent->type) {
571 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
574 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
577 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
580 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
583 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
586 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
589 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
592 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
595 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
598 case NODE_FLOATING_POINT:
601 case NODE_CTF_EXPRESSION:
603 case NODE_TYPEALIAS_TARGET:
604 case NODE_TYPEALIAS_ALIAS:
606 case NODE_TYPE_SPECIFIER:
607 case NODE_TYPE_SPECIFIER_LIST:
609 case NODE_TYPE_DECLARATOR:
610 case NODE_ENUMERATOR:
612 case NODE_STRUCT_OR_VARIANT_DECLARATION:
613 case NODE_UNARY_EXPRESSION:
618 BT_LOGE("Unknown node type: node-type=%d", parent->type);
624 static int reparent_field_class_specifier(struct ctf_node *node,
625 struct ctf_node *parent)
627 switch (parent->type) {
628 case NODE_TYPE_SPECIFIER_LIST:
629 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_specifier_list.head);
632 case NODE_TYPE_SPECIFIER:
642 case NODE_TYPEALIAS_TARGET:
643 case NODE_TYPEALIAS_ALIAS:
644 case NODE_TYPE_DECLARATOR:
646 case NODE_STRUCT_OR_VARIANT_DECLARATION:
648 case NODE_FLOATING_POINT:
651 case NODE_CTF_EXPRESSION:
653 case NODE_ENUMERATOR:
654 case NODE_UNARY_EXPRESSION:
659 BT_LOGE("Unknown node type: node-type=%d", parent->type);
665 static int reparent_field_class_specifier_list(struct ctf_node *node,
666 struct ctf_node *parent)
668 switch (parent->type) {
670 bt_list_add_tail(&node->siblings, &parent->u.root.declaration_list);
673 bt_list_add_tail(&node->siblings, &parent->u.event.declaration_list);
676 bt_list_add_tail(&node->siblings, &parent->u.stream.declaration_list);
679 bt_list_add_tail(&node->siblings, &parent->u.env.declaration_list);
682 bt_list_add_tail(&node->siblings, &parent->u.trace.declaration_list);
685 bt_list_add_tail(&node->siblings, &parent->u.clock.declaration_list);
688 bt_list_add_tail(&node->siblings, &parent->u.callsite.declaration_list);
691 bt_list_add_tail(&node->siblings, &parent->u.variant.declaration_list);
694 bt_list_add_tail(&node->siblings, &parent->u._struct.declaration_list);
697 parent->u.field_class_def.field_class_specifier_list = node;
699 case NODE_TYPEALIAS_TARGET:
700 parent->u.field_class_alias_target.field_class_specifier_list = node;
702 case NODE_TYPEALIAS_ALIAS:
703 parent->u.field_class_alias_name.field_class_specifier_list = node;
706 parent->u._enum.container_field_class = node;
708 case NODE_STRUCT_OR_VARIANT_DECLARATION:
709 parent->u.struct_or_variant_declaration.field_class_specifier_list = node;
711 case NODE_TYPE_DECLARATOR:
712 case NODE_TYPE_SPECIFIER:
714 case NODE_FLOATING_POINT:
717 case NODE_CTF_EXPRESSION:
719 case NODE_ENUMERATOR:
720 case NODE_UNARY_EXPRESSION:
725 BT_LOGE("Unknown node type: node-type=%d", parent->type);
731 static int reparent_field_class_declarator(struct ctf_node *node,
732 struct ctf_node *parent)
734 switch (parent->type) {
735 case NODE_TYPE_DECLARATOR:
736 parent->u.field_class_declarator.type = TYPEDEC_NESTED;
737 parent->u.field_class_declarator.u.nested.field_class_declarator = node;
739 case NODE_STRUCT_OR_VARIANT_DECLARATION:
740 _bt_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.field_class_declarators);
743 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_def.field_class_declarators);
745 case NODE_TYPEALIAS_TARGET:
746 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_alias_target.field_class_declarators);
748 case NODE_TYPEALIAS_ALIAS:
749 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_alias_name.field_class_declarators);
763 case NODE_FLOATING_POINT:
766 case NODE_CTF_EXPRESSION:
767 case NODE_TYPE_SPECIFIER:
768 case NODE_TYPE_SPECIFIER_LIST:
770 case NODE_ENUMERATOR:
771 case NODE_UNARY_EXPRESSION:
776 BT_LOGE("Unknown node type: node-type=%d", parent->type);
785 * Link node to parent. Returns 0 on success, -EPERM if it is not permitted to
786 * create the link declared by the input, -ENOENT if node or parent is NULL,
787 * -EINVAL if there is an internal structure problem.
789 static int set_parent_node(struct ctf_node *node,
790 struct ctf_node *parent)
792 if (!node || !parent)
795 /* Note: Linking to parent will be done only by an external visitor */
797 switch (node->type) {
799 BT_LOGE_STR("Trying to reparent root node.");
803 if (parent->type == NODE_ROOT) {
804 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.event);
810 if (parent->type == NODE_ROOT) {
811 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.stream);
817 if (parent->type == NODE_ROOT) {
818 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.env);
824 if (parent->type == NODE_ROOT) {
825 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.trace);
831 if (parent->type == NODE_ROOT) {
832 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.clock);
838 if (parent->type == NODE_ROOT) {
839 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.callsite);
845 case NODE_CTF_EXPRESSION:
846 return reparent_ctf_expression(node, parent);
847 case NODE_UNARY_EXPRESSION:
848 if (parent->type == NODE_TYPE_DECLARATOR)
849 parent->u.field_class_declarator.bitfield_len = node;
855 return reparent_typedef(node, parent);
856 case NODE_TYPEALIAS_TARGET:
857 if (parent->type == NODE_TYPEALIAS)
858 parent->u.field_class_alias.target = node;
862 case NODE_TYPEALIAS_ALIAS:
863 if (parent->type == NODE_TYPEALIAS)
864 parent->u.field_class_alias.alias = node;
869 return reparent_field_class_alias(node, parent);
872 if (parent->type == NODE_TYPE_DECLARATOR) {
873 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_declarator.pointers);
877 case NODE_TYPE_DECLARATOR:
878 return reparent_field_class_declarator(node, parent);
880 case NODE_TYPE_SPECIFIER_LIST:
881 return reparent_field_class_specifier_list(node, parent);
883 case NODE_TYPE_SPECIFIER:
884 return reparent_field_class_specifier(node, parent);
886 case NODE_FLOATING_POINT:
892 return -EINVAL; /* Dealt with internally within grammar */
894 case NODE_ENUMERATOR:
895 if (parent->type == NODE_ENUM) {
896 _bt_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
901 case NODE_STRUCT_OR_VARIANT_DECLARATION:
902 switch (parent->type) {
904 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
907 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
916 BT_LOGE("Unknown node type: node-type=%d", parent->type);
923 void yyerror(struct ctf_scanner *scanner, yyscan_t yyscanner, const char *str)
925 _BT_LOGE_APPEND_CAUSE_LINENO(yyget_lineno(scanner->scanner),
926 "%s: token=\"%s\"", str, yyget_text(scanner->scanner));
929 #define reparent_error(scanner, str) \
931 yyerror(scanner, scanner->scanner, YY_("reparent_error: " str)); \
935 static struct ctf_ast *ctf_ast_alloc(struct ctf_scanner *scanner)
939 ast = (ctf_ast *) objstack_alloc(scanner->objstack, sizeof(*ast));
942 ast->root.type = NODE_ROOT;
943 BT_INIT_LIST_HEAD(&ast->root.tmp_head);
944 BT_INIT_LIST_HEAD(&ast->root.u.root.declaration_list);
945 BT_INIT_LIST_HEAD(&ast->root.u.root.trace);
946 BT_INIT_LIST_HEAD(&ast->root.u.root.env);
947 BT_INIT_LIST_HEAD(&ast->root.u.root.stream);
948 BT_INIT_LIST_HEAD(&ast->root.u.root.event);
949 BT_INIT_LIST_HEAD(&ast->root.u.root.clock);
950 BT_INIT_LIST_HEAD(&ast->root.u.root.callsite);
954 int ctf_scanner_append_ast(struct ctf_scanner *scanner, FILE *input)
956 /* Start processing new stream */
957 yyrestart(input, scanner->scanner);
958 return yyparse(scanner, scanner->scanner);
961 struct ctf_scanner *ctf_scanner_alloc(void)
963 struct ctf_scanner *scanner;
966 scanner = (ctf_scanner *) malloc(sizeof(*scanner));
969 memset(scanner, 0, sizeof(*scanner));
970 ret = yylex_init_extra(scanner, &scanner->scanner);
972 BT_LOGE("yylex_init_extra() failed: ret=%d", ret);
973 goto cleanup_scanner;
975 scanner->objstack = objstack_create();
976 if (!scanner->objstack)
978 scanner->ast = ctf_ast_alloc(scanner);
980 goto cleanup_objstack;
981 init_scope(&scanner->root_scope, NULL);
982 scanner->cs = &scanner->root_scope;
987 objstack_destroy(scanner->objstack);
989 ret = yylex_destroy(scanner->scanner);
991 BT_LOGE("yylex_destroy() failed: scanner-addr=%p, ret=%d",
998 void ctf_scanner_free(struct ctf_scanner *scanner)
1005 struct ctf_scanner_scope *scope = scanner->cs;
1008 struct ctf_scanner_scope *parent = scope->parent;
1009 finalize_scope(scope);
1012 * The root scope is allocated within the ctf_scanner structure,
1013 * do doesn't need freeing. All others are allocated on their
1016 if (scope != &scanner->root_scope)
1022 objstack_destroy(scanner->objstack);
1023 ret = yylex_destroy(scanner->scanner);
1025 BT_LOGE("yylex_destroy() failed: scanner-addr=%p, ret=%d",
1031 * The bison-provided version of strlen (yystrlen) generates a benign
1032 * -Wnull-dereference warning. That version is used when building on cygwin,
1033 * for example, but you can also enable it by hand (to test) by removing the
1034 * preprocessor conditional around it.
1036 * Define yystrlen such that it will always use strlen. As far as we know,
1037 * strlen provided by all the platforms we use is reliable.
1039 #define yystrlen strlen
1044 * This ends up in parser.h and makes sure those who want to include it pass
1045 * through parser-wrap.h.
1048 #ifndef ALLOW_INCLUDE_PARSER_H
1049 # error "Don't include parser.h directly, include parser-wrap.h instead."
1054 void setstring(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src);
1056 int import_string(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src, char delim);
1062 %parse-param {struct ctf_scanner *scanner}
1063 %parse-param {yyscan_t yyscanner}
1064 %lex-param {yyscan_t yyscanner}
1066 * Expect two shift-reduce conflicts. Caused by enum name-opt : type {}
1067 * vs struct { int :value; } (unnamed bit-field). The default is to
1068 * shift, so whenever we encounter an enumeration, we are doing the
1069 * proper thing (shift). It is illegal to declare an enumeration
1070 * "bit-field", so it is OK if this situation ends up in a parsing
1075 %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
1076 %token <s> IDENTIFIER ID_TYPE
1081 unsigned long long ull;
1087 %type <s> CTF_STRING_LITERAL CTF_CHARACTER_LITERAL
1091 %type <ull> CTF_INTEGER_LITERAL
1092 %type <n> postfix_expression unary_expression unary_expression_or_range
1094 %type <n> declaration
1095 %type <n> event_declaration
1096 %type <n> stream_declaration
1097 %type <n> env_declaration
1098 %type <n> trace_declaration
1099 %type <n> clock_declaration
1100 %type <n> callsite_declaration
1101 %type <n> integer_declaration_specifiers
1102 %type <n> declaration_specifiers
1103 %type <n> alias_declaration_specifiers
1105 %type <n> field_class_declarator_list
1106 %type <n> integer_field_class_specifier
1107 %type <n> field_class_specifier
1108 %type <n> struct_class_specifier
1109 %type <n> variant_field_class_specifier
1110 %type <n> enum_field_class_specifier
1111 %type <n> struct_or_variant_declaration_list
1112 %type <n> struct_or_variant_declaration
1113 %type <n> struct_or_variant_declarator_list
1114 %type <n> struct_or_variant_declarator
1115 %type <n> enumerator_list
1116 %type <n> enumerator
1117 %type <n> abstract_declarator_list
1118 %type <n> abstract_declarator
1119 %type <n> direct_abstract_declarator
1120 %type <n> alias_abstract_declarator_list
1121 %type <n> alias_abstract_declarator
1122 %type <n> direct_alias_abstract_declarator
1123 %type <n> declarator
1124 %type <n> direct_declarator
1125 %type <n> field_class_declarator
1126 %type <n> direct_field_class_declarator
1128 %type <n> ctf_assignment_expression_list
1129 %type <n> ctf_assignment_expression
1136 if (set_parent_node($1, &ctf_scanner_get_ast(scanner)->root))
1137 reparent_error(scanner, "error reparenting to root");
1141 if (set_parent_node($2, &ctf_scanner_get_ast(scanner)->root))
1142 reparent_error(scanner, "error reparenting to root");
1171 | CTF_FLOATING_POINT
1204 /* 2: Phrase structure grammar */
1209 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1210 $$->u.unary_expression.type = UNARY_STRING;
1211 $$->u.unary_expression.u.string = yylval.s;
1215 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1216 $$->u.unary_expression.type = UNARY_STRING;
1217 $$->u.unary_expression.u.string = yylval.s;
1221 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1222 $$->u.unary_expression.type = UNARY_STRING;
1223 $$->u.unary_expression.u.string = yylval.s;
1225 | CTF_INTEGER_LITERAL
1227 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1228 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1229 $$->u.unary_expression.u.unsigned_constant = $1;
1231 | CTF_STRING_LITERAL
1233 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1234 $$->u.unary_expression.type = UNARY_STRING;
1235 $$->u.unary_expression.u.string = $1;
1237 | CTF_CHARACTER_LITERAL
1239 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1240 $$->u.unary_expression.type = UNARY_STRING;
1241 $$->u.unary_expression.u.string = $1;
1243 | CTF_LPAREN unary_expression CTF_RPAREN
1247 | postfix_expression CTF_LSBRAC unary_expression CTF_RSBRAC
1249 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1250 $$->u.unary_expression.type = UNARY_SBRAC;
1251 $$->u.unary_expression.u.sbrac_exp = $3;
1252 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1253 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1255 | postfix_expression CTF_DOT IDENTIFIER
1257 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1258 $$->u.unary_expression.type = UNARY_STRING;
1259 $$->u.unary_expression.u.string = yylval.s;
1260 $$->u.unary_expression.link = UNARY_DOTLINK;
1261 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1262 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1264 | postfix_expression CTF_DOT ID_TYPE
1266 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1267 $$->u.unary_expression.type = UNARY_STRING;
1268 $$->u.unary_expression.u.string = yylval.s;
1269 $$->u.unary_expression.link = UNARY_DOTLINK;
1270 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1271 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1273 | postfix_expression CTF_DOT keywords
1275 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1276 $$->u.unary_expression.type = UNARY_STRING;
1277 $$->u.unary_expression.u.string = yylval.s;
1278 $$->u.unary_expression.link = UNARY_DOTLINK;
1279 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1280 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1282 | postfix_expression CTF_RARROW IDENTIFIER
1284 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1285 $$->u.unary_expression.type = UNARY_STRING;
1286 $$->u.unary_expression.u.string = yylval.s;
1287 $$->u.unary_expression.link = UNARY_ARROWLINK;
1288 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1289 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1291 | postfix_expression CTF_RARROW ID_TYPE
1293 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1294 $$->u.unary_expression.type = UNARY_STRING;
1295 $$->u.unary_expression.u.string = yylval.s;
1296 $$->u.unary_expression.link = UNARY_ARROWLINK;
1297 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1298 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1305 | CTF_PLUS postfix_expression
1308 if ($$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
1309 && $$->u.unary_expression.type != UNARY_SIGNED_CONSTANT) {
1310 reparent_error(scanner, "expecting numeric constant");
1313 | CTF_MINUS postfix_expression
1316 if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1317 $$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
1318 $$->u.unary_expression.u.signed_constant =
1319 -($$->u.unary_expression.u.unsigned_constant);
1320 } else if ($$->u.unary_expression.type == UNARY_SIGNED_CONSTANT) {
1321 $$->u.unary_expression.u.signed_constant =
1322 -($$->u.unary_expression.u.signed_constant);
1324 reparent_error(scanner, "expecting numeric constant");
1329 unary_expression_or_range:
1330 unary_expression CTF_DOTDOTDOT unary_expression
1333 _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
1334 $3->u.unary_expression.link = UNARY_DOTDOTDOT;
1340 /* 2.2: Declarations */
1343 declaration_specifiers CTF_SEMICOLON
1347 | stream_declaration
1355 | callsite_declaration
1357 | declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
1359 struct ctf_node *list;
1361 $$ = make_node(scanner, NODE_TYPEDEF);
1362 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1363 $$->u.field_class_def.field_class_specifier_list = list;
1364 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1365 _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1366 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1368 | 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(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1376 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1378 | declaration_specifiers CTF_TYPEDEF 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(&($1)->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 | CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
1390 struct ctf_node *list;
1392 $$ = make_node(scanner, NODE_TYPEALIAS);
1393 $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1394 $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1396 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1397 $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
1398 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1399 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
1401 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1402 $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
1403 _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1404 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
1409 event_declaration_begin event_declaration_end
1411 $$ = make_node(scanner, NODE_EVENT);
1413 | event_declaration_begin ctf_assignment_expression_list event_declaration_end
1415 $$ = make_node(scanner, NODE_EVENT);
1416 if (set_parent_node($2, $$))
1417 reparent_error(scanner, "event_declaration");
1421 event_declaration_begin:
1423 { push_scope(scanner); }
1426 event_declaration_end:
1427 CTF_RBRAC CTF_SEMICOLON
1428 { pop_scope(scanner); }
1433 stream_declaration_begin stream_declaration_end
1435 $$ = make_node(scanner, NODE_STREAM);
1437 | stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
1439 $$ = make_node(scanner, NODE_STREAM);
1440 if (set_parent_node($2, $$))
1441 reparent_error(scanner, "stream_declaration");
1445 stream_declaration_begin:
1446 CTF_STREAM CTF_LBRAC
1447 { push_scope(scanner); }
1450 stream_declaration_end:
1451 CTF_RBRAC CTF_SEMICOLON
1452 { pop_scope(scanner); }
1456 env_declaration_begin env_declaration_end
1458 $$ = make_node(scanner, NODE_ENV);
1460 | env_declaration_begin ctf_assignment_expression_list env_declaration_end
1462 $$ = make_node(scanner, NODE_ENV);
1463 if (set_parent_node($2, $$))
1464 reparent_error(scanner, "env declaration");
1468 env_declaration_begin:
1470 { push_scope(scanner); }
1473 env_declaration_end:
1474 CTF_RBRAC CTF_SEMICOLON
1475 { pop_scope(scanner); }
1479 trace_declaration_begin trace_declaration_end
1481 $$ = make_node(scanner, NODE_TRACE);
1483 | trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
1485 $$ = make_node(scanner, NODE_TRACE);
1486 if (set_parent_node($2, $$))
1487 reparent_error(scanner, "trace_declaration");
1491 trace_declaration_begin:
1493 { push_scope(scanner); }
1496 trace_declaration_end:
1497 CTF_RBRAC CTF_SEMICOLON
1498 { pop_scope(scanner); }
1502 CTF_CLOCK clock_declaration_begin clock_declaration_end
1504 $$ = make_node(scanner, NODE_CLOCK);
1506 | CTF_CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
1508 $$ = make_node(scanner, NODE_CLOCK);
1509 if (set_parent_node($3, $$))
1510 reparent_error(scanner, "trace_declaration");
1514 clock_declaration_begin:
1516 { push_scope(scanner); }
1519 clock_declaration_end:
1520 CTF_RBRAC CTF_SEMICOLON
1521 { pop_scope(scanner); }
1524 callsite_declaration:
1525 CTF_CALLSITE callsite_declaration_begin callsite_declaration_end
1527 $$ = make_node(scanner, NODE_CALLSITE);
1529 | CTF_CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
1531 $$ = make_node(scanner, NODE_CALLSITE);
1532 if (set_parent_node($3, $$))
1533 reparent_error(scanner, "trace_declaration");
1537 callsite_declaration_begin:
1539 { push_scope(scanner); }
1542 callsite_declaration_end:
1543 CTF_RBRAC CTF_SEMICOLON
1544 { pop_scope(scanner); }
1547 integer_declaration_specifiers:
1550 struct ctf_node *node;
1552 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1553 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1554 node->u.field_class_specifier.type = TYPESPEC_CONST;
1555 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1557 | integer_field_class_specifier
1559 struct ctf_node *node;
1561 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1563 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1565 | integer_declaration_specifiers CTF_CONST
1567 struct ctf_node *node;
1570 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1571 node->u.field_class_specifier.type = TYPESPEC_CONST;
1572 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1574 | integer_declaration_specifiers integer_field_class_specifier
1577 bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
1581 declaration_specifiers:
1584 struct ctf_node *node;
1586 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1587 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1588 node->u.field_class_specifier.type = TYPESPEC_CONST;
1589 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1591 | field_class_specifier
1593 struct ctf_node *node;
1595 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1597 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1599 | declaration_specifiers CTF_CONST
1601 struct ctf_node *node;
1604 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1605 node->u.field_class_specifier.type = TYPESPEC_CONST;
1606 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1608 | declaration_specifiers field_class_specifier
1611 bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
1615 field_class_declarator_list:
1616 field_class_declarator
1618 | field_class_declarator_list CTF_COMMA field_class_declarator
1621 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1625 integer_field_class_specifier:
1628 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1629 $$->u.field_class_specifier.type = TYPESPEC_CHAR;
1633 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1634 $$->u.field_class_specifier.type = TYPESPEC_SHORT;
1638 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1639 $$->u.field_class_specifier.type = TYPESPEC_INT;
1643 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1644 $$->u.field_class_specifier.type = TYPESPEC_LONG;
1648 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1649 $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
1653 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1654 $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
1658 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1659 $$->u.field_class_specifier.type = TYPESPEC_BOOL;
1663 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1664 $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
1665 $$->u.field_class_specifier.id_type = yylval.s;
1667 | CTF_INTEGER CTF_LBRAC CTF_RBRAC
1669 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1670 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1671 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1673 | CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1675 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1676 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1677 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1678 if (set_parent_node($3, $$->u.field_class_specifier.node))
1679 reparent_error(scanner, "integer reparent error");
1683 field_class_specifier:
1686 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1687 $$->u.field_class_specifier.type = TYPESPEC_VOID;
1691 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1692 $$->u.field_class_specifier.type = TYPESPEC_CHAR;
1696 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1697 $$->u.field_class_specifier.type = TYPESPEC_SHORT;
1701 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1702 $$->u.field_class_specifier.type = TYPESPEC_INT;
1706 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1707 $$->u.field_class_specifier.type = TYPESPEC_LONG;
1711 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1712 $$->u.field_class_specifier.type = TYPESPEC_FLOAT;
1716 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1717 $$->u.field_class_specifier.type = TYPESPEC_DOUBLE;
1721 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1722 $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
1726 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1727 $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
1731 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1732 $$->u.field_class_specifier.type = TYPESPEC_BOOL;
1736 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1737 $$->u.field_class_specifier.type = TYPESPEC_COMPLEX;
1741 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1742 $$->u.field_class_specifier.type = TYPESPEC_IMAGINARY;
1746 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1747 $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
1748 $$->u.field_class_specifier.id_type = yylval.s;
1750 | CTF_FLOATING_POINT CTF_LBRAC CTF_RBRAC
1752 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1753 $$->u.field_class_specifier.type = TYPESPEC_FLOATING_POINT;
1754 $$->u.field_class_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1756 | CTF_FLOATING_POINT CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1758 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1759 $$->u.field_class_specifier.type = TYPESPEC_FLOATING_POINT;
1760 $$->u.field_class_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1761 if (set_parent_node($3, $$->u.field_class_specifier.node))
1762 reparent_error(scanner, "floating point reparent error");
1764 | CTF_INTEGER CTF_LBRAC CTF_RBRAC
1766 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1767 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1768 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1770 | CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1772 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1773 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1774 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1775 if (set_parent_node($3, $$->u.field_class_specifier.node))
1776 reparent_error(scanner, "integer reparent error");
1780 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1781 $$->u.field_class_specifier.type = TYPESPEC_STRING;
1782 $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1784 | CTF_STRING CTF_LBRAC CTF_RBRAC
1786 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1787 $$->u.field_class_specifier.type = TYPESPEC_STRING;
1788 $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1790 | CTF_STRING CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1792 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1793 $$->u.field_class_specifier.type = TYPESPEC_STRING;
1794 $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1795 if (set_parent_node($3, $$->u.field_class_specifier.node))
1796 reparent_error(scanner, "string reparent error");
1798 | CTF_ENUM enum_field_class_specifier
1800 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1801 $$->u.field_class_specifier.type = TYPESPEC_ENUM;
1802 $$->u.field_class_specifier.node = $2;
1804 | CTF_VARIANT variant_field_class_specifier
1806 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1807 $$->u.field_class_specifier.type = TYPESPEC_VARIANT;
1808 $$->u.field_class_specifier.node = $2;
1810 | CTF_STRUCT struct_class_specifier
1812 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1813 $$->u.field_class_specifier.type = TYPESPEC_STRUCT;
1814 $$->u.field_class_specifier.node = $2;
1818 struct_class_specifier:
1819 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1821 $$ = make_node(scanner, NODE_STRUCT);
1822 $$->u._struct.has_body = 1;
1823 if ($2 && set_parent_node($2, $$))
1824 reparent_error(scanner, "struct reparent error");
1826 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1828 $$ = make_node(scanner, NODE_STRUCT);
1829 $$->u._struct.has_body = 1;
1830 $$->u._struct.name = $1;
1831 if ($3 && set_parent_node($3, $$))
1832 reparent_error(scanner, "struct reparent error");
1834 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1836 $$ = make_node(scanner, NODE_STRUCT);
1837 $$->u._struct.has_body = 1;
1838 $$->u._struct.name = $1;
1839 if ($3 && set_parent_node($3, $$))
1840 reparent_error(scanner, "struct reparent error");
1844 $$ = make_node(scanner, NODE_STRUCT);
1845 $$->u._struct.has_body = 0;
1846 $$->u._struct.name = $1;
1850 $$ = make_node(scanner, NODE_STRUCT);
1851 $$->u._struct.has_body = 0;
1852 $$->u._struct.name = $1;
1854 | struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1856 $$ = make_node(scanner, NODE_STRUCT);
1857 $$->u._struct.has_body = 1;
1858 bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
1859 if ($2 && set_parent_node($2, $$))
1860 reparent_error(scanner, "struct reparent error");
1862 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1864 $$ = make_node(scanner, NODE_STRUCT);
1865 $$->u._struct.has_body = 1;
1866 $$->u._struct.name = $1;
1867 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1868 if ($3 && set_parent_node($3, $$))
1869 reparent_error(scanner, "struct reparent error");
1871 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1873 $$ = make_node(scanner, NODE_STRUCT);
1874 $$->u._struct.has_body = 1;
1875 $$->u._struct.name = $1;
1876 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1877 if ($3 && set_parent_node($3, $$))
1878 reparent_error(scanner, "struct reparent error");
1882 struct_declaration_begin:
1884 { push_scope(scanner); }
1887 struct_declaration_end:
1889 { pop_scope(scanner); }
1892 variant_field_class_specifier:
1893 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1895 $$ = make_node(scanner, NODE_VARIANT);
1896 $$->u.variant.has_body = 1;
1897 if ($2 && set_parent_node($2, $$))
1898 reparent_error(scanner, "variant reparent error");
1900 | CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1902 $$ = make_node(scanner, NODE_VARIANT);
1903 $$->u.variant.has_body = 1;
1904 $$->u.variant.choice = $2;
1905 if ($5 && set_parent_node($5, $$))
1906 reparent_error(scanner, "variant reparent error");
1908 | CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1910 $$ = make_node(scanner, NODE_VARIANT);
1911 $$->u.variant.has_body = 1;
1912 $$->u.variant.choice = $2;
1913 if ($5 && set_parent_node($5, $$))
1914 reparent_error(scanner, "variant reparent error");
1916 | IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1918 $$ = make_node(scanner, NODE_VARIANT);
1919 $$->u.variant.has_body = 1;
1920 $$->u.variant.name = $1;
1921 if ($3 && set_parent_node($3, $$))
1922 reparent_error(scanner, "variant reparent error");
1924 | IDENTIFIER CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1926 $$ = make_node(scanner, NODE_VARIANT);
1927 $$->u.variant.has_body = 1;
1928 $$->u.variant.name = $1;
1929 $$->u.variant.choice = $3;
1930 if ($6 && set_parent_node($6, $$))
1931 reparent_error(scanner, "variant reparent error");
1933 | IDENTIFIER CTF_LT IDENTIFIER CTF_GT
1935 $$ = make_node(scanner, NODE_VARIANT);
1936 $$->u.variant.has_body = 0;
1937 $$->u.variant.name = $1;
1938 $$->u.variant.choice = $3;
1940 | IDENTIFIER CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1942 $$ = make_node(scanner, NODE_VARIANT);
1943 $$->u.variant.has_body = 1;
1944 $$->u.variant.name = $1;
1945 $$->u.variant.choice = $3;
1946 if ($6 && set_parent_node($6, $$))
1947 reparent_error(scanner, "variant reparent error");
1949 | IDENTIFIER CTF_LT ID_TYPE CTF_GT
1951 $$ = make_node(scanner, NODE_VARIANT);
1952 $$->u.variant.has_body = 0;
1953 $$->u.variant.name = $1;
1954 $$->u.variant.choice = $3;
1956 | ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1958 $$ = make_node(scanner, NODE_VARIANT);
1959 $$->u.variant.has_body = 1;
1960 $$->u.variant.name = $1;
1961 if ($3 && set_parent_node($3, $$))
1962 reparent_error(scanner, "variant reparent error");
1964 | ID_TYPE CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1966 $$ = make_node(scanner, NODE_VARIANT);
1967 $$->u.variant.has_body = 1;
1968 $$->u.variant.name = $1;
1969 $$->u.variant.choice = $3;
1970 if ($6 && set_parent_node($6, $$))
1971 reparent_error(scanner, "variant reparent error");
1973 | ID_TYPE CTF_LT IDENTIFIER CTF_GT
1975 $$ = make_node(scanner, NODE_VARIANT);
1976 $$->u.variant.has_body = 0;
1977 $$->u.variant.name = $1;
1978 $$->u.variant.choice = $3;
1980 | ID_TYPE CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1982 $$ = make_node(scanner, NODE_VARIANT);
1983 $$->u.variant.has_body = 1;
1984 $$->u.variant.name = $1;
1985 $$->u.variant.choice = $3;
1986 if ($6 && set_parent_node($6, $$))
1987 reparent_error(scanner, "variant reparent error");
1989 | ID_TYPE CTF_LT ID_TYPE CTF_GT
1991 $$ = make_node(scanner, NODE_VARIANT);
1992 $$->u.variant.has_body = 0;
1993 $$->u.variant.name = $1;
1994 $$->u.variant.choice = $3;
1998 variant_declaration_begin:
2000 { push_scope(scanner); }
2003 variant_declaration_end:
2005 { pop_scope(scanner); }
2008 enum_field_class_specifier:
2009 CTF_LBRAC enumerator_list CTF_RBRAC
2011 $$ = make_node(scanner, NODE_ENUM);
2012 $$->u._enum.has_body = 1;
2013 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
2015 | CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2017 $$ = make_node(scanner, NODE_ENUM);
2018 $$->u._enum.has_body = 1;
2019 ($$)->u._enum.container_field_class = $2;
2020 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2022 | IDENTIFIER CTF_LBRAC enumerator_list CTF_RBRAC
2024 $$ = make_node(scanner, NODE_ENUM);
2025 $$->u._enum.has_body = 1;
2026 $$->u._enum.enum_id = $1;
2027 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2029 | IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2031 $$ = make_node(scanner, NODE_ENUM);
2032 $$->u._enum.has_body = 1;
2033 $$->u._enum.enum_id = $1;
2034 ($$)->u._enum.container_field_class = $3;
2035 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2037 | ID_TYPE CTF_LBRAC enumerator_list CTF_RBRAC
2039 $$ = make_node(scanner, NODE_ENUM);
2040 $$->u._enum.has_body = 1;
2041 $$->u._enum.enum_id = $1;
2042 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2044 | ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2046 $$ = make_node(scanner, NODE_ENUM);
2047 $$->u._enum.has_body = 1;
2048 $$->u._enum.enum_id = $1;
2049 ($$)->u._enum.container_field_class = $3;
2050 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2052 | CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2054 $$ = make_node(scanner, NODE_ENUM);
2055 $$->u._enum.has_body = 1;
2056 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
2058 | CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2060 $$ = make_node(scanner, NODE_ENUM);
2061 $$->u._enum.has_body = 1;
2062 ($$)->u._enum.container_field_class = $2;
2063 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2065 | IDENTIFIER CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2067 $$ = make_node(scanner, NODE_ENUM);
2068 $$->u._enum.has_body = 1;
2069 $$->u._enum.enum_id = $1;
2070 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2072 | IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2074 $$ = make_node(scanner, NODE_ENUM);
2075 $$->u._enum.has_body = 1;
2076 $$->u._enum.enum_id = $1;
2077 ($$)->u._enum.container_field_class = $3;
2078 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2082 $$ = make_node(scanner, NODE_ENUM);
2083 $$->u._enum.has_body = 0;
2084 $$->u._enum.enum_id = $1;
2086 | ID_TYPE CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2088 $$ = make_node(scanner, NODE_ENUM);
2089 $$->u._enum.has_body = 1;
2090 $$->u._enum.enum_id = $1;
2091 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2093 | ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2095 $$ = make_node(scanner, NODE_ENUM);
2096 $$->u._enum.has_body = 1;
2097 $$->u._enum.enum_id = $1;
2098 ($$)->u._enum.container_field_class = $3;
2099 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2103 $$ = make_node(scanner, NODE_ENUM);
2104 $$->u._enum.has_body = 0;
2105 $$->u._enum.enum_id = $1;
2109 struct_or_variant_declaration_list:
2112 | struct_or_variant_declaration_list struct_or_variant_declaration
2116 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2119 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
2124 struct_or_variant_declaration:
2125 declaration_specifiers struct_or_variant_declarator_list CTF_SEMICOLON
2127 struct ctf_node *list;
2129 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2130 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2131 $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
2132 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2133 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.field_class_declarators);
2135 | declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
2137 struct ctf_node *list;
2139 $$ = make_node(scanner, NODE_TYPEDEF);
2140 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2141 $$->u.field_class_def.field_class_specifier_list = list;
2142 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2143 _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2144 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2146 | 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(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2154 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2156 | declaration_specifiers CTF_TYPEDEF field_class_declarator_list CTF_SEMICOLON
2158 struct ctf_node *list;
2160 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2161 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2162 $$ = make_node(scanner, NODE_TYPEDEF);
2163 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2164 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2166 | CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
2168 struct ctf_node *list;
2170 $$ = make_node(scanner, NODE_TYPEALIAS);
2171 $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2172 $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2174 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2175 $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
2176 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2177 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
2179 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2180 $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
2181 _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2182 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
2186 alias_declaration_specifiers:
2189 struct ctf_node *node;
2191 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2192 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2193 node->u.field_class_specifier.type = TYPESPEC_CONST;
2194 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2196 | field_class_specifier
2198 struct ctf_node *node;
2200 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2202 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2206 struct ctf_node *node;
2208 add_type(scanner, $1);
2209 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2210 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2211 node->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
2212 node->u.field_class_specifier.id_type = yylval.s;
2213 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2215 | alias_declaration_specifiers CTF_CONST
2217 struct ctf_node *node;
2220 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2221 node->u.field_class_specifier.type = TYPESPEC_CONST;
2222 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2224 | alias_declaration_specifiers field_class_specifier
2227 bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
2229 | alias_declaration_specifiers IDENTIFIER
2231 struct ctf_node *node;
2233 add_type(scanner, $2);
2235 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2236 node->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
2237 node->u.field_class_specifier.id_type = yylval.s;
2238 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2242 struct_or_variant_declarator_list:
2243 struct_or_variant_declarator
2245 | struct_or_variant_declarator_list CTF_COMMA struct_or_variant_declarator
2248 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2252 struct_or_variant_declarator:
2255 | CTF_COLON unary_expression
2257 | declarator CTF_COLON unary_expression
2260 if (set_parent_node($3, $1))
2261 reparent_error(scanner, "struct_or_variant_declarator");
2268 | enumerator_list CTF_COMMA enumerator
2271 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2278 $$ = make_node(scanner, NODE_ENUMERATOR);
2279 $$->u.enumerator.id = $1;
2283 $$ = make_node(scanner, NODE_ENUMERATOR);
2284 $$->u.enumerator.id = $1;
2288 $$ = make_node(scanner, NODE_ENUMERATOR);
2289 $$->u.enumerator.id = $1;
2291 | CTF_STRING_LITERAL
2293 $$ = make_node(scanner, NODE_ENUMERATOR);
2294 $$->u.enumerator.id = $1;
2296 | IDENTIFIER CTF_EQUAL unary_expression_or_range
2298 $$ = make_node(scanner, NODE_ENUMERATOR);
2299 $$->u.enumerator.id = $1;
2300 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2302 | ID_TYPE CTF_EQUAL unary_expression_or_range
2304 $$ = make_node(scanner, NODE_ENUMERATOR);
2305 $$->u.enumerator.id = $1;
2306 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2308 | keywords CTF_EQUAL unary_expression_or_range
2310 $$ = make_node(scanner, NODE_ENUMERATOR);
2311 $$->u.enumerator.id = $1;
2312 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2314 | CTF_STRING_LITERAL CTF_EQUAL unary_expression_or_range
2316 $$ = make_node(scanner, NODE_ENUMERATOR);
2317 $$->u.enumerator.id = $1;
2318 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2322 abstract_declarator_list:
2325 | abstract_declarator_list CTF_COMMA abstract_declarator
2328 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2332 abstract_declarator:
2333 direct_abstract_declarator
2335 | pointer direct_abstract_declarator
2338 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2342 direct_abstract_declarator:
2345 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2346 $$->u.field_class_declarator.type = TYPEDEC_ID;
2351 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2352 $$->u.field_class_declarator.type = TYPEDEC_ID;
2353 $$->u.field_class_declarator.u.id = $1;
2355 | CTF_LPAREN abstract_declarator CTF_RPAREN
2357 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2358 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2359 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2361 | direct_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2363 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2364 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2365 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2366 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2367 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2369 | direct_abstract_declarator CTF_LSBRAC CTF_RSBRAC
2371 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2372 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2373 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2374 $$->u.field_class_declarator.u.nested.abstract_array = 1;
2378 alias_abstract_declarator_list:
2379 alias_abstract_declarator
2381 | alias_abstract_declarator_list CTF_COMMA alias_abstract_declarator
2384 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2388 alias_abstract_declarator:
2389 direct_alias_abstract_declarator
2391 | pointer direct_alias_abstract_declarator
2394 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2398 direct_alias_abstract_declarator:
2401 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2402 $$->u.field_class_declarator.type = TYPEDEC_ID;
2405 | CTF_LPAREN alias_abstract_declarator CTF_RPAREN
2407 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2408 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2409 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2411 | direct_alias_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2413 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2414 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2415 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2416 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2417 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2419 | direct_alias_abstract_declarator CTF_LSBRAC CTF_RSBRAC
2421 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2422 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2423 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2424 $$->u.field_class_declarator.u.nested.abstract_array = 1;
2431 | pointer direct_declarator
2434 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2441 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2442 $$->u.field_class_declarator.type = TYPEDEC_ID;
2443 $$->u.field_class_declarator.u.id = $1;
2445 | CTF_LPAREN declarator CTF_RPAREN
2447 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2448 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2449 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2451 | direct_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2453 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2454 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2455 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2456 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2457 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2461 field_class_declarator:
2462 direct_field_class_declarator
2464 | pointer direct_field_class_declarator
2467 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2471 direct_field_class_declarator:
2474 add_type(scanner, $1);
2475 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2476 $$->u.field_class_declarator.type = TYPEDEC_ID;
2477 $$->u.field_class_declarator.u.id = $1;
2479 | CTF_LPAREN field_class_declarator CTF_RPAREN
2481 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2482 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2483 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2485 | direct_field_class_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2487 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2488 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2489 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2490 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2491 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2498 $$ = make_node(scanner, NODE_POINTER);
2502 $$ = make_node(scanner, NODE_POINTER);
2503 bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
2505 | CTF_STAR type_qualifier_list pointer
2507 $$ = make_node(scanner, NODE_POINTER);
2508 $$->u.pointer.const_qualifier = 1;
2509 bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
2513 type_qualifier_list:
2514 /* pointer assumes only const type qualifier */
2516 | type_qualifier_list CTF_CONST
2519 /* 2.3: CTF-specific declarations */
2521 ctf_assignment_expression_list:
2522 ctf_assignment_expression CTF_SEMICOLON
2524 | ctf_assignment_expression_list ctf_assignment_expression CTF_SEMICOLON
2527 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2531 ctf_assignment_expression:
2532 unary_expression CTF_EQUAL unary_expression
2535 * Because we have left and right, cannot use
2538 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2539 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2540 if ($1->u.unary_expression.type != UNARY_STRING)
2541 reparent_error(scanner, "ctf_assignment_expression left expects string");
2542 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
2544 | unary_expression CTF_TYPEASSIGN declaration_specifiers /* Only allow struct */
2547 * Because we have left and right, cannot use
2550 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2551 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2552 if ($1->u.unary_expression.type != UNARY_STRING)
2553 reparent_error(scanner, "ctf_assignment_expression left expects string");
2554 bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
2556 | declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list
2558 struct ctf_node *list;
2560 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2561 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2562 _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2563 $$ = make_node(scanner, NODE_TYPEDEF);
2564 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2565 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2567 | CTF_TYPEDEF declaration_specifiers field_class_declarator_list
2569 struct ctf_node *list;
2571 $$ = make_node(scanner, NODE_TYPEDEF);
2572 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2573 $$->u.field_class_def.field_class_specifier_list = list;
2574 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2575 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2577 | declaration_specifiers CTF_TYPEDEF field_class_declarator_list
2579 struct ctf_node *list;
2581 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2582 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2583 $$ = make_node(scanner, NODE_TYPEDEF);
2584 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2585 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2587 | CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
2589 struct ctf_node *list;
2591 $$ = make_node(scanner, NODE_TYPEALIAS);
2592 $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2593 $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2595 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2596 $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
2597 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2598 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
2600 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2601 $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
2602 _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2603 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);