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)
866 int ctf_scanner_append_ast(struct ctf_scanner *scanner)
868 return yyparse(scanner);
871 struct ctf_scanner *ctf_scanner_alloc(FILE *input)
873 struct ctf_scanner *scanner;
876 yydebug = babeltrace_debug;
878 scanner = malloc(sizeof(*scanner));
881 memset(scanner, 0, sizeof(*scanner));
883 ret = yylex_init_extra(scanner, &scanner->scanner);
885 fprintf(stderr, "yylex_init error\n");
886 goto cleanup_scanner;
888 /* Start processing new stream */
889 yyrestart(input, scanner->scanner);
891 scanner->ast = ctf_ast_alloc();
894 init_scope(&scanner->root_scope, NULL);
895 scanner->cs = &scanner->root_scope;
896 BT_INIT_LIST_HEAD(&scanner->allocated_strings);
899 fprintf(stdout, "Scanner input is a%s.\n",
900 isatty(fileno(input)) ? "n interactive tty" :
901 " noninteractive file");
906 ret = yylex_destroy(scanner->scanner);
908 fprintf(stderr, "yylex_destroy error\n");
914 void ctf_scanner_free(struct ctf_scanner *scanner)
918 finalize_scope(&scanner->root_scope);
919 free_strings(&scanner->allocated_strings);
920 ctf_ast_free(scanner->ast);
921 ret = yylex_destroy(scanner->scanner);
923 fprintf(stderr, "yylex_destroy error\n");
931 %parse-param {struct ctf_scanner *scanner}
932 %lex-param {struct ctf_scanner *scanner}
934 * Expect two shift-reduce conflicts. Caused by enum name-opt : type {}
935 * vs struct { int :value; } (unnamed bit-field). The default is to
936 * shift, so whenever we encounter an enumeration, we are doing the
937 * proper thing (shift). It is illegal to declare an enumeration
938 * "bit-field", so it is OK if this situation ends up in a parsing
943 %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
944 %token <gs> IDENTIFIER ID_TYPE
950 struct gc_string *gs;
955 %type <gs> s_char s_char_sequence c_char c_char_sequence
957 %type <n> postfix_expression unary_expression unary_expression_or_range
959 %type <n> declaration
960 %type <n> event_declaration
961 %type <n> stream_declaration
962 %type <n> env_declaration
963 %type <n> trace_declaration
964 %type <n> clock_declaration
965 %type <n> callsite_declaration
966 %type <n> integer_declaration_specifiers
967 %type <n> declaration_specifiers
968 %type <n> alias_declaration_specifiers
970 %type <n> type_declarator_list
971 %type <n> integer_type_specifier
972 %type <n> type_specifier
973 %type <n> struct_type_specifier
974 %type <n> variant_type_specifier
975 %type <n> enum_type_specifier
976 %type <n> struct_or_variant_declaration_list
977 %type <n> struct_or_variant_declaration
978 %type <n> struct_or_variant_declarator_list
979 %type <n> struct_or_variant_declarator
980 %type <n> enumerator_list
982 %type <n> abstract_declarator_list
983 %type <n> abstract_declarator
984 %type <n> direct_abstract_declarator
985 %type <n> alias_abstract_declarator_list
986 %type <n> alias_abstract_declarator
987 %type <n> direct_alias_abstract_declarator
989 %type <n> direct_declarator
990 %type <n> type_declarator
991 %type <n> direct_type_declarator
993 %type <n> ctf_assignment_expression_list
994 %type <n> ctf_assignment_expression
1001 if (set_parent_node($1, &ctf_scanner_get_ast(scanner)->root))
1002 reparent_error(scanner, "error reparenting to root");
1006 if (set_parent_node($2, &ctf_scanner_get_ast(scanner)->root))
1007 reparent_error(scanner, "error reparenting to root");
1073 | c_char_sequence c_char
1074 { $$ = gc_string_append(scanner, $1, $2); }
1082 reparent_error(scanner, "escape sequences not supported yet");
1086 /* 1.6 String literals */
1091 | s_char_sequence s_char
1092 { $$ = gc_string_append(scanner, $1, $2); }
1100 reparent_error(scanner, "escape sequences not supported yet");
1104 /* 2: Phrase structure grammar */
1109 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1110 $$->u.unary_expression.type = UNARY_STRING;
1111 $$->u.unary_expression.u.string = yylval.gs->s;
1115 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1116 $$->u.unary_expression.type = UNARY_STRING;
1117 $$->u.unary_expression.u.string = yylval.gs->s;
1121 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1122 $$->u.unary_expression.type = UNARY_STRING;
1123 $$->u.unary_expression.u.string = yylval.gs->s;
1127 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1128 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1129 sscanf(yylval.gs->s, "%" PRIu64,
1130 &$$->u.unary_expression.u.unsigned_constant);
1134 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1135 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1136 sscanf(yylval.gs->s, "0%" PRIo64,
1137 &$$->u.unary_expression.u.unsigned_constant);
1139 | HEXADECIMAL_CONSTANT
1141 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1142 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1143 sscanf(yylval.gs->s, "0x%" PRIx64,
1144 &$$->u.unary_expression.u.unsigned_constant);
1146 | STRING_LITERAL_START DQUOTE
1148 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1149 $$->u.unary_expression.type = UNARY_STRING;
1150 $$->u.unary_expression.u.string = "";
1152 | STRING_LITERAL_START s_char_sequence DQUOTE
1154 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1155 $$->u.unary_expression.type = UNARY_STRING;
1156 $$->u.unary_expression.u.string = $2->s;
1158 | CHARACTER_CONSTANT_START c_char_sequence SQUOTE
1160 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1161 $$->u.unary_expression.type = UNARY_STRING;
1162 $$->u.unary_expression.u.string = $2->s;
1164 | LPAREN unary_expression RPAREN
1166 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1167 $$->u.unary_expression.type = UNARY_NESTED;
1168 $$->u.unary_expression.u.nested_exp = $2;
1170 | postfix_expression LSBRAC unary_expression RSBRAC
1172 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1173 $$->u.unary_expression.type = UNARY_SBRAC;
1174 $$->u.unary_expression.u.sbrac_exp = $3;
1175 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1176 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1178 | postfix_expression DOT IDENTIFIER
1180 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1181 $$->u.unary_expression.type = UNARY_STRING;
1182 $$->u.unary_expression.u.string = yylval.gs->s;
1183 $$->u.unary_expression.link = UNARY_DOTLINK;
1184 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1185 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1187 | postfix_expression DOT ID_TYPE
1189 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1190 $$->u.unary_expression.type = UNARY_STRING;
1191 $$->u.unary_expression.u.string = yylval.gs->s;
1192 $$->u.unary_expression.link = UNARY_DOTLINK;
1193 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1194 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1196 | postfix_expression RARROW IDENTIFIER
1198 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1199 $$->u.unary_expression.type = UNARY_STRING;
1200 $$->u.unary_expression.u.string = yylval.gs->s;
1201 $$->u.unary_expression.link = UNARY_ARROWLINK;
1202 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1203 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1205 | postfix_expression RARROW ID_TYPE
1207 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1208 $$->u.unary_expression.type = UNARY_STRING;
1209 $$->u.unary_expression.u.string = yylval.gs->s;
1210 $$->u.unary_expression.link = UNARY_ARROWLINK;
1211 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1212 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1219 | PLUS postfix_expression
1221 | MINUS postfix_expression
1224 if ($$->u.unary_expression.type != UNARY_SIGNED_CONSTANT
1225 && $$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT)
1226 reparent_error(scanner, "expecting numeric constant");
1228 if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1229 $$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
1230 $$->u.unary_expression.u.signed_constant =
1231 -($$->u.unary_expression.u.unsigned_constant);
1233 $$->u.unary_expression.u.signed_constant =
1234 -($$->u.unary_expression.u.signed_constant);
1239 unary_expression_or_range:
1240 unary_expression DOTDOTDOT unary_expression
1243 _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
1244 $3->u.unary_expression.link = UNARY_DOTDOTDOT;
1250 /* 2.2: Declarations */
1253 declaration_specifiers SEMICOLON
1257 | stream_declaration
1265 | callsite_declaration
1267 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
1269 struct ctf_node *list;
1271 $$ = make_node(scanner, NODE_TYPEDEF);
1272 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1273 $$->u._typedef.type_specifier_list = list;
1274 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1275 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1276 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
1278 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
1280 struct ctf_node *list;
1282 $$ = make_node(scanner, NODE_TYPEDEF);
1283 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1284 $$->u._typedef.type_specifier_list = list;
1285 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1286 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
1288 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
1290 struct ctf_node *list;
1292 $$ = make_node(scanner, NODE_TYPEDEF);
1293 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1294 $$->u._typedef.type_specifier_list = list;
1295 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1296 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
1298 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
1300 struct ctf_node *list;
1302 $$ = make_node(scanner, NODE_TYPEALIAS);
1303 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1304 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1306 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1307 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
1308 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1309 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
1311 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1312 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
1313 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1314 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
1319 event_declaration_begin event_declaration_end
1321 $$ = make_node(scanner, NODE_EVENT);
1323 | event_declaration_begin ctf_assignment_expression_list event_declaration_end
1325 $$ = make_node(scanner, NODE_EVENT);
1326 if (set_parent_node($2, $$))
1327 reparent_error(scanner, "event_declaration");
1331 event_declaration_begin:
1333 { push_scope(scanner); }
1336 event_declaration_end:
1338 { pop_scope(scanner); }
1343 stream_declaration_begin stream_declaration_end
1345 $$ = make_node(scanner, NODE_STREAM);
1347 | stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
1349 $$ = make_node(scanner, NODE_STREAM);
1350 if (set_parent_node($2, $$))
1351 reparent_error(scanner, "stream_declaration");
1355 stream_declaration_begin:
1357 { push_scope(scanner); }
1360 stream_declaration_end:
1362 { pop_scope(scanner); }
1366 env_declaration_begin env_declaration_end
1368 $$ = make_node(scanner, NODE_ENV);
1370 | env_declaration_begin ctf_assignment_expression_list env_declaration_end
1372 $$ = make_node(scanner, NODE_ENV);
1373 if (set_parent_node($2, $$))
1374 reparent_error(scanner, "env declaration");
1378 env_declaration_begin:
1380 { push_scope(scanner); }
1383 env_declaration_end:
1385 { pop_scope(scanner); }
1389 trace_declaration_begin trace_declaration_end
1391 $$ = make_node(scanner, NODE_TRACE);
1393 | trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
1395 $$ = make_node(scanner, NODE_TRACE);
1396 if (set_parent_node($2, $$))
1397 reparent_error(scanner, "trace_declaration");
1401 trace_declaration_begin:
1403 { push_scope(scanner); }
1406 trace_declaration_end:
1408 { pop_scope(scanner); }
1412 CLOCK clock_declaration_begin clock_declaration_end
1414 $$ = make_node(scanner, NODE_CLOCK);
1416 | CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
1418 $$ = make_node(scanner, NODE_CLOCK);
1419 if (set_parent_node($3, $$))
1420 reparent_error(scanner, "trace_declaration");
1424 clock_declaration_begin:
1426 { push_scope(scanner); }
1429 clock_declaration_end:
1431 { pop_scope(scanner); }
1434 callsite_declaration:
1435 CALLSITE callsite_declaration_begin callsite_declaration_end
1437 $$ = make_node(scanner, NODE_CALLSITE);
1439 | CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
1441 $$ = make_node(scanner, NODE_CALLSITE);
1442 if (set_parent_node($3, $$))
1443 reparent_error(scanner, "trace_declaration");
1447 callsite_declaration_begin:
1449 { push_scope(scanner); }
1452 callsite_declaration_end:
1454 { pop_scope(scanner); }
1457 integer_declaration_specifiers:
1460 struct ctf_node *node;
1462 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1463 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1464 node->u.type_specifier.type = TYPESPEC_CONST;
1465 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1467 | integer_type_specifier
1469 struct ctf_node *node;
1471 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1473 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1475 | integer_declaration_specifiers CONST
1477 struct ctf_node *node;
1480 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1481 node->u.type_specifier.type = TYPESPEC_CONST;
1482 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1484 | integer_declaration_specifiers integer_type_specifier
1487 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
1491 declaration_specifiers:
1494 struct ctf_node *node;
1496 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1497 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1498 node->u.type_specifier.type = TYPESPEC_CONST;
1499 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1503 struct ctf_node *node;
1505 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1507 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1509 | declaration_specifiers CONST
1511 struct ctf_node *node;
1514 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1515 node->u.type_specifier.type = TYPESPEC_CONST;
1516 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1518 | declaration_specifiers type_specifier
1521 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
1525 type_declarator_list:
1528 | type_declarator_list COMMA type_declarator
1531 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1535 integer_type_specifier:
1538 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1539 $$->u.type_specifier.type = TYPESPEC_CHAR;
1543 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1544 $$->u.type_specifier.type = TYPESPEC_SHORT;
1548 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1549 $$->u.type_specifier.type = TYPESPEC_INT;
1553 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1554 $$->u.type_specifier.type = TYPESPEC_LONG;
1558 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1559 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1563 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1564 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1568 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1569 $$->u.type_specifier.type = TYPESPEC_BOOL;
1573 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1574 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
1575 $$->u.type_specifier.id_type = yylval.gs->s;
1577 | INTEGER LBRAC RBRAC
1579 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1580 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1581 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1583 | INTEGER LBRAC ctf_assignment_expression_list RBRAC
1585 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1586 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1587 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1588 if (set_parent_node($3, $$->u.type_specifier.node))
1589 reparent_error(scanner, "integer reparent error");
1596 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1597 $$->u.type_specifier.type = TYPESPEC_VOID;
1601 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1602 $$->u.type_specifier.type = TYPESPEC_CHAR;
1606 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1607 $$->u.type_specifier.type = TYPESPEC_SHORT;
1611 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1612 $$->u.type_specifier.type = TYPESPEC_INT;
1616 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1617 $$->u.type_specifier.type = TYPESPEC_LONG;
1621 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1622 $$->u.type_specifier.type = TYPESPEC_FLOAT;
1626 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1627 $$->u.type_specifier.type = TYPESPEC_DOUBLE;
1631 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1632 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1636 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1637 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1641 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1642 $$->u.type_specifier.type = TYPESPEC_BOOL;
1646 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1647 $$->u.type_specifier.type = TYPESPEC_COMPLEX;
1651 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1652 $$->u.type_specifier.type = TYPESPEC_IMAGINARY;
1656 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1657 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
1658 $$->u.type_specifier.id_type = yylval.gs->s;
1660 | FLOATING_POINT LBRAC RBRAC
1662 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1663 $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
1664 $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1666 | FLOATING_POINT LBRAC ctf_assignment_expression_list RBRAC
1668 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1669 $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
1670 $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1671 if (set_parent_node($3, $$->u.type_specifier.node))
1672 reparent_error(scanner, "floating point reparent error");
1674 | INTEGER LBRAC RBRAC
1676 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1677 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1678 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1680 | INTEGER LBRAC ctf_assignment_expression_list RBRAC
1682 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1683 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1684 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1685 if (set_parent_node($3, $$->u.type_specifier.node))
1686 reparent_error(scanner, "integer reparent error");
1690 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1691 $$->u.type_specifier.type = TYPESPEC_STRING;
1692 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1694 | STRING LBRAC RBRAC
1696 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1697 $$->u.type_specifier.type = TYPESPEC_STRING;
1698 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1700 | STRING LBRAC ctf_assignment_expression_list RBRAC
1702 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1703 $$->u.type_specifier.type = TYPESPEC_STRING;
1704 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1705 if (set_parent_node($3, $$->u.type_specifier.node))
1706 reparent_error(scanner, "string reparent error");
1708 | ENUM enum_type_specifier
1710 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1711 $$->u.type_specifier.type = TYPESPEC_ENUM;
1712 $$->u.type_specifier.node = $2;
1714 | VARIANT variant_type_specifier
1716 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1717 $$->u.type_specifier.type = TYPESPEC_VARIANT;
1718 $$->u.type_specifier.node = $2;
1720 | STRUCT struct_type_specifier
1722 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1723 $$->u.type_specifier.type = TYPESPEC_STRUCT;
1724 $$->u.type_specifier.node = $2;
1728 struct_type_specifier:
1729 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1731 $$ = make_node(scanner, NODE_STRUCT);
1732 $$->u._struct.has_body = 1;
1733 if ($2 && set_parent_node($2, $$))
1734 reparent_error(scanner, "struct reparent error");
1736 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1738 $$ = make_node(scanner, NODE_STRUCT);
1739 $$->u._struct.has_body = 1;
1740 $$->u._struct.name = $1->s;
1741 if ($3 && set_parent_node($3, $$))
1742 reparent_error(scanner, "struct reparent error");
1744 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1746 $$ = make_node(scanner, NODE_STRUCT);
1747 $$->u._struct.has_body = 1;
1748 $$->u._struct.name = $1->s;
1749 if ($3 && set_parent_node($3, $$))
1750 reparent_error(scanner, "struct reparent error");
1754 $$ = make_node(scanner, NODE_STRUCT);
1755 $$->u._struct.has_body = 0;
1756 $$->u._struct.name = $1->s;
1760 $$ = make_node(scanner, NODE_STRUCT);
1761 $$->u._struct.has_body = 0;
1762 $$->u._struct.name = $1->s;
1764 | struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1766 $$ = make_node(scanner, NODE_STRUCT);
1767 $$->u._struct.has_body = 1;
1768 bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
1769 if ($2 && set_parent_node($2, $$))
1770 reparent_error(scanner, "struct reparent error");
1772 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1774 $$ = make_node(scanner, NODE_STRUCT);
1775 $$->u._struct.has_body = 1;
1776 $$->u._struct.name = $1->s;
1777 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1778 if ($3 && set_parent_node($3, $$))
1779 reparent_error(scanner, "struct reparent error");
1781 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1783 $$ = make_node(scanner, NODE_STRUCT);
1784 $$->u._struct.has_body = 1;
1785 $$->u._struct.name = $1->s;
1786 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1787 if ($3 && set_parent_node($3, $$))
1788 reparent_error(scanner, "struct reparent error");
1792 struct_declaration_begin:
1794 { push_scope(scanner); }
1797 struct_declaration_end:
1799 { pop_scope(scanner); }
1802 variant_type_specifier:
1803 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1805 $$ = make_node(scanner, NODE_VARIANT);
1806 $$->u.variant.has_body = 1;
1807 if ($2 && set_parent_node($2, $$))
1808 reparent_error(scanner, "variant reparent error");
1810 | LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1812 $$ = make_node(scanner, NODE_VARIANT);
1813 $$->u.variant.has_body = 1;
1814 $$->u.variant.choice = $2->s;
1815 if ($5 && set_parent_node($5, $$))
1816 reparent_error(scanner, "variant reparent error");
1818 | LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1820 $$ = make_node(scanner, NODE_VARIANT);
1821 $$->u.variant.has_body = 1;
1822 $$->u.variant.choice = $2->s;
1823 if ($5 && set_parent_node($5, $$))
1824 reparent_error(scanner, "variant reparent error");
1826 | IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1828 $$ = make_node(scanner, NODE_VARIANT);
1829 $$->u.variant.has_body = 1;
1830 $$->u.variant.name = $1->s;
1831 if ($3 && set_parent_node($3, $$))
1832 reparent_error(scanner, "variant reparent error");
1834 | IDENTIFIER LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1836 $$ = make_node(scanner, NODE_VARIANT);
1837 $$->u.variant.has_body = 1;
1838 $$->u.variant.name = $1->s;
1839 $$->u.variant.choice = $3->s;
1840 if ($6 && set_parent_node($6, $$))
1841 reparent_error(scanner, "variant reparent error");
1843 | IDENTIFIER LT IDENTIFIER GT
1845 $$ = make_node(scanner, NODE_VARIANT);
1846 $$->u.variant.has_body = 0;
1847 $$->u.variant.name = $1->s;
1848 $$->u.variant.choice = $3->s;
1850 | IDENTIFIER LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1852 $$ = make_node(scanner, NODE_VARIANT);
1853 $$->u.variant.has_body = 1;
1854 $$->u.variant.name = $1->s;
1855 $$->u.variant.choice = $3->s;
1856 if ($6 && set_parent_node($6, $$))
1857 reparent_error(scanner, "variant reparent error");
1859 | IDENTIFIER LT ID_TYPE GT
1861 $$ = make_node(scanner, NODE_VARIANT);
1862 $$->u.variant.has_body = 0;
1863 $$->u.variant.name = $1->s;
1864 $$->u.variant.choice = $3->s;
1866 | ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1868 $$ = make_node(scanner, NODE_VARIANT);
1869 $$->u.variant.has_body = 1;
1870 $$->u.variant.name = $1->s;
1871 if ($3 && set_parent_node($3, $$))
1872 reparent_error(scanner, "variant reparent error");
1874 | ID_TYPE LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1876 $$ = make_node(scanner, NODE_VARIANT);
1877 $$->u.variant.has_body = 1;
1878 $$->u.variant.name = $1->s;
1879 $$->u.variant.choice = $3->s;
1880 if ($6 && set_parent_node($6, $$))
1881 reparent_error(scanner, "variant reparent error");
1883 | ID_TYPE LT IDENTIFIER GT
1885 $$ = make_node(scanner, NODE_VARIANT);
1886 $$->u.variant.has_body = 0;
1887 $$->u.variant.name = $1->s;
1888 $$->u.variant.choice = $3->s;
1890 | ID_TYPE LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1892 $$ = make_node(scanner, NODE_VARIANT);
1893 $$->u.variant.has_body = 1;
1894 $$->u.variant.name = $1->s;
1895 $$->u.variant.choice = $3->s;
1896 if ($6 && set_parent_node($6, $$))
1897 reparent_error(scanner, "variant reparent error");
1899 | ID_TYPE LT ID_TYPE GT
1901 $$ = make_node(scanner, NODE_VARIANT);
1902 $$->u.variant.has_body = 0;
1903 $$->u.variant.name = $1->s;
1904 $$->u.variant.choice = $3->s;
1908 variant_declaration_begin:
1910 { push_scope(scanner); }
1913 variant_declaration_end:
1915 { pop_scope(scanner); }
1918 enum_type_specifier:
1919 LBRAC enumerator_list RBRAC
1921 $$ = make_node(scanner, NODE_ENUM);
1922 $$->u._enum.has_body = 1;
1923 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
1925 | COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
1927 $$ = make_node(scanner, NODE_ENUM);
1928 $$->u._enum.has_body = 1;
1929 ($$)->u._enum.container_type = $2;
1930 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
1932 | IDENTIFIER LBRAC enumerator_list RBRAC
1934 $$ = make_node(scanner, NODE_ENUM);
1935 $$->u._enum.has_body = 1;
1936 $$->u._enum.enum_id = $1->s;
1937 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1939 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
1941 $$ = make_node(scanner, NODE_ENUM);
1942 $$->u._enum.has_body = 1;
1943 $$->u._enum.enum_id = $1->s;
1944 ($$)->u._enum.container_type = $3;
1945 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
1947 | ID_TYPE LBRAC enumerator_list RBRAC
1949 $$ = make_node(scanner, NODE_ENUM);
1950 $$->u._enum.has_body = 1;
1951 $$->u._enum.enum_id = $1->s;
1952 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1954 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
1956 $$ = make_node(scanner, NODE_ENUM);
1957 $$->u._enum.has_body = 1;
1958 $$->u._enum.enum_id = $1->s;
1959 ($$)->u._enum.container_type = $3;
1960 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
1962 | LBRAC enumerator_list COMMA RBRAC
1964 $$ = make_node(scanner, NODE_ENUM);
1965 $$->u._enum.has_body = 1;
1966 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
1968 | COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
1970 $$ = make_node(scanner, NODE_ENUM);
1971 $$->u._enum.has_body = 1;
1972 ($$)->u._enum.container_type = $2;
1973 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
1975 | IDENTIFIER LBRAC enumerator_list COMMA RBRAC
1977 $$ = make_node(scanner, NODE_ENUM);
1978 $$->u._enum.has_body = 1;
1979 $$->u._enum.enum_id = $1->s;
1980 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1982 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
1984 $$ = make_node(scanner, NODE_ENUM);
1985 $$->u._enum.has_body = 1;
1986 $$->u._enum.enum_id = $1->s;
1987 ($$)->u._enum.container_type = $3;
1988 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
1992 $$ = make_node(scanner, NODE_ENUM);
1993 $$->u._enum.has_body = 0;
1994 $$->u._enum.enum_id = $1->s;
1996 | ID_TYPE LBRAC enumerator_list COMMA RBRAC
1998 $$ = make_node(scanner, NODE_ENUM);
1999 $$->u._enum.has_body = 1;
2000 $$->u._enum.enum_id = $1->s;
2001 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2003 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
2005 $$ = make_node(scanner, NODE_ENUM);
2006 $$->u._enum.has_body = 1;
2007 $$->u._enum.enum_id = $1->s;
2008 ($$)->u._enum.container_type = $3;
2009 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2013 $$ = make_node(scanner, NODE_ENUM);
2014 $$->u._enum.has_body = 0;
2015 $$->u._enum.enum_id = $1->s;
2019 struct_or_variant_declaration_list:
2022 | struct_or_variant_declaration_list struct_or_variant_declaration
2026 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2029 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
2034 struct_or_variant_declaration:
2035 declaration_specifiers struct_or_variant_declarator_list SEMICOLON
2037 struct ctf_node *list;
2039 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2040 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2041 $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
2042 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2043 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
2045 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
2047 struct ctf_node *list;
2049 $$ = make_node(scanner, NODE_TYPEDEF);
2050 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2051 $$->u._typedef.type_specifier_list = list;
2052 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2053 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2054 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
2056 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
2058 struct ctf_node *list;
2060 $$ = make_node(scanner, NODE_TYPEDEF);
2061 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2062 $$->u._typedef.type_specifier_list = list;
2063 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2064 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2066 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
2068 struct ctf_node *list;
2070 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2071 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2072 $$ = make_node(scanner, NODE_TYPEDEF);
2073 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2074 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2076 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
2078 struct ctf_node *list;
2080 $$ = make_node(scanner, NODE_TYPEALIAS);
2081 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2082 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2084 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2085 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
2086 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2087 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
2089 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2090 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
2091 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2092 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
2096 alias_declaration_specifiers:
2099 struct ctf_node *node;
2101 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2102 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2103 node->u.type_specifier.type = TYPESPEC_CONST;
2104 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2108 struct ctf_node *node;
2110 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2112 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2116 struct ctf_node *node;
2118 add_type(scanner, $1);
2119 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2120 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2121 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
2122 node->u.type_specifier.id_type = yylval.gs->s;
2123 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2125 | alias_declaration_specifiers CONST
2127 struct ctf_node *node;
2130 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2131 node->u.type_specifier.type = TYPESPEC_CONST;
2132 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2134 | alias_declaration_specifiers type_specifier
2137 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
2139 | alias_declaration_specifiers IDENTIFIER
2141 struct ctf_node *node;
2143 add_type(scanner, $2);
2145 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2146 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
2147 node->u.type_specifier.id_type = yylval.gs->s;
2148 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2152 struct_or_variant_declarator_list:
2153 struct_or_variant_declarator
2155 | struct_or_variant_declarator_list COMMA struct_or_variant_declarator
2158 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2162 struct_or_variant_declarator:
2165 | COLON unary_expression
2167 | declarator COLON unary_expression
2170 if (set_parent_node($3, $1))
2171 reparent_error(scanner, "struct_or_variant_declarator");
2178 | enumerator_list COMMA enumerator
2181 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2188 $$ = make_node(scanner, NODE_ENUMERATOR);
2189 $$->u.enumerator.id = $1->s;
2193 $$ = make_node(scanner, NODE_ENUMERATOR);
2194 $$->u.enumerator.id = $1->s;
2198 $$ = make_node(scanner, NODE_ENUMERATOR);
2199 $$->u.enumerator.id = $1->s;
2201 | STRING_LITERAL_START DQUOTE
2203 $$ = make_node(scanner, NODE_ENUMERATOR);
2204 $$->u.enumerator.id = "";
2206 | STRING_LITERAL_START s_char_sequence DQUOTE
2208 $$ = make_node(scanner, NODE_ENUMERATOR);
2209 $$->u.enumerator.id = $2->s;
2211 | IDENTIFIER EQUAL unary_expression_or_range
2213 $$ = make_node(scanner, NODE_ENUMERATOR);
2214 $$->u.enumerator.id = $1->s;
2215 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2217 | ID_TYPE EQUAL unary_expression_or_range
2219 $$ = make_node(scanner, NODE_ENUMERATOR);
2220 $$->u.enumerator.id = $1->s;
2221 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2223 | keywords EQUAL unary_expression_or_range
2225 $$ = make_node(scanner, NODE_ENUMERATOR);
2226 $$->u.enumerator.id = $1->s;
2227 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2229 | STRING_LITERAL_START DQUOTE EQUAL unary_expression_or_range
2231 $$ = make_node(scanner, NODE_ENUMERATOR);
2232 $$->u.enumerator.id = "";
2233 bt_list_splice(&($4)->tmp_head, &($$)->u.enumerator.values);
2235 | STRING_LITERAL_START s_char_sequence DQUOTE EQUAL unary_expression_or_range
2237 $$ = make_node(scanner, NODE_ENUMERATOR);
2238 $$->u.enumerator.id = $2->s;
2239 bt_list_splice(&($5)->tmp_head, &($$)->u.enumerator.values);
2243 abstract_declarator_list:
2246 | abstract_declarator_list COMMA abstract_declarator
2249 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2253 abstract_declarator:
2254 direct_abstract_declarator
2256 | pointer direct_abstract_declarator
2259 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2263 direct_abstract_declarator:
2266 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2267 $$->u.type_declarator.type = TYPEDEC_ID;
2272 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2273 $$->u.type_declarator.type = TYPEDEC_ID;
2274 $$->u.type_declarator.u.id = $1->s;
2276 | LPAREN abstract_declarator RPAREN
2278 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2279 $$->u.type_declarator.type = TYPEDEC_NESTED;
2280 $$->u.type_declarator.u.nested.type_declarator = $2;
2282 | direct_abstract_declarator LSBRAC unary_expression RSBRAC
2284 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2285 $$->u.type_declarator.type = TYPEDEC_NESTED;
2286 $$->u.type_declarator.u.nested.type_declarator = $1;
2287 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2288 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2290 | direct_abstract_declarator LSBRAC RSBRAC
2292 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2293 $$->u.type_declarator.type = TYPEDEC_NESTED;
2294 $$->u.type_declarator.u.nested.type_declarator = $1;
2295 $$->u.type_declarator.u.nested.abstract_array = 1;
2299 alias_abstract_declarator_list:
2300 alias_abstract_declarator
2302 | alias_abstract_declarator_list COMMA alias_abstract_declarator
2305 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2309 alias_abstract_declarator:
2310 direct_alias_abstract_declarator
2312 | pointer direct_alias_abstract_declarator
2315 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2319 direct_alias_abstract_declarator:
2322 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2323 $$->u.type_declarator.type = TYPEDEC_ID;
2326 | LPAREN alias_abstract_declarator RPAREN
2328 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2329 $$->u.type_declarator.type = TYPEDEC_NESTED;
2330 $$->u.type_declarator.u.nested.type_declarator = $2;
2332 | direct_alias_abstract_declarator LSBRAC unary_expression RSBRAC
2334 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2335 $$->u.type_declarator.type = TYPEDEC_NESTED;
2336 $$->u.type_declarator.u.nested.type_declarator = $1;
2337 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2338 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2340 | direct_alias_abstract_declarator LSBRAC RSBRAC
2342 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2343 $$->u.type_declarator.type = TYPEDEC_NESTED;
2344 $$->u.type_declarator.u.nested.type_declarator = $1;
2345 $$->u.type_declarator.u.nested.abstract_array = 1;
2352 | pointer direct_declarator
2355 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2362 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2363 $$->u.type_declarator.type = TYPEDEC_ID;
2364 $$->u.type_declarator.u.id = $1->s;
2366 | LPAREN declarator RPAREN
2368 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2369 $$->u.type_declarator.type = TYPEDEC_NESTED;
2370 $$->u.type_declarator.u.nested.type_declarator = $2;
2372 | direct_declarator LSBRAC unary_expression RSBRAC
2374 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2375 $$->u.type_declarator.type = TYPEDEC_NESTED;
2376 $$->u.type_declarator.u.nested.type_declarator = $1;
2377 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2378 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2383 direct_type_declarator
2385 | pointer direct_type_declarator
2388 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2392 direct_type_declarator:
2395 add_type(scanner, $1);
2396 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2397 $$->u.type_declarator.type = TYPEDEC_ID;
2398 $$->u.type_declarator.u.id = $1->s;
2400 | LPAREN type_declarator RPAREN
2402 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2403 $$->u.type_declarator.type = TYPEDEC_NESTED;
2404 $$->u.type_declarator.u.nested.type_declarator = $2;
2406 | direct_type_declarator LSBRAC unary_expression RSBRAC
2408 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2409 $$->u.type_declarator.type = TYPEDEC_NESTED;
2410 $$->u.type_declarator.u.nested.type_declarator = $1;
2411 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2412 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2419 $$ = make_node(scanner, NODE_POINTER);
2423 $$ = make_node(scanner, NODE_POINTER);
2424 bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
2426 | STAR type_qualifier_list pointer
2428 $$ = make_node(scanner, NODE_POINTER);
2429 $$->u.pointer.const_qualifier = 1;
2430 bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
2434 type_qualifier_list:
2435 /* pointer assumes only const type qualifier */
2437 | type_qualifier_list CONST
2440 /* 2.3: CTF-specific declarations */
2442 ctf_assignment_expression_list:
2443 ctf_assignment_expression SEMICOLON
2445 | ctf_assignment_expression_list ctf_assignment_expression SEMICOLON
2448 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2452 ctf_assignment_expression:
2453 unary_expression EQUAL unary_expression
2456 * Because we have left and right, cannot use
2459 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2460 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2461 if ($1->u.unary_expression.type != UNARY_STRING)
2462 reparent_error(scanner, "ctf_assignment_expression left expects string");
2463 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
2465 | unary_expression TYPEASSIGN declaration_specifiers /* Only allow struct */
2468 * Because we have left and right, cannot use
2471 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2472 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2473 if ($1->u.unary_expression.type != UNARY_STRING)
2474 reparent_error(scanner, "ctf_assignment_expression left expects string");
2475 bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
2477 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list
2479 struct ctf_node *list;
2481 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2482 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2483 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2484 $$ = make_node(scanner, NODE_TYPEDEF);
2485 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2486 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
2488 | TYPEDEF declaration_specifiers type_declarator_list
2490 struct ctf_node *list;
2492 $$ = make_node(scanner, NODE_TYPEDEF);
2493 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2494 $$->u._typedef.type_specifier_list = list;
2495 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2496 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2498 | declaration_specifiers TYPEDEF type_declarator_list
2500 struct ctf_node *list;
2502 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2503 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2504 $$ = make_node(scanner, NODE_TYPEDEF);
2505 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2506 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2508 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
2510 struct ctf_node *list;
2512 $$ = make_node(scanner, NODE_TYPEALIAS);
2513 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2514 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2516 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2517 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
2518 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2519 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
2521 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2522 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
2523 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2524 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);