5 * Common Trace Format Metadata Grammar.
7 * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
9 * Permission is hereby granted, free of charge, to any person obtaining a copy
10 * of this software and associated documentation files (the "Software"), to deal
11 * in the Software without restriction, including without limitation the rights
12 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 * copies of the Software, and to permit persons to whom the Software is
14 * furnished to do so, subject to the following conditions:
16 * The above copyright notice and this permission notice shall be included in
17 * all copies or substantial portions of the Software.
28 #include <babeltrace/list.h>
29 #include <babeltrace/babeltrace-internal.h>
30 #include "ctf-scanner.h"
31 #include "ctf-parser.h"
34 __attribute__((visibility("hidden")))
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 __attribute__((visibility("hidden")))
51 int yyparse(struct ctf_scanner *scanner);
52 __attribute__((visibility("hidden")))
53 int yylex(union YYSTYPE *yyval, struct ctf_scanner *scanner);
54 __attribute__((visibility("hidden")))
55 int yylex_init_extra(struct ctf_scanner *scanner, yyscan_t * ptr_yy_globals);
56 __attribute__((visibility("hidden")))
57 int yylex_destroy(yyscan_t yyscanner);
58 __attribute__((visibility("hidden")))
59 void yyrestart(FILE * in_str, yyscan_t scanner);
62 struct bt_list_head gc;
67 static const char *node_type_to_str[] = {
68 [ NODE_UNKNOWN ] = "NODE_UNKNOWN",
69 [ NODE_ROOT ] = "NODE_ROOT",
70 [ NODE_EVENT ] = "NODE_EVENT",
71 [ NODE_ENV ] = "NODE_ENV",
72 [ NODE_STREAM ] = "NODE_STREAM",
73 [ NODE_TRACE ] = "NODE_TRACE",
74 [ NODE_CLOCK ] = "NODE_CLOCK",
75 [ NODE_CALLSITE ] = "NODE_CALLSITE",
76 [ NODE_CTF_EXPRESSION ] = "NODE_CTF_EXPRESSION",
77 [ NODE_UNARY_EXPRESSION ] = "NODE_UNARY_EXPRESSION",
78 [ NODE_TYPEDEF ] = "NODE_TYPEDEF",
79 [ NODE_TYPEALIAS_TARGET ] = "NODE_TYPEALIAS_TARGET",
80 [ NODE_TYPEALIAS_ALIAS ] = "NODE_TYPEALIAS_ALIAS",
81 [ NODE_TYPEALIAS ] = "NODE_TYPEALIAS",
82 [ NODE_TYPE_SPECIFIER ] = "NODE_TYPE_SPECIFIER",
83 [ NODE_TYPE_SPECIFIER_LIST ] = "NODE_TYPE_SPECIFIER_LIST",
84 [ NODE_POINTER ] = "NODE_POINTER",
85 [ NODE_TYPE_DECLARATOR ] = "NODE_TYPE_DECLARATOR",
86 [ NODE_FLOATING_POINT ] = "NODE_FLOATING_POINT",
87 [ NODE_INTEGER ] = "NODE_INTEGER",
88 [ NODE_STRING ] = "NODE_STRING",
89 [ NODE_ENUMERATOR ] = "NODE_ENUMERATOR",
90 [ NODE_ENUM ] = "NODE_ENUM",
91 [ NODE_STRUCT_OR_VARIANT_DECLARATION ] = "NODE_STRUCT_OR_VARIANT_DECLARATION",
92 [ NODE_VARIANT ] = "NODE_VARIANT",
93 [ NODE_STRUCT ] = "NODE_STRUCT",
96 __attribute__((visibility("hidden")))
97 const char *node_type(struct ctf_node *node)
99 if (node->type < NR_NODE_TYPES)
100 return node_type_to_str[node->type];
105 static struct gc_string *gc_string_alloc(struct ctf_scanner *scanner,
108 struct gc_string *gstr;
111 /* TODO: could be faster with find first bit or glib Gstring */
112 /* sizeof long to account for malloc header (int or long ?) */
113 for (alloclen = 8; alloclen < sizeof(long) + sizeof(*gstr) + len;
116 gstr = malloc(alloclen);
117 bt_list_add(&gstr->gc, &scanner->allocated_strings);
118 gstr->alloclen = alloclen;
123 * note: never use gc_string_append on a string that has external references.
124 * gsrc will be garbage collected immediately, and gstr might be.
125 * Should only be used to append characters to a string literal or constant.
127 __attribute__((visibility("hidden")))
128 struct gc_string *gc_string_append(struct ctf_scanner *scanner,
129 struct gc_string *gstr,
130 struct gc_string *gsrc)
132 size_t newlen = strlen(gsrc->s) + strlen(gstr->s) + 1;
135 /* TODO: could be faster with find first bit or glib Gstring */
136 /* sizeof long to account for malloc header (int or long ?) */
137 for (alloclen = 8; alloclen < sizeof(long) + sizeof(*gstr) + newlen;
140 if (alloclen > gstr->alloclen) {
141 struct gc_string *newgstr;
143 newgstr = gc_string_alloc(scanner, newlen);
144 strcpy(newgstr->s, gstr->s);
145 strcat(newgstr->s, gsrc->s);
146 bt_list_del(&gstr->gc);
150 strcat(gstr->s, gsrc->s);
152 bt_list_del(&gsrc->gc);
157 void setstring(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src)
159 lvalp->gs = gc_string_alloc(scanner, strlen(src) + 1);
160 strcpy(lvalp->gs->s, src);
163 static void init_scope(struct ctf_scanner_scope *scope,
164 struct ctf_scanner_scope *parent)
166 scope->parent = parent;
167 scope->types = g_hash_table_new_full(g_str_hash, g_str_equal,
171 static void finalize_scope(struct ctf_scanner_scope *scope)
173 g_hash_table_destroy(scope->types);
176 static void push_scope(struct ctf_scanner *scanner)
178 struct ctf_scanner_scope *ns;
180 printf_debug("push scope\n");
181 ns = malloc(sizeof(struct ctf_scanner_scope));
182 init_scope(ns, scanner->cs);
186 static void pop_scope(struct ctf_scanner *scanner)
188 struct ctf_scanner_scope *os;
190 printf_debug("pop scope\n");
192 scanner->cs = os->parent;
197 static int lookup_type(struct ctf_scanner_scope *s, const char *id)
201 ret = (int) (long) g_hash_table_lookup(s->types, id);
202 printf_debug("lookup %p %s %d\n", s, id, ret);
206 __attribute__((visibility("hidden")))
207 int is_type(struct ctf_scanner *scanner, const char *id)
209 struct ctf_scanner_scope *it;
212 for (it = scanner->cs; it != NULL; it = it->parent) {
213 if (lookup_type(it, id)) {
218 printf_debug("is type %s %d\n", id, ret);
222 static void add_type(struct ctf_scanner *scanner, struct gc_string *id)
224 printf_debug("add type %s\n", id->s);
225 if (lookup_type(scanner->cs, id->s))
227 g_hash_table_insert(scanner->cs->types, id->s, id->s);
230 static struct ctf_node *make_node(struct ctf_scanner *scanner,
233 struct ctf_ast *ast = ctf_scanner_get_ast(scanner);
234 struct ctf_node *node;
236 node = malloc(sizeof(*node));
239 memset(node, 0, sizeof(*node));
241 BT_INIT_LIST_HEAD(&node->tmp_head);
242 bt_list_add(&node->gc, &ast->allocated_nodes);
243 bt_list_add(&node->siblings, &node->tmp_head);
247 fprintf(stderr, "[error] %s: trying to create root node\n", __func__);
251 BT_INIT_LIST_HEAD(&node->u.event.declaration_list);
254 BT_INIT_LIST_HEAD(&node->u.stream.declaration_list);
257 BT_INIT_LIST_HEAD(&node->u.env.declaration_list);
260 BT_INIT_LIST_HEAD(&node->u.trace.declaration_list);
263 BT_INIT_LIST_HEAD(&node->u.clock.declaration_list);
266 BT_INIT_LIST_HEAD(&node->u.callsite.declaration_list);
269 case NODE_CTF_EXPRESSION:
270 BT_INIT_LIST_HEAD(&node->u.ctf_expression.left);
271 BT_INIT_LIST_HEAD(&node->u.ctf_expression.right);
273 case NODE_UNARY_EXPRESSION:
277 BT_INIT_LIST_HEAD(&node->u._typedef.type_declarators);
279 case NODE_TYPEALIAS_TARGET:
280 BT_INIT_LIST_HEAD(&node->u.typealias_target.type_declarators);
282 case NODE_TYPEALIAS_ALIAS:
283 BT_INIT_LIST_HEAD(&node->u.typealias_alias.type_declarators);
288 case NODE_TYPE_SPECIFIER:
290 case NODE_TYPE_SPECIFIER_LIST:
291 BT_INIT_LIST_HEAD(&node->u.type_specifier_list.head);
295 case NODE_TYPE_DECLARATOR:
296 BT_INIT_LIST_HEAD(&node->u.type_declarator.pointers);
299 case NODE_FLOATING_POINT:
300 BT_INIT_LIST_HEAD(&node->u.floating_point.expressions);
303 BT_INIT_LIST_HEAD(&node->u.integer.expressions);
306 BT_INIT_LIST_HEAD(&node->u.string.expressions);
308 case NODE_ENUMERATOR:
309 BT_INIT_LIST_HEAD(&node->u.enumerator.values);
312 BT_INIT_LIST_HEAD(&node->u._enum.enumerator_list);
314 case NODE_STRUCT_OR_VARIANT_DECLARATION:
315 BT_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.type_declarators);
318 BT_INIT_LIST_HEAD(&node->u.variant.declaration_list);
321 BT_INIT_LIST_HEAD(&node->u._struct.declaration_list);
322 BT_INIT_LIST_HEAD(&node->u._struct.min_align);
327 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
335 static int reparent_ctf_expression(struct ctf_node *node,
336 struct ctf_node *parent)
338 switch (parent->type) {
340 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
343 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
346 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
349 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
352 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
355 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
357 case NODE_FLOATING_POINT:
358 _bt_list_splice_tail(&node->tmp_head, &parent->u.floating_point.expressions);
361 _bt_list_splice_tail(&node->tmp_head, &parent->u.integer.expressions);
364 _bt_list_splice_tail(&node->tmp_head, &parent->u.string.expressions);
368 case NODE_CTF_EXPRESSION:
370 case NODE_TYPEALIAS_TARGET:
371 case NODE_TYPEALIAS_ALIAS:
373 case NODE_TYPE_SPECIFIER:
374 case NODE_TYPE_SPECIFIER_LIST:
376 case NODE_TYPE_DECLARATOR:
377 case NODE_ENUMERATOR:
379 case NODE_STRUCT_OR_VARIANT_DECLARATION:
382 case NODE_UNARY_EXPRESSION:
387 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
394 static int reparent_typedef(struct ctf_node *node, struct ctf_node *parent)
396 switch (parent->type) {
398 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
401 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
404 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
407 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
410 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
413 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
416 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
419 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
422 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
425 case NODE_FLOATING_POINT:
428 case NODE_CTF_EXPRESSION:
430 case NODE_TYPEALIAS_TARGET:
431 case NODE_TYPEALIAS_ALIAS:
433 case NODE_TYPE_SPECIFIER:
434 case NODE_TYPE_SPECIFIER_LIST:
436 case NODE_TYPE_DECLARATOR:
437 case NODE_ENUMERATOR:
439 case NODE_STRUCT_OR_VARIANT_DECLARATION:
440 case NODE_UNARY_EXPRESSION:
445 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
452 static int reparent_typealias(struct ctf_node *node, struct ctf_node *parent)
454 switch (parent->type) {
456 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
459 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
462 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
465 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
468 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
471 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
474 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
477 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
480 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
483 case NODE_FLOATING_POINT:
486 case NODE_CTF_EXPRESSION:
488 case NODE_TYPEALIAS_TARGET:
489 case NODE_TYPEALIAS_ALIAS:
491 case NODE_TYPE_SPECIFIER:
492 case NODE_TYPE_SPECIFIER_LIST:
494 case NODE_TYPE_DECLARATOR:
495 case NODE_ENUMERATOR:
497 case NODE_STRUCT_OR_VARIANT_DECLARATION:
498 case NODE_UNARY_EXPRESSION:
503 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
510 static int reparent_type_specifier(struct ctf_node *node,
511 struct ctf_node *parent)
513 switch (parent->type) {
514 case NODE_TYPE_SPECIFIER_LIST:
515 _bt_list_splice_tail(&node->tmp_head, &parent->u.type_specifier_list.head);
518 case NODE_TYPE_SPECIFIER:
528 case NODE_TYPEALIAS_TARGET:
529 case NODE_TYPEALIAS_ALIAS:
530 case NODE_TYPE_DECLARATOR:
532 case NODE_STRUCT_OR_VARIANT_DECLARATION:
534 case NODE_FLOATING_POINT:
537 case NODE_CTF_EXPRESSION:
539 case NODE_ENUMERATOR:
540 case NODE_UNARY_EXPRESSION:
545 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
552 static int reparent_type_specifier_list(struct ctf_node *node,
553 struct ctf_node *parent)
555 switch (parent->type) {
557 bt_list_add_tail(&node->siblings, &parent->u.root.declaration_list);
560 bt_list_add_tail(&node->siblings, &parent->u.event.declaration_list);
563 bt_list_add_tail(&node->siblings, &parent->u.stream.declaration_list);
566 bt_list_add_tail(&node->siblings, &parent->u.env.declaration_list);
569 bt_list_add_tail(&node->siblings, &parent->u.trace.declaration_list);
572 bt_list_add_tail(&node->siblings, &parent->u.clock.declaration_list);
575 bt_list_add_tail(&node->siblings, &parent->u.callsite.declaration_list);
578 bt_list_add_tail(&node->siblings, &parent->u.variant.declaration_list);
581 bt_list_add_tail(&node->siblings, &parent->u._struct.declaration_list);
584 parent->u._typedef.type_specifier_list = node;
586 case NODE_TYPEALIAS_TARGET:
587 parent->u.typealias_target.type_specifier_list = node;
589 case NODE_TYPEALIAS_ALIAS:
590 parent->u.typealias_alias.type_specifier_list = node;
593 parent->u._enum.container_type = node;
595 case NODE_STRUCT_OR_VARIANT_DECLARATION:
596 parent->u.struct_or_variant_declaration.type_specifier_list = node;
598 case NODE_TYPE_DECLARATOR:
599 case NODE_TYPE_SPECIFIER:
601 case NODE_FLOATING_POINT:
604 case NODE_CTF_EXPRESSION:
606 case NODE_ENUMERATOR:
607 case NODE_UNARY_EXPRESSION:
612 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
619 static int reparent_type_declarator(struct ctf_node *node,
620 struct ctf_node *parent)
622 switch (parent->type) {
623 case NODE_TYPE_DECLARATOR:
624 parent->u.type_declarator.type = TYPEDEC_NESTED;
625 parent->u.type_declarator.u.nested.type_declarator = node;
627 case NODE_STRUCT_OR_VARIANT_DECLARATION:
628 _bt_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.type_declarators);
631 _bt_list_splice_tail(&node->tmp_head, &parent->u._typedef.type_declarators);
633 case NODE_TYPEALIAS_TARGET:
634 _bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_target.type_declarators);
636 case NODE_TYPEALIAS_ALIAS:
637 _bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_alias.type_declarators);
651 case NODE_FLOATING_POINT:
654 case NODE_CTF_EXPRESSION:
655 case NODE_TYPE_SPECIFIER:
656 case NODE_TYPE_SPECIFIER_LIST:
658 case NODE_ENUMERATOR:
659 case NODE_UNARY_EXPRESSION:
664 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
674 * Link node to parent. Returns 0 on success, -EPERM if it is not permitted to
675 * create the link declared by the input, -ENOENT if node or parent is NULL,
676 * -EINVAL if there is an internal structure problem.
678 static int set_parent_node(struct ctf_node *node,
679 struct ctf_node *parent)
681 if (!node || !parent)
684 /* Note: Linking to parent will be done only by an external visitor */
686 switch (node->type) {
688 fprintf(stderr, "[error] %s: trying to reparent root node\n", __func__);
692 if (parent->type == NODE_ROOT) {
693 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.event);
699 if (parent->type == NODE_ROOT) {
700 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.stream);
706 if (parent->type == NODE_ROOT) {
707 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.env);
713 if (parent->type == NODE_ROOT) {
714 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.trace);
720 if (parent->type == NODE_ROOT) {
721 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.clock);
727 if (parent->type == NODE_ROOT) {
728 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.callsite);
734 case NODE_CTF_EXPRESSION:
735 return reparent_ctf_expression(node, parent);
736 case NODE_UNARY_EXPRESSION:
737 if (parent->type == NODE_TYPE_DECLARATOR)
738 parent->u.type_declarator.bitfield_len = node;
744 return reparent_typedef(node, parent);
745 case NODE_TYPEALIAS_TARGET:
746 if (parent->type == NODE_TYPEALIAS)
747 parent->u.typealias.target = node;
750 case NODE_TYPEALIAS_ALIAS:
751 if (parent->type == NODE_TYPEALIAS)
752 parent->u.typealias.alias = node;
756 return reparent_typealias(node, parent);
759 if (parent->type == NODE_TYPE_DECLARATOR) {
760 _bt_list_splice_tail(&node->tmp_head, &parent->u.type_declarator.pointers);
764 case NODE_TYPE_DECLARATOR:
765 return reparent_type_declarator(node, parent);
767 case NODE_TYPE_SPECIFIER_LIST:
768 return reparent_type_specifier_list(node, parent);
770 case NODE_TYPE_SPECIFIER:
771 return reparent_type_specifier(node, parent);
773 case NODE_FLOATING_POINT:
779 return -EINVAL; /* Dealt with internally within grammar */
781 case NODE_ENUMERATOR:
782 if (parent->type == NODE_ENUM) {
783 _bt_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
788 case NODE_STRUCT_OR_VARIANT_DECLARATION:
789 switch (parent->type) {
791 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
794 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
803 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
810 __attribute__((visibility("hidden")))
811 void yyerror(struct ctf_scanner *scanner, const char *str)
813 fprintf(stderr, "error %s\n", str);
816 __attribute__((visibility("hidden")))
822 #define reparent_error(scanner, str) \
824 yyerror(scanner, YY_("reparent_error: " str "\n")); \
828 static void free_strings(struct bt_list_head *list)
830 struct gc_string *gstr, *tmp;
832 bt_list_for_each_entry_safe(gstr, tmp, list, gc)
836 static struct ctf_ast *ctf_ast_alloc(void)
840 ast = malloc(sizeof(*ast));
843 memset(ast, 0, sizeof(*ast));
844 BT_INIT_LIST_HEAD(&ast->allocated_nodes);
845 ast->root.type = NODE_ROOT;
846 BT_INIT_LIST_HEAD(&ast->root.tmp_head);
847 BT_INIT_LIST_HEAD(&ast->root.u.root.declaration_list);
848 BT_INIT_LIST_HEAD(&ast->root.u.root.trace);
849 BT_INIT_LIST_HEAD(&ast->root.u.root.env);
850 BT_INIT_LIST_HEAD(&ast->root.u.root.stream);
851 BT_INIT_LIST_HEAD(&ast->root.u.root.event);
852 BT_INIT_LIST_HEAD(&ast->root.u.root.clock);
853 BT_INIT_LIST_HEAD(&ast->root.u.root.callsite);
857 static void ctf_ast_free(struct ctf_ast *ast)
859 struct ctf_node *node, *tmp;
861 bt_list_for_each_entry_safe(node, tmp, &ast->allocated_nodes, gc)
865 int ctf_scanner_append_ast(struct ctf_scanner *scanner)
867 return yyparse(scanner);
870 struct ctf_scanner *ctf_scanner_alloc(FILE *input)
872 struct ctf_scanner *scanner;
875 yydebug = babeltrace_debug;
877 scanner = malloc(sizeof(*scanner));
880 memset(scanner, 0, sizeof(*scanner));
882 ret = yylex_init_extra(scanner, &scanner->scanner);
884 fprintf(stderr, "yylex_init error\n");
885 goto cleanup_scanner;
887 /* Start processing new stream */
888 yyrestart(input, scanner->scanner);
890 scanner->ast = ctf_ast_alloc();
893 init_scope(&scanner->root_scope, NULL);
894 scanner->cs = &scanner->root_scope;
895 BT_INIT_LIST_HEAD(&scanner->allocated_strings);
898 fprintf(stdout, "Scanner input is a%s.\n",
899 isatty(fileno(input)) ? "n interactive tty" :
900 " noninteractive file");
905 ret = yylex_destroy(scanner->scanner);
907 fprintf(stderr, "yylex_destroy error\n");
913 void ctf_scanner_free(struct ctf_scanner *scanner)
917 finalize_scope(&scanner->root_scope);
918 free_strings(&scanner->allocated_strings);
919 ctf_ast_free(scanner->ast);
920 ret = yylex_destroy(scanner->scanner);
922 fprintf(stderr, "yylex_destroy error\n");
930 %parse-param {struct ctf_scanner *scanner}
931 %lex-param {struct ctf_scanner *scanner}
933 * Expect two shift-reduce conflicts. Caused by enum name-opt : type {}
934 * vs struct { int :value; } (unnamed bit-field). The default is to
935 * shift, so whenever we encounter an enumeration, we are doing the
936 * proper thing (shift). It is illegal to declare an enumeration
937 * "bit-field", so it is OK if this situation ends up in a parsing
942 %token CHARACTER_CONSTANT_START SQUOTE STRING_LITERAL_START DQUOTE ESCSEQ CHAR_STRING_TOKEN LSBRAC RSBRAC LPAREN RPAREN LBRAC RBRAC RARROW STAR PLUS MINUS LT GT TYPEASSIGN COLON SEMICOLON DOTDOTDOT DOT EQUAL COMMA CONST CHAR DOUBLE ENUM ENV EVENT FLOATING_POINT FLOAT INTEGER INT LONG SHORT SIGNED STREAM STRING STRUCT TRACE CALLSITE CLOCK TYPEALIAS TYPEDEF UNSIGNED VARIANT VOID _BOOL _COMPLEX _IMAGINARY DECIMAL_CONSTANT OCTAL_CONSTANT HEXADECIMAL_CONSTANT TOK_ALIGN
943 %token <gs> IDENTIFIER ID_TYPE
949 struct gc_string *gs;
954 %type <gs> s_char s_char_sequence c_char c_char_sequence
956 %type <n> postfix_expression unary_expression unary_expression_or_range
958 %type <n> declaration
959 %type <n> event_declaration
960 %type <n> stream_declaration
961 %type <n> env_declaration
962 %type <n> trace_declaration
963 %type <n> clock_declaration
964 %type <n> callsite_declaration
965 %type <n> integer_declaration_specifiers
966 %type <n> declaration_specifiers
967 %type <n> alias_declaration_specifiers
969 %type <n> type_declarator_list
970 %type <n> integer_type_specifier
971 %type <n> type_specifier
972 %type <n> struct_type_specifier
973 %type <n> variant_type_specifier
974 %type <n> enum_type_specifier
975 %type <n> struct_or_variant_declaration_list
976 %type <n> struct_or_variant_declaration
977 %type <n> struct_or_variant_declarator_list
978 %type <n> struct_or_variant_declarator
979 %type <n> enumerator_list
981 %type <n> abstract_declarator_list
982 %type <n> abstract_declarator
983 %type <n> direct_abstract_declarator
984 %type <n> alias_abstract_declarator_list
985 %type <n> alias_abstract_declarator
986 %type <n> direct_alias_abstract_declarator
988 %type <n> direct_declarator
989 %type <n> type_declarator
990 %type <n> direct_type_declarator
992 %type <n> ctf_assignment_expression_list
993 %type <n> ctf_assignment_expression
1000 if (set_parent_node($1, &ctf_scanner_get_ast(scanner)->root))
1001 reparent_error(scanner, "error reparenting to root");
1005 if (set_parent_node($2, &ctf_scanner_get_ast(scanner)->root))
1006 reparent_error(scanner, "error reparenting to root");
1072 | c_char_sequence c_char
1073 { $$ = gc_string_append(scanner, $1, $2); }
1081 reparent_error(scanner, "escape sequences not supported yet");
1085 /* 1.6 String literals */
1090 | s_char_sequence s_char
1091 { $$ = gc_string_append(scanner, $1, $2); }
1099 reparent_error(scanner, "escape sequences not supported yet");
1103 /* 2: Phrase structure grammar */
1108 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1109 $$->u.unary_expression.type = UNARY_STRING;
1110 $$->u.unary_expression.u.string = yylval.gs->s;
1114 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1115 $$->u.unary_expression.type = UNARY_STRING;
1116 $$->u.unary_expression.u.string = yylval.gs->s;
1120 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1121 $$->u.unary_expression.type = UNARY_STRING;
1122 $$->u.unary_expression.u.string = yylval.gs->s;
1126 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1127 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1128 sscanf(yylval.gs->s, "%" PRIu64,
1129 &$$->u.unary_expression.u.unsigned_constant);
1133 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1134 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1135 sscanf(yylval.gs->s, "0%" PRIo64,
1136 &$$->u.unary_expression.u.unsigned_constant);
1138 | HEXADECIMAL_CONSTANT
1140 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1141 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1142 sscanf(yylval.gs->s, "0x%" PRIx64,
1143 &$$->u.unary_expression.u.unsigned_constant);
1145 | STRING_LITERAL_START DQUOTE
1147 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1148 $$->u.unary_expression.type = UNARY_STRING;
1149 $$->u.unary_expression.u.string = "";
1151 | STRING_LITERAL_START s_char_sequence DQUOTE
1153 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1154 $$->u.unary_expression.type = UNARY_STRING;
1155 $$->u.unary_expression.u.string = $2->s;
1157 | CHARACTER_CONSTANT_START c_char_sequence SQUOTE
1159 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1160 $$->u.unary_expression.type = UNARY_STRING;
1161 $$->u.unary_expression.u.string = $2->s;
1163 | LPAREN unary_expression RPAREN
1165 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1166 $$->u.unary_expression.type = UNARY_NESTED;
1167 $$->u.unary_expression.u.nested_exp = $2;
1169 | postfix_expression LSBRAC unary_expression RSBRAC
1171 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1172 $$->u.unary_expression.type = UNARY_SBRAC;
1173 $$->u.unary_expression.u.sbrac_exp = $3;
1174 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1175 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1177 | postfix_expression DOT IDENTIFIER
1179 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1180 $$->u.unary_expression.type = UNARY_STRING;
1181 $$->u.unary_expression.u.string = yylval.gs->s;
1182 $$->u.unary_expression.link = UNARY_DOTLINK;
1183 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1184 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1186 | postfix_expression DOT ID_TYPE
1188 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1189 $$->u.unary_expression.type = UNARY_STRING;
1190 $$->u.unary_expression.u.string = yylval.gs->s;
1191 $$->u.unary_expression.link = UNARY_DOTLINK;
1192 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1193 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1195 | postfix_expression RARROW IDENTIFIER
1197 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1198 $$->u.unary_expression.type = UNARY_STRING;
1199 $$->u.unary_expression.u.string = yylval.gs->s;
1200 $$->u.unary_expression.link = UNARY_ARROWLINK;
1201 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1202 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1204 | postfix_expression RARROW ID_TYPE
1206 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1207 $$->u.unary_expression.type = UNARY_STRING;
1208 $$->u.unary_expression.u.string = yylval.gs->s;
1209 $$->u.unary_expression.link = UNARY_ARROWLINK;
1210 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1211 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1218 | PLUS postfix_expression
1220 | MINUS postfix_expression
1223 if ($$->u.unary_expression.type != UNARY_SIGNED_CONSTANT
1224 && $$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT)
1225 reparent_error(scanner, "expecting numeric constant");
1227 if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1228 $$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
1229 $$->u.unary_expression.u.signed_constant =
1230 -($$->u.unary_expression.u.unsigned_constant);
1232 $$->u.unary_expression.u.signed_constant =
1233 -($$->u.unary_expression.u.signed_constant);
1238 unary_expression_or_range:
1239 unary_expression DOTDOTDOT unary_expression
1242 _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
1243 $3->u.unary_expression.link = UNARY_DOTDOTDOT;
1249 /* 2.2: Declarations */
1252 declaration_specifiers SEMICOLON
1256 | stream_declaration
1264 | callsite_declaration
1266 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
1268 struct ctf_node *list;
1270 $$ = make_node(scanner, NODE_TYPEDEF);
1271 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1272 $$->u._typedef.type_specifier_list = list;
1273 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1274 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1275 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
1277 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
1279 struct ctf_node *list;
1281 $$ = make_node(scanner, NODE_TYPEDEF);
1282 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1283 $$->u._typedef.type_specifier_list = list;
1284 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1285 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
1287 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
1289 struct ctf_node *list;
1291 $$ = make_node(scanner, NODE_TYPEDEF);
1292 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1293 $$->u._typedef.type_specifier_list = list;
1294 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1295 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
1297 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
1299 struct ctf_node *list;
1301 $$ = make_node(scanner, NODE_TYPEALIAS);
1302 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1303 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1305 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1306 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
1307 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1308 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
1310 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1311 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
1312 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1313 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
1318 event_declaration_begin event_declaration_end
1320 $$ = make_node(scanner, NODE_EVENT);
1322 | event_declaration_begin ctf_assignment_expression_list event_declaration_end
1324 $$ = make_node(scanner, NODE_EVENT);
1325 if (set_parent_node($2, $$))
1326 reparent_error(scanner, "event_declaration");
1330 event_declaration_begin:
1332 { push_scope(scanner); }
1335 event_declaration_end:
1337 { pop_scope(scanner); }
1342 stream_declaration_begin stream_declaration_end
1344 $$ = make_node(scanner, NODE_STREAM);
1346 | stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
1348 $$ = make_node(scanner, NODE_STREAM);
1349 if (set_parent_node($2, $$))
1350 reparent_error(scanner, "stream_declaration");
1354 stream_declaration_begin:
1356 { push_scope(scanner); }
1359 stream_declaration_end:
1361 { pop_scope(scanner); }
1365 env_declaration_begin env_declaration_end
1367 $$ = make_node(scanner, NODE_ENV);
1369 | env_declaration_begin ctf_assignment_expression_list env_declaration_end
1371 $$ = make_node(scanner, NODE_ENV);
1372 if (set_parent_node($2, $$))
1373 reparent_error(scanner, "env declaration");
1377 env_declaration_begin:
1379 { push_scope(scanner); }
1382 env_declaration_end:
1384 { pop_scope(scanner); }
1388 trace_declaration_begin trace_declaration_end
1390 $$ = make_node(scanner, NODE_TRACE);
1392 | trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
1394 $$ = make_node(scanner, NODE_TRACE);
1395 if (set_parent_node($2, $$))
1396 reparent_error(scanner, "trace_declaration");
1400 trace_declaration_begin:
1402 { push_scope(scanner); }
1405 trace_declaration_end:
1407 { pop_scope(scanner); }
1411 CLOCK clock_declaration_begin clock_declaration_end
1413 $$ = make_node(scanner, NODE_CLOCK);
1415 | CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
1417 $$ = make_node(scanner, NODE_CLOCK);
1418 if (set_parent_node($3, $$))
1419 reparent_error(scanner, "trace_declaration");
1423 clock_declaration_begin:
1425 { push_scope(scanner); }
1428 clock_declaration_end:
1430 { pop_scope(scanner); }
1433 callsite_declaration:
1434 CALLSITE callsite_declaration_begin callsite_declaration_end
1436 $$ = make_node(scanner, NODE_CALLSITE);
1438 | CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
1440 $$ = make_node(scanner, NODE_CALLSITE);
1441 if (set_parent_node($3, $$))
1442 reparent_error(scanner, "trace_declaration");
1446 callsite_declaration_begin:
1448 { push_scope(scanner); }
1451 callsite_declaration_end:
1453 { pop_scope(scanner); }
1456 integer_declaration_specifiers:
1459 struct ctf_node *node;
1461 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1462 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1463 node->u.type_specifier.type = TYPESPEC_CONST;
1464 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1466 | integer_type_specifier
1468 struct ctf_node *node;
1470 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1472 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1474 | integer_declaration_specifiers CONST
1476 struct ctf_node *node;
1479 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1480 node->u.type_specifier.type = TYPESPEC_CONST;
1481 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1483 | integer_declaration_specifiers integer_type_specifier
1486 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
1490 declaration_specifiers:
1493 struct ctf_node *node;
1495 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1496 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1497 node->u.type_specifier.type = TYPESPEC_CONST;
1498 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1502 struct ctf_node *node;
1504 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1506 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1508 | declaration_specifiers CONST
1510 struct ctf_node *node;
1513 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1514 node->u.type_specifier.type = TYPESPEC_CONST;
1515 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1517 | declaration_specifiers type_specifier
1520 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
1524 type_declarator_list:
1527 | type_declarator_list COMMA type_declarator
1530 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1534 integer_type_specifier:
1537 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1538 $$->u.type_specifier.type = TYPESPEC_CHAR;
1542 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1543 $$->u.type_specifier.type = TYPESPEC_SHORT;
1547 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1548 $$->u.type_specifier.type = TYPESPEC_INT;
1552 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1553 $$->u.type_specifier.type = TYPESPEC_LONG;
1557 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1558 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1562 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1563 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1567 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1568 $$->u.type_specifier.type = TYPESPEC_BOOL;
1572 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1573 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
1574 $$->u.type_specifier.id_type = yylval.gs->s;
1576 | INTEGER LBRAC RBRAC
1578 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1579 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1580 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1582 | INTEGER LBRAC ctf_assignment_expression_list RBRAC
1584 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1585 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1586 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1587 if (set_parent_node($3, $$->u.type_specifier.node))
1588 reparent_error(scanner, "integer reparent error");
1595 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1596 $$->u.type_specifier.type = TYPESPEC_VOID;
1600 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1601 $$->u.type_specifier.type = TYPESPEC_CHAR;
1605 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1606 $$->u.type_specifier.type = TYPESPEC_SHORT;
1610 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1611 $$->u.type_specifier.type = TYPESPEC_INT;
1615 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1616 $$->u.type_specifier.type = TYPESPEC_LONG;
1620 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1621 $$->u.type_specifier.type = TYPESPEC_FLOAT;
1625 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1626 $$->u.type_specifier.type = TYPESPEC_DOUBLE;
1630 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1631 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1635 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1636 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1640 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1641 $$->u.type_specifier.type = TYPESPEC_BOOL;
1645 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1646 $$->u.type_specifier.type = TYPESPEC_COMPLEX;
1650 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1651 $$->u.type_specifier.type = TYPESPEC_IMAGINARY;
1655 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1656 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
1657 $$->u.type_specifier.id_type = yylval.gs->s;
1659 | FLOATING_POINT LBRAC RBRAC
1661 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1662 $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
1663 $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1665 | FLOATING_POINT LBRAC ctf_assignment_expression_list RBRAC
1667 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1668 $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
1669 $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1670 if (set_parent_node($3, $$->u.type_specifier.node))
1671 reparent_error(scanner, "floating point reparent error");
1673 | INTEGER LBRAC RBRAC
1675 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1676 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1677 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1679 | INTEGER LBRAC ctf_assignment_expression_list RBRAC
1681 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1682 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1683 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1684 if (set_parent_node($3, $$->u.type_specifier.node))
1685 reparent_error(scanner, "integer reparent error");
1689 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1690 $$->u.type_specifier.type = TYPESPEC_STRING;
1691 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1693 | STRING LBRAC RBRAC
1695 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1696 $$->u.type_specifier.type = TYPESPEC_STRING;
1697 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1699 | STRING LBRAC ctf_assignment_expression_list RBRAC
1701 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1702 $$->u.type_specifier.type = TYPESPEC_STRING;
1703 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1704 if (set_parent_node($3, $$->u.type_specifier.node))
1705 reparent_error(scanner, "string reparent error");
1707 | ENUM enum_type_specifier
1709 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1710 $$->u.type_specifier.type = TYPESPEC_ENUM;
1711 $$->u.type_specifier.node = $2;
1713 | VARIANT variant_type_specifier
1715 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1716 $$->u.type_specifier.type = TYPESPEC_VARIANT;
1717 $$->u.type_specifier.node = $2;
1719 | STRUCT struct_type_specifier
1721 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1722 $$->u.type_specifier.type = TYPESPEC_STRUCT;
1723 $$->u.type_specifier.node = $2;
1727 struct_type_specifier:
1728 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1730 $$ = make_node(scanner, NODE_STRUCT);
1731 $$->u._struct.has_body = 1;
1732 if ($2 && set_parent_node($2, $$))
1733 reparent_error(scanner, "struct reparent error");
1735 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1737 $$ = make_node(scanner, NODE_STRUCT);
1738 $$->u._struct.has_body = 1;
1739 $$->u._struct.name = $1->s;
1740 if ($3 && set_parent_node($3, $$))
1741 reparent_error(scanner, "struct reparent error");
1743 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1745 $$ = make_node(scanner, NODE_STRUCT);
1746 $$->u._struct.has_body = 1;
1747 $$->u._struct.name = $1->s;
1748 if ($3 && set_parent_node($3, $$))
1749 reparent_error(scanner, "struct reparent error");
1753 $$ = make_node(scanner, NODE_STRUCT);
1754 $$->u._struct.has_body = 0;
1755 $$->u._struct.name = $1->s;
1759 $$ = make_node(scanner, NODE_STRUCT);
1760 $$->u._struct.has_body = 0;
1761 $$->u._struct.name = $1->s;
1763 | struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1765 $$ = make_node(scanner, NODE_STRUCT);
1766 $$->u._struct.has_body = 1;
1767 bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
1768 if ($2 && set_parent_node($2, $$))
1769 reparent_error(scanner, "struct reparent error");
1771 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1773 $$ = make_node(scanner, NODE_STRUCT);
1774 $$->u._struct.has_body = 1;
1775 $$->u._struct.name = $1->s;
1776 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1777 if ($3 && set_parent_node($3, $$))
1778 reparent_error(scanner, "struct reparent error");
1780 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1782 $$ = make_node(scanner, NODE_STRUCT);
1783 $$->u._struct.has_body = 1;
1784 $$->u._struct.name = $1->s;
1785 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1786 if ($3 && set_parent_node($3, $$))
1787 reparent_error(scanner, "struct reparent error");
1791 struct_declaration_begin:
1793 { push_scope(scanner); }
1796 struct_declaration_end:
1798 { pop_scope(scanner); }
1801 variant_type_specifier:
1802 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1804 $$ = make_node(scanner, NODE_VARIANT);
1805 $$->u.variant.has_body = 1;
1806 if ($2 && set_parent_node($2, $$))
1807 reparent_error(scanner, "variant reparent error");
1809 | LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1811 $$ = make_node(scanner, NODE_VARIANT);
1812 $$->u.variant.has_body = 1;
1813 $$->u.variant.choice = $2->s;
1814 if ($5 && set_parent_node($5, $$))
1815 reparent_error(scanner, "variant reparent error");
1817 | LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1819 $$ = make_node(scanner, NODE_VARIANT);
1820 $$->u.variant.has_body = 1;
1821 $$->u.variant.choice = $2->s;
1822 if ($5 && set_parent_node($5, $$))
1823 reparent_error(scanner, "variant reparent error");
1825 | IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1827 $$ = make_node(scanner, NODE_VARIANT);
1828 $$->u.variant.has_body = 1;
1829 $$->u.variant.name = $1->s;
1830 if ($3 && set_parent_node($3, $$))
1831 reparent_error(scanner, "variant reparent error");
1833 | IDENTIFIER LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1835 $$ = make_node(scanner, NODE_VARIANT);
1836 $$->u.variant.has_body = 1;
1837 $$->u.variant.name = $1->s;
1838 $$->u.variant.choice = $3->s;
1839 if ($6 && set_parent_node($6, $$))
1840 reparent_error(scanner, "variant reparent error");
1842 | IDENTIFIER LT IDENTIFIER GT
1844 $$ = make_node(scanner, NODE_VARIANT);
1845 $$->u.variant.has_body = 0;
1846 $$->u.variant.name = $1->s;
1847 $$->u.variant.choice = $3->s;
1849 | IDENTIFIER LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1851 $$ = make_node(scanner, NODE_VARIANT);
1852 $$->u.variant.has_body = 1;
1853 $$->u.variant.name = $1->s;
1854 $$->u.variant.choice = $3->s;
1855 if ($6 && set_parent_node($6, $$))
1856 reparent_error(scanner, "variant reparent error");
1858 | IDENTIFIER LT ID_TYPE GT
1860 $$ = make_node(scanner, NODE_VARIANT);
1861 $$->u.variant.has_body = 0;
1862 $$->u.variant.name = $1->s;
1863 $$->u.variant.choice = $3->s;
1865 | ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1867 $$ = make_node(scanner, NODE_VARIANT);
1868 $$->u.variant.has_body = 1;
1869 $$->u.variant.name = $1->s;
1870 if ($3 && set_parent_node($3, $$))
1871 reparent_error(scanner, "variant reparent error");
1873 | ID_TYPE LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1875 $$ = make_node(scanner, NODE_VARIANT);
1876 $$->u.variant.has_body = 1;
1877 $$->u.variant.name = $1->s;
1878 $$->u.variant.choice = $3->s;
1879 if ($6 && set_parent_node($6, $$))
1880 reparent_error(scanner, "variant reparent error");
1882 | ID_TYPE LT IDENTIFIER GT
1884 $$ = make_node(scanner, NODE_VARIANT);
1885 $$->u.variant.has_body = 0;
1886 $$->u.variant.name = $1->s;
1887 $$->u.variant.choice = $3->s;
1889 | ID_TYPE LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1891 $$ = make_node(scanner, NODE_VARIANT);
1892 $$->u.variant.has_body = 1;
1893 $$->u.variant.name = $1->s;
1894 $$->u.variant.choice = $3->s;
1895 if ($6 && set_parent_node($6, $$))
1896 reparent_error(scanner, "variant reparent error");
1898 | ID_TYPE LT ID_TYPE GT
1900 $$ = make_node(scanner, NODE_VARIANT);
1901 $$->u.variant.has_body = 0;
1902 $$->u.variant.name = $1->s;
1903 $$->u.variant.choice = $3->s;
1907 variant_declaration_begin:
1909 { push_scope(scanner); }
1912 variant_declaration_end:
1914 { pop_scope(scanner); }
1917 enum_type_specifier:
1918 LBRAC enumerator_list RBRAC
1920 $$ = make_node(scanner, NODE_ENUM);
1921 $$->u._enum.has_body = 1;
1922 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
1924 | COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
1926 $$ = make_node(scanner, NODE_ENUM);
1927 $$->u._enum.has_body = 1;
1928 ($$)->u._enum.container_type = $2;
1929 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
1931 | IDENTIFIER LBRAC enumerator_list RBRAC
1933 $$ = make_node(scanner, NODE_ENUM);
1934 $$->u._enum.has_body = 1;
1935 $$->u._enum.enum_id = $1->s;
1936 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1938 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
1940 $$ = make_node(scanner, NODE_ENUM);
1941 $$->u._enum.has_body = 1;
1942 $$->u._enum.enum_id = $1->s;
1943 ($$)->u._enum.container_type = $3;
1944 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
1946 | ID_TYPE LBRAC enumerator_list RBRAC
1948 $$ = make_node(scanner, NODE_ENUM);
1949 $$->u._enum.has_body = 1;
1950 $$->u._enum.enum_id = $1->s;
1951 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1953 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
1955 $$ = make_node(scanner, NODE_ENUM);
1956 $$->u._enum.has_body = 1;
1957 $$->u._enum.enum_id = $1->s;
1958 ($$)->u._enum.container_type = $3;
1959 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
1961 | LBRAC enumerator_list COMMA RBRAC
1963 $$ = make_node(scanner, NODE_ENUM);
1964 $$->u._enum.has_body = 1;
1965 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
1967 | COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
1969 $$ = make_node(scanner, NODE_ENUM);
1970 $$->u._enum.has_body = 1;
1971 ($$)->u._enum.container_type = $2;
1972 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
1974 | IDENTIFIER LBRAC enumerator_list COMMA RBRAC
1976 $$ = make_node(scanner, NODE_ENUM);
1977 $$->u._enum.has_body = 1;
1978 $$->u._enum.enum_id = $1->s;
1979 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1981 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
1983 $$ = make_node(scanner, NODE_ENUM);
1984 $$->u._enum.has_body = 1;
1985 $$->u._enum.enum_id = $1->s;
1986 ($$)->u._enum.container_type = $3;
1987 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
1991 $$ = make_node(scanner, NODE_ENUM);
1992 $$->u._enum.has_body = 0;
1993 $$->u._enum.enum_id = $1->s;
1995 | ID_TYPE LBRAC enumerator_list COMMA RBRAC
1997 $$ = make_node(scanner, NODE_ENUM);
1998 $$->u._enum.has_body = 1;
1999 $$->u._enum.enum_id = $1->s;
2000 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2002 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
2004 $$ = make_node(scanner, NODE_ENUM);
2005 $$->u._enum.has_body = 1;
2006 $$->u._enum.enum_id = $1->s;
2007 ($$)->u._enum.container_type = $3;
2008 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2012 $$ = make_node(scanner, NODE_ENUM);
2013 $$->u._enum.has_body = 0;
2014 $$->u._enum.enum_id = $1->s;
2018 struct_or_variant_declaration_list:
2021 | struct_or_variant_declaration_list struct_or_variant_declaration
2025 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2028 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
2033 struct_or_variant_declaration:
2034 declaration_specifiers struct_or_variant_declarator_list SEMICOLON
2036 struct ctf_node *list;
2038 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2039 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2040 $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
2041 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2042 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
2044 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
2046 struct ctf_node *list;
2048 $$ = make_node(scanner, NODE_TYPEDEF);
2049 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2050 $$->u._typedef.type_specifier_list = list;
2051 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2052 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2053 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
2055 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
2057 struct ctf_node *list;
2059 $$ = make_node(scanner, NODE_TYPEDEF);
2060 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2061 $$->u._typedef.type_specifier_list = list;
2062 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2063 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2065 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
2067 struct ctf_node *list;
2069 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2070 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2071 $$ = make_node(scanner, NODE_TYPEDEF);
2072 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2073 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2075 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
2077 struct ctf_node *list;
2079 $$ = make_node(scanner, NODE_TYPEALIAS);
2080 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2081 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2083 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2084 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
2085 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2086 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
2088 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2089 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
2090 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2091 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
2095 alias_declaration_specifiers:
2098 struct ctf_node *node;
2100 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2101 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2102 node->u.type_specifier.type = TYPESPEC_CONST;
2103 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2107 struct ctf_node *node;
2109 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2111 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2115 struct ctf_node *node;
2117 add_type(scanner, $1);
2118 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2119 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2120 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
2121 node->u.type_specifier.id_type = yylval.gs->s;
2122 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2124 | alias_declaration_specifiers CONST
2126 struct ctf_node *node;
2129 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2130 node->u.type_specifier.type = TYPESPEC_CONST;
2131 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2133 | alias_declaration_specifiers type_specifier
2136 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
2138 | alias_declaration_specifiers IDENTIFIER
2140 struct ctf_node *node;
2142 add_type(scanner, $2);
2144 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2145 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
2146 node->u.type_specifier.id_type = yylval.gs->s;
2147 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2151 struct_or_variant_declarator_list:
2152 struct_or_variant_declarator
2154 | struct_or_variant_declarator_list COMMA struct_or_variant_declarator
2157 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2161 struct_or_variant_declarator:
2164 | COLON unary_expression
2166 | declarator COLON unary_expression
2169 if (set_parent_node($3, $1))
2170 reparent_error(scanner, "struct_or_variant_declarator");
2177 | enumerator_list COMMA enumerator
2180 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2187 $$ = make_node(scanner, NODE_ENUMERATOR);
2188 $$->u.enumerator.id = $1->s;
2192 $$ = make_node(scanner, NODE_ENUMERATOR);
2193 $$->u.enumerator.id = $1->s;
2197 $$ = make_node(scanner, NODE_ENUMERATOR);
2198 $$->u.enumerator.id = $1->s;
2200 | STRING_LITERAL_START DQUOTE
2202 $$ = make_node(scanner, NODE_ENUMERATOR);
2203 $$->u.enumerator.id = "";
2205 | STRING_LITERAL_START s_char_sequence DQUOTE
2207 $$ = make_node(scanner, NODE_ENUMERATOR);
2208 $$->u.enumerator.id = $2->s;
2210 | IDENTIFIER EQUAL unary_expression_or_range
2212 $$ = make_node(scanner, NODE_ENUMERATOR);
2213 $$->u.enumerator.id = $1->s;
2214 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2216 | ID_TYPE EQUAL unary_expression_or_range
2218 $$ = make_node(scanner, NODE_ENUMERATOR);
2219 $$->u.enumerator.id = $1->s;
2220 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2222 | keywords EQUAL unary_expression_or_range
2224 $$ = make_node(scanner, NODE_ENUMERATOR);
2225 $$->u.enumerator.id = $1->s;
2226 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2228 | STRING_LITERAL_START DQUOTE EQUAL unary_expression_or_range
2230 $$ = make_node(scanner, NODE_ENUMERATOR);
2231 $$->u.enumerator.id = "";
2232 bt_list_splice(&($4)->tmp_head, &($$)->u.enumerator.values);
2234 | STRING_LITERAL_START s_char_sequence DQUOTE EQUAL unary_expression_or_range
2236 $$ = make_node(scanner, NODE_ENUMERATOR);
2237 $$->u.enumerator.id = $2->s;
2238 bt_list_splice(&($5)->tmp_head, &($$)->u.enumerator.values);
2242 abstract_declarator_list:
2245 | abstract_declarator_list COMMA abstract_declarator
2248 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2252 abstract_declarator:
2253 direct_abstract_declarator
2255 | pointer direct_abstract_declarator
2258 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2262 direct_abstract_declarator:
2265 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2266 $$->u.type_declarator.type = TYPEDEC_ID;
2271 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2272 $$->u.type_declarator.type = TYPEDEC_ID;
2273 $$->u.type_declarator.u.id = $1->s;
2275 | LPAREN abstract_declarator RPAREN
2277 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2278 $$->u.type_declarator.type = TYPEDEC_NESTED;
2279 $$->u.type_declarator.u.nested.type_declarator = $2;
2281 | direct_abstract_declarator LSBRAC unary_expression RSBRAC
2283 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2284 $$->u.type_declarator.type = TYPEDEC_NESTED;
2285 $$->u.type_declarator.u.nested.type_declarator = $1;
2286 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2287 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2289 | direct_abstract_declarator LSBRAC RSBRAC
2291 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2292 $$->u.type_declarator.type = TYPEDEC_NESTED;
2293 $$->u.type_declarator.u.nested.type_declarator = $1;
2294 $$->u.type_declarator.u.nested.abstract_array = 1;
2298 alias_abstract_declarator_list:
2299 alias_abstract_declarator
2301 | alias_abstract_declarator_list COMMA alias_abstract_declarator
2304 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2308 alias_abstract_declarator:
2309 direct_alias_abstract_declarator
2311 | pointer direct_alias_abstract_declarator
2314 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2318 direct_alias_abstract_declarator:
2321 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2322 $$->u.type_declarator.type = TYPEDEC_ID;
2325 | LPAREN alias_abstract_declarator RPAREN
2327 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2328 $$->u.type_declarator.type = TYPEDEC_NESTED;
2329 $$->u.type_declarator.u.nested.type_declarator = $2;
2331 | direct_alias_abstract_declarator LSBRAC unary_expression RSBRAC
2333 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2334 $$->u.type_declarator.type = TYPEDEC_NESTED;
2335 $$->u.type_declarator.u.nested.type_declarator = $1;
2336 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2337 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2339 | direct_alias_abstract_declarator LSBRAC RSBRAC
2341 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2342 $$->u.type_declarator.type = TYPEDEC_NESTED;
2343 $$->u.type_declarator.u.nested.type_declarator = $1;
2344 $$->u.type_declarator.u.nested.abstract_array = 1;
2351 | pointer direct_declarator
2354 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2361 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2362 $$->u.type_declarator.type = TYPEDEC_ID;
2363 $$->u.type_declarator.u.id = $1->s;
2365 | LPAREN declarator RPAREN
2367 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2368 $$->u.type_declarator.type = TYPEDEC_NESTED;
2369 $$->u.type_declarator.u.nested.type_declarator = $2;
2371 | direct_declarator LSBRAC unary_expression RSBRAC
2373 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2374 $$->u.type_declarator.type = TYPEDEC_NESTED;
2375 $$->u.type_declarator.u.nested.type_declarator = $1;
2376 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2377 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2382 direct_type_declarator
2384 | pointer direct_type_declarator
2387 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2391 direct_type_declarator:
2394 add_type(scanner, $1);
2395 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2396 $$->u.type_declarator.type = TYPEDEC_ID;
2397 $$->u.type_declarator.u.id = $1->s;
2399 | LPAREN type_declarator RPAREN
2401 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2402 $$->u.type_declarator.type = TYPEDEC_NESTED;
2403 $$->u.type_declarator.u.nested.type_declarator = $2;
2405 | direct_type_declarator LSBRAC unary_expression RSBRAC
2407 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2408 $$->u.type_declarator.type = TYPEDEC_NESTED;
2409 $$->u.type_declarator.u.nested.type_declarator = $1;
2410 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2411 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2418 $$ = make_node(scanner, NODE_POINTER);
2422 $$ = make_node(scanner, NODE_POINTER);
2423 bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
2425 | STAR type_qualifier_list pointer
2427 $$ = make_node(scanner, NODE_POINTER);
2428 $$->u.pointer.const_qualifier = 1;
2429 bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
2433 type_qualifier_list:
2434 /* pointer assumes only const type qualifier */
2436 | type_qualifier_list CONST
2439 /* 2.3: CTF-specific declarations */
2441 ctf_assignment_expression_list:
2442 ctf_assignment_expression SEMICOLON
2444 | ctf_assignment_expression_list ctf_assignment_expression SEMICOLON
2447 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2451 ctf_assignment_expression:
2452 unary_expression EQUAL unary_expression
2455 * Because we have left and right, cannot use
2458 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2459 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2460 if ($1->u.unary_expression.type != UNARY_STRING)
2461 reparent_error(scanner, "ctf_assignment_expression left expects string");
2462 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
2464 | unary_expression TYPEASSIGN declaration_specifiers /* Only allow struct */
2467 * Because we have left and right, cannot use
2470 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2471 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2472 if ($1->u.unary_expression.type != UNARY_STRING)
2473 reparent_error(scanner, "ctf_assignment_expression left expects string");
2474 bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
2476 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list
2478 struct ctf_node *list;
2480 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2481 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2482 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2483 $$ = make_node(scanner, NODE_TYPEDEF);
2484 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2485 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
2487 | TYPEDEF declaration_specifiers type_declarator_list
2489 struct ctf_node *list;
2491 $$ = make_node(scanner, NODE_TYPEDEF);
2492 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2493 $$->u._typedef.type_specifier_list = list;
2494 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2495 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2497 | declaration_specifiers TYPEDEF type_declarator_list
2499 struct ctf_node *list;
2501 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2502 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2503 $$ = make_node(scanner, NODE_TYPEDEF);
2504 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2505 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2507 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
2509 struct ctf_node *list;
2511 $$ = make_node(scanner, NODE_TYPEALIAS);
2512 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2513 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2515 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2516 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
2517 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2518 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
2520 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2521 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
2522 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2523 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);