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.
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
37 #include <babeltrace/list.h>
38 #include <babeltrace/babeltrace-internal.h>
39 #include "ctf-scanner.h"
40 #include "ctf-parser.h"
46 /* Join two lists, put "add" at the end of "head". */
48 _bt_list_splice_tail (struct bt_list_head *add, struct bt_list_head *head)
50 /* Do nothing if the list which gets added is empty. */
51 if (add != add->next) {
52 add->next->prev = head->prev;
53 add->prev->next = head;
54 head->prev->next = add->next;
55 head->prev = add->prev;
60 int yyparse(struct ctf_scanner *scanner);
62 int yylex(union YYSTYPE *yyval, struct ctf_scanner *scanner);
64 int yylex_init_extra(struct ctf_scanner *scanner, yyscan_t * ptr_yy_globals);
66 int yylex_destroy(yyscan_t yyscanner);
68 void yyrestart(FILE * in_str, yyscan_t scanner);
70 int yyget_lineno(yyscan_t yyscanner);
72 char *yyget_text(yyscan_t yyscanner);
75 struct bt_list_head gc;
80 static const char *node_type_to_str[] = {
81 #define ENTRY(S) [S] = #S,
82 FOREACH_CTF_NODES(ENTRY)
87 * Static node for out of memory errors. Only "type" is used. lineno is
88 * always left at 0. The rest of the node content can be overwritten,
91 static struct ctf_node error_node = {
96 const char *node_type(struct ctf_node *node)
98 if (node->type < NR_NODE_TYPES)
99 return node_type_to_str[node->type];
104 static struct gc_string *gc_string_alloc(struct ctf_scanner *scanner,
107 struct gc_string *gstr;
110 /* TODO: could be faster with find first bit or glib Gstring */
111 /* sizeof long to account for malloc header (int or long ?) */
112 for (alloclen = 8; alloclen < sizeof(long) + sizeof(*gstr) + len;
115 gstr = malloc(alloclen);
116 bt_list_add(&gstr->gc, &scanner->allocated_strings);
117 gstr->alloclen = alloclen;
121 void setstring(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src)
123 lvalp->gs = gc_string_alloc(scanner, strlen(src) + 1);
124 strcpy(lvalp->gs->s, src);
128 int str_check(size_t str_len, size_t offset, size_t len)
131 if (offset + len < offset)
133 if (offset + len > str_len)
139 int import_basic_string(struct ctf_scanner *scanner, YYSTYPE *lvalp,
140 size_t len, const char *src, char delim)
142 size_t pos = 0, dpos = 0;
144 if (str_check(len, pos, 1))
146 if (src[pos++] != delim)
149 while (src[pos] != delim) {
152 if (str_check(len, pos, 1))
156 if (str_check(len, pos, 1))
201 if (str_check(len, pos, oct_len))
203 if (!isdigit((int) src[pos]) || !isdigit((int) src[pos+1]) || !isdigit((int) src[pos+2]))
205 char oct_buffer[4] = { src[pos], src[pos+1], src[pos+2], '\0' };
206 c = strtoul(&oct_buffer[0], NULL, 8);
214 if (str_check(len, pos, hex_len))
216 if (!isxdigit((int) src[pos]) || !isxdigit((int) src[pos+1]))
218 char hex_buffer[3] = { src[pos], src[pos+1], '\0' };
219 c = strtoul(&hex_buffer[0], NULL, 16);
227 if (str_check(len, dpos, 1))
229 lvalp->gs->s[dpos++] = c;
232 if (str_check(len, dpos, 1))
234 lvalp->gs->s[dpos++] = '\0';
236 if (str_check(len, pos, 1))
238 if (src[pos++] != delim)
241 if (str_check(len, pos, 1))
243 if (src[pos] != '\0')
248 int import_string(struct ctf_scanner *scanner, YYSTYPE *lvalp,
249 const char *src, char delim)
253 len = strlen(src) + 1;
254 lvalp->gs = gc_string_alloc(scanner, len);
256 // TODO: import wide string
257 printfl_error(yyget_lineno(scanner),
258 "Wide string not supported yet.");
261 return import_basic_string(scanner, lvalp, len, src, delim);
265 static void init_scope(struct ctf_scanner_scope *scope,
266 struct ctf_scanner_scope *parent)
268 scope->parent = parent;
269 scope->types = g_hash_table_new_full(g_str_hash, g_str_equal,
273 static void finalize_scope(struct ctf_scanner_scope *scope)
275 g_hash_table_destroy(scope->types);
278 static void push_scope(struct ctf_scanner *scanner)
280 struct ctf_scanner_scope *ns;
282 printf_debug("push scope\n");
283 ns = malloc(sizeof(struct ctf_scanner_scope));
284 init_scope(ns, scanner->cs);
288 static void pop_scope(struct ctf_scanner *scanner)
290 struct ctf_scanner_scope *os;
292 printf_debug("pop scope\n");
294 scanner->cs = os->parent;
299 static int lookup_type(struct ctf_scanner_scope *s, const char *id)
303 ret = (int) (long) g_hash_table_lookup(s->types, id);
304 printf_debug("lookup %p %s %d\n", s, id, ret);
309 int is_type(struct ctf_scanner *scanner, const char *id)
311 struct ctf_scanner_scope *it;
314 for (it = scanner->cs; it != NULL; it = it->parent) {
315 if (lookup_type(it, id)) {
320 printf_debug("is type %s %d\n", id, ret);
324 static void add_type(struct ctf_scanner *scanner, struct gc_string *id)
326 printf_debug("add type %s\n", id->s);
327 if (lookup_type(scanner->cs, id->s))
329 g_hash_table_insert(scanner->cs->types, id->s, id->s);
332 static struct ctf_node *make_node(struct ctf_scanner *scanner,
335 struct ctf_ast *ast = ctf_scanner_get_ast(scanner);
336 struct ctf_node *node;
338 node = malloc(sizeof(*node));
340 printfl_fatal(yyget_lineno(scanner->scanner), "out of memory");
343 memset(node, 0, sizeof(*node));
345 node->lineno = yyget_lineno(scanner->scanner);
346 BT_INIT_LIST_HEAD(&node->tmp_head);
347 bt_list_add(&node->gc, &ast->allocated_nodes);
348 bt_list_add(&node->siblings, &node->tmp_head);
352 node->type = NODE_ERROR;
353 printfn_fatal(node, "trying to create root node");
357 BT_INIT_LIST_HEAD(&node->u.event.declaration_list);
360 BT_INIT_LIST_HEAD(&node->u.stream.declaration_list);
363 BT_INIT_LIST_HEAD(&node->u.env.declaration_list);
366 BT_INIT_LIST_HEAD(&node->u.trace.declaration_list);
369 BT_INIT_LIST_HEAD(&node->u.clock.declaration_list);
372 BT_INIT_LIST_HEAD(&node->u.callsite.declaration_list);
375 case NODE_CTF_EXPRESSION:
376 BT_INIT_LIST_HEAD(&node->u.ctf_expression.left);
377 BT_INIT_LIST_HEAD(&node->u.ctf_expression.right);
379 case NODE_UNARY_EXPRESSION:
383 BT_INIT_LIST_HEAD(&node->u._typedef.type_declarators);
385 case NODE_TYPEALIAS_TARGET:
386 BT_INIT_LIST_HEAD(&node->u.typealias_target.type_declarators);
388 case NODE_TYPEALIAS_ALIAS:
389 BT_INIT_LIST_HEAD(&node->u.typealias_alias.type_declarators);
394 case NODE_TYPE_SPECIFIER:
396 case NODE_TYPE_SPECIFIER_LIST:
397 BT_INIT_LIST_HEAD(&node->u.type_specifier_list.head);
401 case NODE_TYPE_DECLARATOR:
402 BT_INIT_LIST_HEAD(&node->u.type_declarator.pointers);
405 case NODE_FLOATING_POINT:
406 BT_INIT_LIST_HEAD(&node->u.floating_point.expressions);
409 BT_INIT_LIST_HEAD(&node->u.integer.expressions);
412 BT_INIT_LIST_HEAD(&node->u.string.expressions);
414 case NODE_ENUMERATOR:
415 BT_INIT_LIST_HEAD(&node->u.enumerator.values);
418 BT_INIT_LIST_HEAD(&node->u._enum.enumerator_list);
420 case NODE_STRUCT_OR_VARIANT_DECLARATION:
421 BT_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.type_declarators);
424 BT_INIT_LIST_HEAD(&node->u.variant.declaration_list);
427 BT_INIT_LIST_HEAD(&node->u._struct.declaration_list);
428 BT_INIT_LIST_HEAD(&node->u._struct.min_align);
433 node->type = NODE_ERROR;
434 printfn_fatal(node, "unknown node type '%d'", (int) type);
441 static int reparent_ctf_expression(struct ctf_node *node,
442 struct ctf_node *parent)
444 switch (parent->type) {
446 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
449 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
452 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
455 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
458 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
461 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
463 case NODE_FLOATING_POINT:
464 _bt_list_splice_tail(&node->tmp_head, &parent->u.floating_point.expressions);
467 _bt_list_splice_tail(&node->tmp_head, &parent->u.integer.expressions);
470 _bt_list_splice_tail(&node->tmp_head, &parent->u.string.expressions);
474 case NODE_CTF_EXPRESSION:
476 case NODE_TYPEALIAS_TARGET:
477 case NODE_TYPEALIAS_ALIAS:
479 case NODE_TYPE_SPECIFIER:
480 case NODE_TYPE_SPECIFIER_LIST:
482 case NODE_TYPE_DECLARATOR:
483 case NODE_ENUMERATOR:
485 case NODE_STRUCT_OR_VARIANT_DECLARATION:
488 case NODE_UNARY_EXPRESSION:
493 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
499 static int reparent_typedef(struct ctf_node *node, struct ctf_node *parent)
501 switch (parent->type) {
503 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
506 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
509 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
512 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
515 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
518 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
521 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
524 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
527 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
530 case NODE_FLOATING_POINT:
533 case NODE_CTF_EXPRESSION:
535 case NODE_TYPEALIAS_TARGET:
536 case NODE_TYPEALIAS_ALIAS:
538 case NODE_TYPE_SPECIFIER:
539 case NODE_TYPE_SPECIFIER_LIST:
541 case NODE_TYPE_DECLARATOR:
542 case NODE_ENUMERATOR:
544 case NODE_STRUCT_OR_VARIANT_DECLARATION:
545 case NODE_UNARY_EXPRESSION:
550 printfn_fatal(node, "unknown node type %d", parent->type);
556 static int reparent_typealias(struct ctf_node *node, struct ctf_node *parent)
558 switch (parent->type) {
560 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
563 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
566 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
569 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
572 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
575 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
578 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
581 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
584 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
587 case NODE_FLOATING_POINT:
590 case NODE_CTF_EXPRESSION:
592 case NODE_TYPEALIAS_TARGET:
593 case NODE_TYPEALIAS_ALIAS:
595 case NODE_TYPE_SPECIFIER:
596 case NODE_TYPE_SPECIFIER_LIST:
598 case NODE_TYPE_DECLARATOR:
599 case NODE_ENUMERATOR:
601 case NODE_STRUCT_OR_VARIANT_DECLARATION:
602 case NODE_UNARY_EXPRESSION:
607 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
613 static int reparent_type_specifier(struct ctf_node *node,
614 struct ctf_node *parent)
616 switch (parent->type) {
617 case NODE_TYPE_SPECIFIER_LIST:
618 _bt_list_splice_tail(&node->tmp_head, &parent->u.type_specifier_list.head);
621 case NODE_TYPE_SPECIFIER:
631 case NODE_TYPEALIAS_TARGET:
632 case NODE_TYPEALIAS_ALIAS:
633 case NODE_TYPE_DECLARATOR:
635 case NODE_STRUCT_OR_VARIANT_DECLARATION:
637 case NODE_FLOATING_POINT:
640 case NODE_CTF_EXPRESSION:
642 case NODE_ENUMERATOR:
643 case NODE_UNARY_EXPRESSION:
648 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
654 static int reparent_type_specifier_list(struct ctf_node *node,
655 struct ctf_node *parent)
657 switch (parent->type) {
659 bt_list_add_tail(&node->siblings, &parent->u.root.declaration_list);
662 bt_list_add_tail(&node->siblings, &parent->u.event.declaration_list);
665 bt_list_add_tail(&node->siblings, &parent->u.stream.declaration_list);
668 bt_list_add_tail(&node->siblings, &parent->u.env.declaration_list);
671 bt_list_add_tail(&node->siblings, &parent->u.trace.declaration_list);
674 bt_list_add_tail(&node->siblings, &parent->u.clock.declaration_list);
677 bt_list_add_tail(&node->siblings, &parent->u.callsite.declaration_list);
680 bt_list_add_tail(&node->siblings, &parent->u.variant.declaration_list);
683 bt_list_add_tail(&node->siblings, &parent->u._struct.declaration_list);
686 parent->u._typedef.type_specifier_list = node;
688 case NODE_TYPEALIAS_TARGET:
689 parent->u.typealias_target.type_specifier_list = node;
691 case NODE_TYPEALIAS_ALIAS:
692 parent->u.typealias_alias.type_specifier_list = node;
695 parent->u._enum.container_type = node;
697 case NODE_STRUCT_OR_VARIANT_DECLARATION:
698 parent->u.struct_or_variant_declaration.type_specifier_list = node;
700 case NODE_TYPE_DECLARATOR:
701 case NODE_TYPE_SPECIFIER:
703 case NODE_FLOATING_POINT:
706 case NODE_CTF_EXPRESSION:
708 case NODE_ENUMERATOR:
709 case NODE_UNARY_EXPRESSION:
714 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
720 static int reparent_type_declarator(struct ctf_node *node,
721 struct ctf_node *parent)
723 switch (parent->type) {
724 case NODE_TYPE_DECLARATOR:
725 parent->u.type_declarator.type = TYPEDEC_NESTED;
726 parent->u.type_declarator.u.nested.type_declarator = node;
728 case NODE_STRUCT_OR_VARIANT_DECLARATION:
729 _bt_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.type_declarators);
732 _bt_list_splice_tail(&node->tmp_head, &parent->u._typedef.type_declarators);
734 case NODE_TYPEALIAS_TARGET:
735 _bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_target.type_declarators);
737 case NODE_TYPEALIAS_ALIAS:
738 _bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_alias.type_declarators);
752 case NODE_FLOATING_POINT:
755 case NODE_CTF_EXPRESSION:
756 case NODE_TYPE_SPECIFIER:
757 case NODE_TYPE_SPECIFIER_LIST:
759 case NODE_ENUMERATOR:
760 case NODE_UNARY_EXPRESSION:
765 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
774 * Link node to parent. Returns 0 on success, -EPERM if it is not permitted to
775 * create the link declared by the input, -ENOENT if node or parent is NULL,
776 * -EINVAL if there is an internal structure problem.
778 static int set_parent_node(struct ctf_node *node,
779 struct ctf_node *parent)
781 if (!node || !parent)
784 /* Note: Linking to parent will be done only by an external visitor */
786 switch (node->type) {
788 printfn_fatal(node, "trying to reparent root node");
792 if (parent->type == NODE_ROOT) {
793 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.event);
799 if (parent->type == NODE_ROOT) {
800 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.stream);
806 if (parent->type == NODE_ROOT) {
807 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.env);
813 if (parent->type == NODE_ROOT) {
814 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.trace);
820 if (parent->type == NODE_ROOT) {
821 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.clock);
827 if (parent->type == NODE_ROOT) {
828 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.callsite);
834 case NODE_CTF_EXPRESSION:
835 return reparent_ctf_expression(node, parent);
836 case NODE_UNARY_EXPRESSION:
837 if (parent->type == NODE_TYPE_DECLARATOR)
838 parent->u.type_declarator.bitfield_len = node;
844 return reparent_typedef(node, parent);
845 case NODE_TYPEALIAS_TARGET:
846 if (parent->type == NODE_TYPEALIAS)
847 parent->u.typealias.target = node;
850 case NODE_TYPEALIAS_ALIAS:
851 if (parent->type == NODE_TYPEALIAS)
852 parent->u.typealias.alias = node;
856 return reparent_typealias(node, parent);
859 if (parent->type == NODE_TYPE_DECLARATOR) {
860 _bt_list_splice_tail(&node->tmp_head, &parent->u.type_declarator.pointers);
864 case NODE_TYPE_DECLARATOR:
865 return reparent_type_declarator(node, parent);
867 case NODE_TYPE_SPECIFIER_LIST:
868 return reparent_type_specifier_list(node, parent);
870 case NODE_TYPE_SPECIFIER:
871 return reparent_type_specifier(node, parent);
873 case NODE_FLOATING_POINT:
879 return -EINVAL; /* Dealt with internally within grammar */
881 case NODE_ENUMERATOR:
882 if (parent->type == NODE_ENUM) {
883 _bt_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
888 case NODE_STRUCT_OR_VARIANT_DECLARATION:
889 switch (parent->type) {
891 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
894 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
903 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
910 void yyerror(struct ctf_scanner *scanner, const char *str)
912 printfl_error(yyget_lineno(scanner->scanner),
913 "token \"%s\": %s\n",
914 yyget_text(scanner->scanner), str);
923 #define reparent_error(scanner, str) \
925 yyerror(scanner, YY_("reparent_error: " str)); \
929 static void free_strings(struct bt_list_head *list)
931 struct gc_string *gstr, *tmp;
933 bt_list_for_each_entry_safe(gstr, tmp, list, gc)
937 static struct ctf_ast *ctf_ast_alloc(void)
941 ast = malloc(sizeof(*ast));
944 memset(ast, 0, sizeof(*ast));
945 BT_INIT_LIST_HEAD(&ast->allocated_nodes);
946 ast->root.type = NODE_ROOT;
947 BT_INIT_LIST_HEAD(&ast->root.tmp_head);
948 BT_INIT_LIST_HEAD(&ast->root.u.root.declaration_list);
949 BT_INIT_LIST_HEAD(&ast->root.u.root.trace);
950 BT_INIT_LIST_HEAD(&ast->root.u.root.env);
951 BT_INIT_LIST_HEAD(&ast->root.u.root.stream);
952 BT_INIT_LIST_HEAD(&ast->root.u.root.event);
953 BT_INIT_LIST_HEAD(&ast->root.u.root.clock);
954 BT_INIT_LIST_HEAD(&ast->root.u.root.callsite);
958 static void ctf_ast_free(struct ctf_ast *ast)
960 struct ctf_node *node, *tmp;
962 bt_list_for_each_entry_safe(node, tmp, &ast->allocated_nodes, gc)
967 int ctf_scanner_append_ast(struct ctf_scanner *scanner)
969 return yyparse(scanner);
972 struct ctf_scanner *ctf_scanner_alloc(FILE *input)
974 struct ctf_scanner *scanner;
977 yydebug = babeltrace_debug;
979 scanner = malloc(sizeof(*scanner));
982 memset(scanner, 0, sizeof(*scanner));
984 ret = yylex_init_extra(scanner, &scanner->scanner);
986 printf_fatal("yylex_init error");
987 goto cleanup_scanner;
989 /* Start processing new stream */
990 yyrestart(input, scanner->scanner);
992 scanner->ast = ctf_ast_alloc();
995 init_scope(&scanner->root_scope, NULL);
996 scanner->cs = &scanner->root_scope;
997 BT_INIT_LIST_HEAD(&scanner->allocated_strings);
1000 fprintf(stdout, "Scanner input is a%s.\n",
1001 isatty(fileno(input)) ? "n interactive tty" :
1002 " noninteractive file");
1007 ret = yylex_destroy(scanner->scanner);
1009 printf_fatal("yylex_destroy error");
1015 void ctf_scanner_free(struct ctf_scanner *scanner)
1019 finalize_scope(&scanner->root_scope);
1020 free_strings(&scanner->allocated_strings);
1021 ctf_ast_free(scanner->ast);
1022 ret = yylex_destroy(scanner->scanner);
1024 printf_error("yylex_destroy error");
1033 %parse-param {struct ctf_scanner *scanner}
1034 %lex-param {struct ctf_scanner *scanner}
1036 * Expect two shift-reduce conflicts. Caused by enum name-opt : type {}
1037 * vs struct { int :value; } (unnamed bit-field). The default is to
1038 * shift, so whenever we encounter an enumeration, we are doing the
1039 * proper thing (shift). It is illegal to declare an enumeration
1040 * "bit-field", so it is OK if this situation ends up in a parsing
1045 %token INTEGER_LITERAL STRING_LITERAL CHARACTER_LITERAL 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 TOK_ALIGN
1046 %token <gs> IDENTIFIER ID_TYPE
1051 unsigned long long ull;
1053 struct gc_string *gs;
1057 %type <gs> STRING_LITERAL CHARACTER_LITERAL
1061 %type <ull> INTEGER_LITERAL
1062 %type <n> postfix_expression unary_expression unary_expression_or_range
1064 %type <n> declaration
1065 %type <n> event_declaration
1066 %type <n> stream_declaration
1067 %type <n> env_declaration
1068 %type <n> trace_declaration
1069 %type <n> clock_declaration
1070 %type <n> callsite_declaration
1071 %type <n> integer_declaration_specifiers
1072 %type <n> declaration_specifiers
1073 %type <n> alias_declaration_specifiers
1075 %type <n> type_declarator_list
1076 %type <n> integer_type_specifier
1077 %type <n> type_specifier
1078 %type <n> struct_type_specifier
1079 %type <n> variant_type_specifier
1080 %type <n> enum_type_specifier
1081 %type <n> struct_or_variant_declaration_list
1082 %type <n> struct_or_variant_declaration
1083 %type <n> struct_or_variant_declarator_list
1084 %type <n> struct_or_variant_declarator
1085 %type <n> enumerator_list
1086 %type <n> enumerator
1087 %type <n> abstract_declarator_list
1088 %type <n> abstract_declarator
1089 %type <n> direct_abstract_declarator
1090 %type <n> alias_abstract_declarator_list
1091 %type <n> alias_abstract_declarator
1092 %type <n> direct_alias_abstract_declarator
1093 %type <n> declarator
1094 %type <n> direct_declarator
1095 %type <n> type_declarator
1096 %type <n> direct_type_declarator
1098 %type <n> ctf_assignment_expression_list
1099 %type <n> ctf_assignment_expression
1106 if (set_parent_node($1, &ctf_scanner_get_ast(scanner)->root))
1107 reparent_error(scanner, "error reparenting to root");
1111 if (set_parent_node($2, &ctf_scanner_get_ast(scanner)->root))
1112 reparent_error(scanner, "error reparenting to root");
1174 /* 2: Phrase structure grammar */
1179 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1180 $$->u.unary_expression.type = UNARY_STRING;
1181 $$->u.unary_expression.u.string = yylval.gs->s;
1185 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1186 $$->u.unary_expression.type = UNARY_STRING;
1187 $$->u.unary_expression.u.string = yylval.gs->s;
1191 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1192 $$->u.unary_expression.type = UNARY_STRING;
1193 $$->u.unary_expression.u.string = yylval.gs->s;
1197 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1198 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1199 $$->u.unary_expression.u.unsigned_constant = $1;
1203 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1204 $$->u.unary_expression.type = UNARY_STRING;
1205 $$->u.unary_expression.u.string = $1->s;
1209 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1210 $$->u.unary_expression.type = UNARY_STRING;
1211 $$->u.unary_expression.u.string = $1->s;
1213 | LPAREN unary_expression RPAREN
1217 | postfix_expression LSBRAC unary_expression RSBRAC
1219 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1220 $$->u.unary_expression.type = UNARY_SBRAC;
1221 $$->u.unary_expression.u.sbrac_exp = $3;
1222 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1223 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1225 | postfix_expression DOT IDENTIFIER
1227 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1228 $$->u.unary_expression.type = UNARY_STRING;
1229 $$->u.unary_expression.u.string = yylval.gs->s;
1230 $$->u.unary_expression.link = UNARY_DOTLINK;
1231 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1232 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1234 | postfix_expression DOT ID_TYPE
1236 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1237 $$->u.unary_expression.type = UNARY_STRING;
1238 $$->u.unary_expression.u.string = yylval.gs->s;
1239 $$->u.unary_expression.link = UNARY_DOTLINK;
1240 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1241 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1243 | postfix_expression RARROW IDENTIFIER
1245 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1246 $$->u.unary_expression.type = UNARY_STRING;
1247 $$->u.unary_expression.u.string = yylval.gs->s;
1248 $$->u.unary_expression.link = UNARY_ARROWLINK;
1249 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1250 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1252 | postfix_expression RARROW ID_TYPE
1254 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1255 $$->u.unary_expression.type = UNARY_STRING;
1256 $$->u.unary_expression.u.string = yylval.gs->s;
1257 $$->u.unary_expression.link = UNARY_ARROWLINK;
1258 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1259 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1266 | PLUS postfix_expression
1269 if ($$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
1270 && $$->u.unary_expression.type != UNARY_SIGNED_CONSTANT) {
1271 reparent_error(scanner, "expecting numeric constant");
1274 | MINUS postfix_expression
1277 if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1278 $$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
1279 $$->u.unary_expression.u.signed_constant =
1280 -($$->u.unary_expression.u.unsigned_constant);
1281 } else if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1282 $$->u.unary_expression.u.signed_constant =
1283 -($$->u.unary_expression.u.signed_constant);
1285 reparent_error(scanner, "expecting numeric constant");
1290 unary_expression_or_range:
1291 unary_expression DOTDOTDOT unary_expression
1294 _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
1295 $3->u.unary_expression.link = UNARY_DOTDOTDOT;
1301 /* 2.2: Declarations */
1304 declaration_specifiers SEMICOLON
1308 | stream_declaration
1316 | callsite_declaration
1318 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
1320 struct ctf_node *list;
1322 $$ = make_node(scanner, NODE_TYPEDEF);
1323 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1324 $$->u._typedef.type_specifier_list = list;
1325 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1326 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1327 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
1329 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
1331 struct ctf_node *list;
1333 $$ = make_node(scanner, NODE_TYPEDEF);
1334 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1335 $$->u._typedef.type_specifier_list = list;
1336 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1337 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
1339 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
1341 struct ctf_node *list;
1343 $$ = make_node(scanner, NODE_TYPEDEF);
1344 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1345 $$->u._typedef.type_specifier_list = list;
1346 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1347 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
1349 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
1351 struct ctf_node *list;
1353 $$ = make_node(scanner, NODE_TYPEALIAS);
1354 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1355 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1357 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1358 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
1359 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1360 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
1362 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1363 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
1364 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1365 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
1370 event_declaration_begin event_declaration_end
1372 $$ = make_node(scanner, NODE_EVENT);
1374 | event_declaration_begin ctf_assignment_expression_list event_declaration_end
1376 $$ = make_node(scanner, NODE_EVENT);
1377 if (set_parent_node($2, $$))
1378 reparent_error(scanner, "event_declaration");
1382 event_declaration_begin:
1384 { push_scope(scanner); }
1387 event_declaration_end:
1389 { pop_scope(scanner); }
1394 stream_declaration_begin stream_declaration_end
1396 $$ = make_node(scanner, NODE_STREAM);
1398 | stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
1400 $$ = make_node(scanner, NODE_STREAM);
1401 if (set_parent_node($2, $$))
1402 reparent_error(scanner, "stream_declaration");
1406 stream_declaration_begin:
1408 { push_scope(scanner); }
1411 stream_declaration_end:
1413 { pop_scope(scanner); }
1417 env_declaration_begin env_declaration_end
1419 $$ = make_node(scanner, NODE_ENV);
1421 | env_declaration_begin ctf_assignment_expression_list env_declaration_end
1423 $$ = make_node(scanner, NODE_ENV);
1424 if (set_parent_node($2, $$))
1425 reparent_error(scanner, "env declaration");
1429 env_declaration_begin:
1431 { push_scope(scanner); }
1434 env_declaration_end:
1436 { pop_scope(scanner); }
1440 trace_declaration_begin trace_declaration_end
1442 $$ = make_node(scanner, NODE_TRACE);
1444 | trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
1446 $$ = make_node(scanner, NODE_TRACE);
1447 if (set_parent_node($2, $$))
1448 reparent_error(scanner, "trace_declaration");
1452 trace_declaration_begin:
1454 { push_scope(scanner); }
1457 trace_declaration_end:
1459 { pop_scope(scanner); }
1463 CLOCK clock_declaration_begin clock_declaration_end
1465 $$ = make_node(scanner, NODE_CLOCK);
1467 | CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
1469 $$ = make_node(scanner, NODE_CLOCK);
1470 if (set_parent_node($3, $$))
1471 reparent_error(scanner, "trace_declaration");
1475 clock_declaration_begin:
1477 { push_scope(scanner); }
1480 clock_declaration_end:
1482 { pop_scope(scanner); }
1485 callsite_declaration:
1486 CALLSITE callsite_declaration_begin callsite_declaration_end
1488 $$ = make_node(scanner, NODE_CALLSITE);
1490 | CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
1492 $$ = make_node(scanner, NODE_CALLSITE);
1493 if (set_parent_node($3, $$))
1494 reparent_error(scanner, "trace_declaration");
1498 callsite_declaration_begin:
1500 { push_scope(scanner); }
1503 callsite_declaration_end:
1505 { pop_scope(scanner); }
1508 integer_declaration_specifiers:
1511 struct ctf_node *node;
1513 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
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 | integer_type_specifier
1520 struct ctf_node *node;
1522 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1524 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1526 | integer_declaration_specifiers CONST
1528 struct ctf_node *node;
1531 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1532 node->u.type_specifier.type = TYPESPEC_CONST;
1533 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1535 | integer_declaration_specifiers integer_type_specifier
1538 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
1542 declaration_specifiers:
1545 struct ctf_node *node;
1547 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1548 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1549 node->u.type_specifier.type = TYPESPEC_CONST;
1550 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1554 struct ctf_node *node;
1556 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1558 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1560 | declaration_specifiers CONST
1562 struct ctf_node *node;
1565 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1566 node->u.type_specifier.type = TYPESPEC_CONST;
1567 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1569 | declaration_specifiers type_specifier
1572 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
1576 type_declarator_list:
1579 | type_declarator_list COMMA type_declarator
1582 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1586 integer_type_specifier:
1589 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1590 $$->u.type_specifier.type = TYPESPEC_CHAR;
1594 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1595 $$->u.type_specifier.type = TYPESPEC_SHORT;
1599 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1600 $$->u.type_specifier.type = TYPESPEC_INT;
1604 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1605 $$->u.type_specifier.type = TYPESPEC_LONG;
1609 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1610 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1614 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1615 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1619 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1620 $$->u.type_specifier.type = TYPESPEC_BOOL;
1624 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1625 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
1626 $$->u.type_specifier.id_type = yylval.gs->s;
1628 | INTEGER LBRAC RBRAC
1630 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1631 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1632 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1634 | INTEGER LBRAC ctf_assignment_expression_list RBRAC
1636 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1637 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1638 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1639 if (set_parent_node($3, $$->u.type_specifier.node))
1640 reparent_error(scanner, "integer reparent error");
1647 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1648 $$->u.type_specifier.type = TYPESPEC_VOID;
1652 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1653 $$->u.type_specifier.type = TYPESPEC_CHAR;
1657 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1658 $$->u.type_specifier.type = TYPESPEC_SHORT;
1662 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1663 $$->u.type_specifier.type = TYPESPEC_INT;
1667 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1668 $$->u.type_specifier.type = TYPESPEC_LONG;
1672 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1673 $$->u.type_specifier.type = TYPESPEC_FLOAT;
1677 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1678 $$->u.type_specifier.type = TYPESPEC_DOUBLE;
1682 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1683 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1687 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1688 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1692 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1693 $$->u.type_specifier.type = TYPESPEC_BOOL;
1697 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1698 $$->u.type_specifier.type = TYPESPEC_COMPLEX;
1702 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1703 $$->u.type_specifier.type = TYPESPEC_IMAGINARY;
1707 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1708 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
1709 $$->u.type_specifier.id_type = yylval.gs->s;
1711 | FLOATING_POINT LBRAC RBRAC
1713 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1714 $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
1715 $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1717 | FLOATING_POINT LBRAC ctf_assignment_expression_list RBRAC
1719 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1720 $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
1721 $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1722 if (set_parent_node($3, $$->u.type_specifier.node))
1723 reparent_error(scanner, "floating point reparent error");
1725 | INTEGER LBRAC RBRAC
1727 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1728 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1729 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1731 | INTEGER LBRAC ctf_assignment_expression_list RBRAC
1733 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1734 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1735 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1736 if (set_parent_node($3, $$->u.type_specifier.node))
1737 reparent_error(scanner, "integer reparent error");
1741 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1742 $$->u.type_specifier.type = TYPESPEC_STRING;
1743 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1745 | STRING LBRAC RBRAC
1747 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1748 $$->u.type_specifier.type = TYPESPEC_STRING;
1749 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1751 | STRING LBRAC ctf_assignment_expression_list RBRAC
1753 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1754 $$->u.type_specifier.type = TYPESPEC_STRING;
1755 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1756 if (set_parent_node($3, $$->u.type_specifier.node))
1757 reparent_error(scanner, "string reparent error");
1759 | ENUM enum_type_specifier
1761 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1762 $$->u.type_specifier.type = TYPESPEC_ENUM;
1763 $$->u.type_specifier.node = $2;
1765 | VARIANT variant_type_specifier
1767 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1768 $$->u.type_specifier.type = TYPESPEC_VARIANT;
1769 $$->u.type_specifier.node = $2;
1771 | STRUCT struct_type_specifier
1773 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1774 $$->u.type_specifier.type = TYPESPEC_STRUCT;
1775 $$->u.type_specifier.node = $2;
1779 struct_type_specifier:
1780 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1782 $$ = make_node(scanner, NODE_STRUCT);
1783 $$->u._struct.has_body = 1;
1784 if ($2 && set_parent_node($2, $$))
1785 reparent_error(scanner, "struct reparent error");
1787 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1789 $$ = make_node(scanner, NODE_STRUCT);
1790 $$->u._struct.has_body = 1;
1791 $$->u._struct.name = $1->s;
1792 if ($3 && set_parent_node($3, $$))
1793 reparent_error(scanner, "struct reparent error");
1795 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1797 $$ = make_node(scanner, NODE_STRUCT);
1798 $$->u._struct.has_body = 1;
1799 $$->u._struct.name = $1->s;
1800 if ($3 && set_parent_node($3, $$))
1801 reparent_error(scanner, "struct reparent error");
1805 $$ = make_node(scanner, NODE_STRUCT);
1806 $$->u._struct.has_body = 0;
1807 $$->u._struct.name = $1->s;
1811 $$ = make_node(scanner, NODE_STRUCT);
1812 $$->u._struct.has_body = 0;
1813 $$->u._struct.name = $1->s;
1815 | struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1817 $$ = make_node(scanner, NODE_STRUCT);
1818 $$->u._struct.has_body = 1;
1819 bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
1820 if ($2 && set_parent_node($2, $$))
1821 reparent_error(scanner, "struct reparent error");
1823 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1825 $$ = make_node(scanner, NODE_STRUCT);
1826 $$->u._struct.has_body = 1;
1827 $$->u._struct.name = $1->s;
1828 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1829 if ($3 && set_parent_node($3, $$))
1830 reparent_error(scanner, "struct reparent error");
1832 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1834 $$ = make_node(scanner, NODE_STRUCT);
1835 $$->u._struct.has_body = 1;
1836 $$->u._struct.name = $1->s;
1837 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1838 if ($3 && set_parent_node($3, $$))
1839 reparent_error(scanner, "struct reparent error");
1843 struct_declaration_begin:
1845 { push_scope(scanner); }
1848 struct_declaration_end:
1850 { pop_scope(scanner); }
1853 variant_type_specifier:
1854 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1856 $$ = make_node(scanner, NODE_VARIANT);
1857 $$->u.variant.has_body = 1;
1858 if ($2 && set_parent_node($2, $$))
1859 reparent_error(scanner, "variant reparent error");
1861 | LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1863 $$ = make_node(scanner, NODE_VARIANT);
1864 $$->u.variant.has_body = 1;
1865 $$->u.variant.choice = $2->s;
1866 if ($5 && set_parent_node($5, $$))
1867 reparent_error(scanner, "variant reparent error");
1869 | LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1871 $$ = make_node(scanner, NODE_VARIANT);
1872 $$->u.variant.has_body = 1;
1873 $$->u.variant.choice = $2->s;
1874 if ($5 && set_parent_node($5, $$))
1875 reparent_error(scanner, "variant reparent error");
1877 | IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1879 $$ = make_node(scanner, NODE_VARIANT);
1880 $$->u.variant.has_body = 1;
1881 $$->u.variant.name = $1->s;
1882 if ($3 && set_parent_node($3, $$))
1883 reparent_error(scanner, "variant reparent error");
1885 | IDENTIFIER LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1887 $$ = make_node(scanner, NODE_VARIANT);
1888 $$->u.variant.has_body = 1;
1889 $$->u.variant.name = $1->s;
1890 $$->u.variant.choice = $3->s;
1891 if ($6 && set_parent_node($6, $$))
1892 reparent_error(scanner, "variant reparent error");
1894 | IDENTIFIER LT IDENTIFIER GT
1896 $$ = make_node(scanner, NODE_VARIANT);
1897 $$->u.variant.has_body = 0;
1898 $$->u.variant.name = $1->s;
1899 $$->u.variant.choice = $3->s;
1901 | IDENTIFIER LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1903 $$ = make_node(scanner, NODE_VARIANT);
1904 $$->u.variant.has_body = 1;
1905 $$->u.variant.name = $1->s;
1906 $$->u.variant.choice = $3->s;
1907 if ($6 && set_parent_node($6, $$))
1908 reparent_error(scanner, "variant reparent error");
1910 | IDENTIFIER LT ID_TYPE GT
1912 $$ = make_node(scanner, NODE_VARIANT);
1913 $$->u.variant.has_body = 0;
1914 $$->u.variant.name = $1->s;
1915 $$->u.variant.choice = $3->s;
1917 | ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1919 $$ = make_node(scanner, NODE_VARIANT);
1920 $$->u.variant.has_body = 1;
1921 $$->u.variant.name = $1->s;
1922 if ($3 && set_parent_node($3, $$))
1923 reparent_error(scanner, "variant reparent error");
1925 | ID_TYPE LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1927 $$ = make_node(scanner, NODE_VARIANT);
1928 $$->u.variant.has_body = 1;
1929 $$->u.variant.name = $1->s;
1930 $$->u.variant.choice = $3->s;
1931 if ($6 && set_parent_node($6, $$))
1932 reparent_error(scanner, "variant reparent error");
1934 | ID_TYPE LT IDENTIFIER GT
1936 $$ = make_node(scanner, NODE_VARIANT);
1937 $$->u.variant.has_body = 0;
1938 $$->u.variant.name = $1->s;
1939 $$->u.variant.choice = $3->s;
1941 | ID_TYPE LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1943 $$ = make_node(scanner, NODE_VARIANT);
1944 $$->u.variant.has_body = 1;
1945 $$->u.variant.name = $1->s;
1946 $$->u.variant.choice = $3->s;
1947 if ($6 && set_parent_node($6, $$))
1948 reparent_error(scanner, "variant reparent error");
1950 | ID_TYPE LT ID_TYPE GT
1952 $$ = make_node(scanner, NODE_VARIANT);
1953 $$->u.variant.has_body = 0;
1954 $$->u.variant.name = $1->s;
1955 $$->u.variant.choice = $3->s;
1959 variant_declaration_begin:
1961 { push_scope(scanner); }
1964 variant_declaration_end:
1966 { pop_scope(scanner); }
1969 enum_type_specifier:
1970 LBRAC enumerator_list RBRAC
1972 $$ = make_node(scanner, NODE_ENUM);
1973 $$->u._enum.has_body = 1;
1974 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
1976 | COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
1978 $$ = make_node(scanner, NODE_ENUM);
1979 $$->u._enum.has_body = 1;
1980 ($$)->u._enum.container_type = $2;
1981 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
1983 | IDENTIFIER LBRAC enumerator_list RBRAC
1985 $$ = make_node(scanner, NODE_ENUM);
1986 $$->u._enum.has_body = 1;
1987 $$->u._enum.enum_id = $1->s;
1988 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1990 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
1992 $$ = make_node(scanner, NODE_ENUM);
1993 $$->u._enum.has_body = 1;
1994 $$->u._enum.enum_id = $1->s;
1995 ($$)->u._enum.container_type = $3;
1996 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
1998 | ID_TYPE LBRAC enumerator_list RBRAC
2000 $$ = make_node(scanner, NODE_ENUM);
2001 $$->u._enum.has_body = 1;
2002 $$->u._enum.enum_id = $1->s;
2003 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2005 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
2007 $$ = make_node(scanner, NODE_ENUM);
2008 $$->u._enum.has_body = 1;
2009 $$->u._enum.enum_id = $1->s;
2010 ($$)->u._enum.container_type = $3;
2011 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2013 | LBRAC enumerator_list COMMA RBRAC
2015 $$ = make_node(scanner, NODE_ENUM);
2016 $$->u._enum.has_body = 1;
2017 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
2019 | COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
2021 $$ = make_node(scanner, NODE_ENUM);
2022 $$->u._enum.has_body = 1;
2023 ($$)->u._enum.container_type = $2;
2024 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2026 | IDENTIFIER LBRAC enumerator_list COMMA RBRAC
2028 $$ = make_node(scanner, NODE_ENUM);
2029 $$->u._enum.has_body = 1;
2030 $$->u._enum.enum_id = $1->s;
2031 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2033 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
2035 $$ = make_node(scanner, NODE_ENUM);
2036 $$->u._enum.has_body = 1;
2037 $$->u._enum.enum_id = $1->s;
2038 ($$)->u._enum.container_type = $3;
2039 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2043 $$ = make_node(scanner, NODE_ENUM);
2044 $$->u._enum.has_body = 0;
2045 $$->u._enum.enum_id = $1->s;
2047 | ID_TYPE LBRAC enumerator_list COMMA RBRAC
2049 $$ = make_node(scanner, NODE_ENUM);
2050 $$->u._enum.has_body = 1;
2051 $$->u._enum.enum_id = $1->s;
2052 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2054 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
2056 $$ = make_node(scanner, NODE_ENUM);
2057 $$->u._enum.has_body = 1;
2058 $$->u._enum.enum_id = $1->s;
2059 ($$)->u._enum.container_type = $3;
2060 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2064 $$ = make_node(scanner, NODE_ENUM);
2065 $$->u._enum.has_body = 0;
2066 $$->u._enum.enum_id = $1->s;
2070 struct_or_variant_declaration_list:
2073 | struct_or_variant_declaration_list struct_or_variant_declaration
2077 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2080 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
2085 struct_or_variant_declaration:
2086 declaration_specifiers struct_or_variant_declarator_list SEMICOLON
2088 struct ctf_node *list;
2090 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2091 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2092 $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
2093 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2094 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
2096 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
2098 struct ctf_node *list;
2100 $$ = make_node(scanner, NODE_TYPEDEF);
2101 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2102 $$->u._typedef.type_specifier_list = list;
2103 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2104 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2105 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
2107 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
2109 struct ctf_node *list;
2111 $$ = make_node(scanner, NODE_TYPEDEF);
2112 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2113 $$->u._typedef.type_specifier_list = list;
2114 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2115 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2117 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
2119 struct ctf_node *list;
2121 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2122 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2123 $$ = make_node(scanner, NODE_TYPEDEF);
2124 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2125 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2127 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
2129 struct ctf_node *list;
2131 $$ = make_node(scanner, NODE_TYPEALIAS);
2132 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2133 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2135 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2136 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
2137 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2138 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
2140 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2141 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
2142 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2143 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
2147 alias_declaration_specifiers:
2150 struct ctf_node *node;
2152 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2153 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2154 node->u.type_specifier.type = TYPESPEC_CONST;
2155 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2159 struct ctf_node *node;
2161 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2163 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2167 struct ctf_node *node;
2169 add_type(scanner, $1);
2170 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2171 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2172 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
2173 node->u.type_specifier.id_type = yylval.gs->s;
2174 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2176 | alias_declaration_specifiers CONST
2178 struct ctf_node *node;
2181 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2182 node->u.type_specifier.type = TYPESPEC_CONST;
2183 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2185 | alias_declaration_specifiers type_specifier
2188 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
2190 | alias_declaration_specifiers IDENTIFIER
2192 struct ctf_node *node;
2194 add_type(scanner, $2);
2196 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2197 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
2198 node->u.type_specifier.id_type = yylval.gs->s;
2199 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2203 struct_or_variant_declarator_list:
2204 struct_or_variant_declarator
2206 | struct_or_variant_declarator_list COMMA struct_or_variant_declarator
2209 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2213 struct_or_variant_declarator:
2216 | COLON unary_expression
2218 | declarator COLON unary_expression
2221 if (set_parent_node($3, $1))
2222 reparent_error(scanner, "struct_or_variant_declarator");
2229 | enumerator_list COMMA enumerator
2232 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2239 $$ = make_node(scanner, NODE_ENUMERATOR);
2240 $$->u.enumerator.id = $1->s;
2244 $$ = make_node(scanner, NODE_ENUMERATOR);
2245 $$->u.enumerator.id = $1->s;
2249 $$ = make_node(scanner, NODE_ENUMERATOR);
2250 $$->u.enumerator.id = $1->s;
2254 $$ = make_node(scanner, NODE_ENUMERATOR);
2255 $$->u.enumerator.id = $1->s;
2257 | IDENTIFIER EQUAL unary_expression_or_range
2259 $$ = make_node(scanner, NODE_ENUMERATOR);
2260 $$->u.enumerator.id = $1->s;
2261 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2263 | ID_TYPE EQUAL unary_expression_or_range
2265 $$ = make_node(scanner, NODE_ENUMERATOR);
2266 $$->u.enumerator.id = $1->s;
2267 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2269 | keywords EQUAL unary_expression_or_range
2271 $$ = make_node(scanner, NODE_ENUMERATOR);
2272 $$->u.enumerator.id = $1->s;
2273 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2275 | STRING_LITERAL EQUAL unary_expression_or_range
2277 $$ = make_node(scanner, NODE_ENUMERATOR);
2278 $$->u.enumerator.id = $1->s;
2279 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2283 abstract_declarator_list:
2286 | abstract_declarator_list COMMA abstract_declarator
2289 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2293 abstract_declarator:
2294 direct_abstract_declarator
2296 | pointer direct_abstract_declarator
2299 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2303 direct_abstract_declarator:
2306 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2307 $$->u.type_declarator.type = TYPEDEC_ID;
2312 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2313 $$->u.type_declarator.type = TYPEDEC_ID;
2314 $$->u.type_declarator.u.id = $1->s;
2316 | LPAREN abstract_declarator RPAREN
2318 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2319 $$->u.type_declarator.type = TYPEDEC_NESTED;
2320 $$->u.type_declarator.u.nested.type_declarator = $2;
2322 | direct_abstract_declarator LSBRAC unary_expression RSBRAC
2324 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2325 $$->u.type_declarator.type = TYPEDEC_NESTED;
2326 $$->u.type_declarator.u.nested.type_declarator = $1;
2327 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2328 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2330 | direct_abstract_declarator LSBRAC RSBRAC
2332 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2333 $$->u.type_declarator.type = TYPEDEC_NESTED;
2334 $$->u.type_declarator.u.nested.type_declarator = $1;
2335 $$->u.type_declarator.u.nested.abstract_array = 1;
2339 alias_abstract_declarator_list:
2340 alias_abstract_declarator
2342 | alias_abstract_declarator_list COMMA alias_abstract_declarator
2345 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2349 alias_abstract_declarator:
2350 direct_alias_abstract_declarator
2352 | pointer direct_alias_abstract_declarator
2355 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2359 direct_alias_abstract_declarator:
2362 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2363 $$->u.type_declarator.type = TYPEDEC_ID;
2366 | LPAREN alias_abstract_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_alias_abstract_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);
2380 | direct_alias_abstract_declarator LSBRAC RSBRAC
2382 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2383 $$->u.type_declarator.type = TYPEDEC_NESTED;
2384 $$->u.type_declarator.u.nested.type_declarator = $1;
2385 $$->u.type_declarator.u.nested.abstract_array = 1;
2392 | pointer direct_declarator
2395 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2402 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2403 $$->u.type_declarator.type = TYPEDEC_ID;
2404 $$->u.type_declarator.u.id = $1->s;
2406 | LPAREN declarator RPAREN
2408 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2409 $$->u.type_declarator.type = TYPEDEC_NESTED;
2410 $$->u.type_declarator.u.nested.type_declarator = $2;
2412 | direct_declarator LSBRAC unary_expression RSBRAC
2414 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2415 $$->u.type_declarator.type = TYPEDEC_NESTED;
2416 $$->u.type_declarator.u.nested.type_declarator = $1;
2417 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2418 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2423 direct_type_declarator
2425 | pointer direct_type_declarator
2428 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2432 direct_type_declarator:
2435 add_type(scanner, $1);
2436 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2437 $$->u.type_declarator.type = TYPEDEC_ID;
2438 $$->u.type_declarator.u.id = $1->s;
2440 | LPAREN type_declarator RPAREN
2442 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2443 $$->u.type_declarator.type = TYPEDEC_NESTED;
2444 $$->u.type_declarator.u.nested.type_declarator = $2;
2446 | direct_type_declarator LSBRAC unary_expression RSBRAC
2448 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2449 $$->u.type_declarator.type = TYPEDEC_NESTED;
2450 $$->u.type_declarator.u.nested.type_declarator = $1;
2451 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2452 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2459 $$ = make_node(scanner, NODE_POINTER);
2463 $$ = make_node(scanner, NODE_POINTER);
2464 bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
2466 | STAR type_qualifier_list pointer
2468 $$ = make_node(scanner, NODE_POINTER);
2469 $$->u.pointer.const_qualifier = 1;
2470 bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
2474 type_qualifier_list:
2475 /* pointer assumes only const type qualifier */
2477 | type_qualifier_list CONST
2480 /* 2.3: CTF-specific declarations */
2482 ctf_assignment_expression_list:
2483 ctf_assignment_expression SEMICOLON
2485 | ctf_assignment_expression_list ctf_assignment_expression SEMICOLON
2488 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2492 ctf_assignment_expression:
2493 unary_expression EQUAL unary_expression
2496 * Because we have left and right, cannot use
2499 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2500 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2501 if ($1->u.unary_expression.type != UNARY_STRING)
2502 reparent_error(scanner, "ctf_assignment_expression left expects string");
2503 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
2505 | unary_expression TYPEASSIGN declaration_specifiers /* Only allow struct */
2508 * Because we have left and right, cannot use
2511 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2512 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2513 if ($1->u.unary_expression.type != UNARY_STRING)
2514 reparent_error(scanner, "ctf_assignment_expression left expects string");
2515 bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
2517 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list
2519 struct ctf_node *list;
2521 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2522 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2523 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2524 $$ = make_node(scanner, NODE_TYPEDEF);
2525 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2526 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
2528 | TYPEDEF declaration_specifiers type_declarator_list
2530 struct ctf_node *list;
2532 $$ = make_node(scanner, NODE_TYPEDEF);
2533 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2534 $$->u._typedef.type_specifier_list = list;
2535 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2536 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2538 | declaration_specifiers TYPEDEF type_declarator_list
2540 struct ctf_node *list;
2542 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2543 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2544 $$ = make_node(scanner, NODE_TYPEDEF);
2545 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2546 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2548 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
2550 struct ctf_node *list;
2552 $$ = make_node(scanner, NODE_TYPEALIAS);
2553 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2554 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2556 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2557 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
2558 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2559 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
2561 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2562 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
2563 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2564 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);