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)
86 /* Static node for out of memory errors */
87 static __thread struct ctf_node error_node = {
92 const char *node_type(struct ctf_node *node)
94 if (node->type < NR_NODE_TYPES)
95 return node_type_to_str[node->type];
100 static struct gc_string *gc_string_alloc(struct ctf_scanner *scanner,
103 struct gc_string *gstr;
106 /* TODO: could be faster with find first bit or glib Gstring */
107 /* sizeof long to account for malloc header (int or long ?) */
108 for (alloclen = 8; alloclen < sizeof(long) + sizeof(*gstr) + len;
111 gstr = malloc(alloclen);
112 bt_list_add(&gstr->gc, &scanner->allocated_strings);
113 gstr->alloclen = alloclen;
117 void setstring(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src)
119 lvalp->gs = gc_string_alloc(scanner, strlen(src) + 1);
120 strcpy(lvalp->gs->s, src);
124 int str_check(size_t str_len, size_t offset, size_t len)
127 if (offset + len < offset)
129 if (offset + len > str_len)
135 int import_basic_string(struct ctf_scanner *scanner, YYSTYPE *lvalp,
136 size_t len, const char *src, char delim)
138 size_t pos = 0, dpos = 0;
140 if (str_check(len, pos, 1))
142 if (src[pos++] != delim)
145 while (src[pos] != delim) {
148 if (str_check(len, pos, 1))
152 if (str_check(len, pos, 1))
197 if (str_check(len, pos, oct_len))
199 if (!isdigit((int) src[pos]) || !isdigit((int) src[pos+1]) || !isdigit((int) src[pos+2]))
201 char oct_buffer[4] = { src[pos], src[pos+1], src[pos+2], '\0' };
202 c = strtoul(&oct_buffer[0], NULL, 8);
210 if (str_check(len, pos, hex_len))
212 if (!isxdigit((int) src[pos]) || !isxdigit((int) src[pos+1]))
214 char hex_buffer[3] = { src[pos], src[pos+1], '\0' };
215 c = strtoul(&hex_buffer[0], NULL, 16);
223 if (str_check(len, dpos, 1))
225 lvalp->gs->s[dpos++] = c;
228 if (str_check(len, dpos, 1))
230 lvalp->gs->s[dpos++] = '\0';
232 if (str_check(len, pos, 1))
234 if (src[pos++] != delim)
237 if (str_check(len, pos, 1))
239 if (src[pos] != '\0')
244 int import_string(struct ctf_scanner *scanner, YYSTYPE *lvalp,
245 const char *src, char delim)
249 len = strlen(src) + 1;
250 lvalp->gs = gc_string_alloc(scanner, len);
252 // TODO: import wide string
253 printfl_error(yyget_lineno(scanner),
254 "Wide string not supported yet.");
257 return import_basic_string(scanner, lvalp, len, src, delim);
261 static void init_scope(struct ctf_scanner_scope *scope,
262 struct ctf_scanner_scope *parent)
264 scope->parent = parent;
265 scope->types = g_hash_table_new_full(g_str_hash, g_str_equal,
269 static void finalize_scope(struct ctf_scanner_scope *scope)
271 g_hash_table_destroy(scope->types);
274 static void push_scope(struct ctf_scanner *scanner)
276 struct ctf_scanner_scope *ns;
278 printf_debug("push scope\n");
279 ns = malloc(sizeof(struct ctf_scanner_scope));
280 init_scope(ns, scanner->cs);
284 static void pop_scope(struct ctf_scanner *scanner)
286 struct ctf_scanner_scope *os;
288 printf_debug("pop scope\n");
290 scanner->cs = os->parent;
295 static int lookup_type(struct ctf_scanner_scope *s, const char *id)
299 ret = (int) (long) g_hash_table_lookup(s->types, id);
300 printf_debug("lookup %p %s %d\n", s, id, ret);
305 int is_type(struct ctf_scanner *scanner, const char *id)
307 struct ctf_scanner_scope *it;
310 for (it = scanner->cs; it != NULL; it = it->parent) {
311 if (lookup_type(it, id)) {
316 printf_debug("is type %s %d\n", id, ret);
320 static void add_type(struct ctf_scanner *scanner, struct gc_string *id)
322 printf_debug("add type %s\n", id->s);
323 if (lookup_type(scanner->cs, id->s))
325 g_hash_table_insert(scanner->cs->types, id->s, id->s);
328 static struct ctf_node *make_node(struct ctf_scanner *scanner,
331 struct ctf_ast *ast = ctf_scanner_get_ast(scanner);
332 struct ctf_node *node;
334 node = malloc(sizeof(*node));
336 error_node.lineno = yyget_lineno(scanner->scanner);
337 printfl_fatal(error_node.lineno, "out of memory");
340 memset(node, 0, sizeof(*node));
342 node->lineno = yyget_lineno(scanner->scanner);
343 BT_INIT_LIST_HEAD(&node->tmp_head);
344 bt_list_add(&node->gc, &ast->allocated_nodes);
345 bt_list_add(&node->siblings, &node->tmp_head);
349 node->type = NODE_ERROR;
350 printfn_fatal(node, "trying to create root node");
354 BT_INIT_LIST_HEAD(&node->u.event.declaration_list);
357 BT_INIT_LIST_HEAD(&node->u.stream.declaration_list);
360 BT_INIT_LIST_HEAD(&node->u.env.declaration_list);
363 BT_INIT_LIST_HEAD(&node->u.trace.declaration_list);
366 BT_INIT_LIST_HEAD(&node->u.clock.declaration_list);
369 BT_INIT_LIST_HEAD(&node->u.callsite.declaration_list);
372 case NODE_CTF_EXPRESSION:
373 BT_INIT_LIST_HEAD(&node->u.ctf_expression.left);
374 BT_INIT_LIST_HEAD(&node->u.ctf_expression.right);
376 case NODE_UNARY_EXPRESSION:
380 BT_INIT_LIST_HEAD(&node->u._typedef.type_declarators);
382 case NODE_TYPEALIAS_TARGET:
383 BT_INIT_LIST_HEAD(&node->u.typealias_target.type_declarators);
385 case NODE_TYPEALIAS_ALIAS:
386 BT_INIT_LIST_HEAD(&node->u.typealias_alias.type_declarators);
391 case NODE_TYPE_SPECIFIER:
393 case NODE_TYPE_SPECIFIER_LIST:
394 BT_INIT_LIST_HEAD(&node->u.type_specifier_list.head);
398 case NODE_TYPE_DECLARATOR:
399 BT_INIT_LIST_HEAD(&node->u.type_declarator.pointers);
402 case NODE_FLOATING_POINT:
403 BT_INIT_LIST_HEAD(&node->u.floating_point.expressions);
406 BT_INIT_LIST_HEAD(&node->u.integer.expressions);
409 BT_INIT_LIST_HEAD(&node->u.string.expressions);
411 case NODE_ENUMERATOR:
412 BT_INIT_LIST_HEAD(&node->u.enumerator.values);
415 BT_INIT_LIST_HEAD(&node->u._enum.enumerator_list);
417 case NODE_STRUCT_OR_VARIANT_DECLARATION:
418 BT_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.type_declarators);
421 BT_INIT_LIST_HEAD(&node->u.variant.declaration_list);
424 BT_INIT_LIST_HEAD(&node->u._struct.declaration_list);
425 BT_INIT_LIST_HEAD(&node->u._struct.min_align);
430 node->type = NODE_ERROR;
431 printfn_fatal(node, "unknown node type '%d'", (int) type);
438 static int reparent_ctf_expression(struct ctf_node *node,
439 struct ctf_node *parent)
441 switch (parent->type) {
443 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
446 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
449 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
452 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
455 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
458 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
460 case NODE_FLOATING_POINT:
461 _bt_list_splice_tail(&node->tmp_head, &parent->u.floating_point.expressions);
464 _bt_list_splice_tail(&node->tmp_head, &parent->u.integer.expressions);
467 _bt_list_splice_tail(&node->tmp_head, &parent->u.string.expressions);
471 case NODE_CTF_EXPRESSION:
473 case NODE_TYPEALIAS_TARGET:
474 case NODE_TYPEALIAS_ALIAS:
476 case NODE_TYPE_SPECIFIER:
477 case NODE_TYPE_SPECIFIER_LIST:
479 case NODE_TYPE_DECLARATOR:
480 case NODE_ENUMERATOR:
482 case NODE_STRUCT_OR_VARIANT_DECLARATION:
485 case NODE_UNARY_EXPRESSION:
490 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
496 static int reparent_typedef(struct ctf_node *node, struct ctf_node *parent)
498 switch (parent->type) {
500 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
503 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
506 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
509 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
512 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
515 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
518 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
521 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
524 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
527 case NODE_FLOATING_POINT:
530 case NODE_CTF_EXPRESSION:
532 case NODE_TYPEALIAS_TARGET:
533 case NODE_TYPEALIAS_ALIAS:
535 case NODE_TYPE_SPECIFIER:
536 case NODE_TYPE_SPECIFIER_LIST:
538 case NODE_TYPE_DECLARATOR:
539 case NODE_ENUMERATOR:
541 case NODE_STRUCT_OR_VARIANT_DECLARATION:
542 case NODE_UNARY_EXPRESSION:
547 printfn_fatal(node, "unknown node type %d", parent->type);
553 static int reparent_typealias(struct ctf_node *node, struct ctf_node *parent)
555 switch (parent->type) {
557 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
560 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
563 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
566 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
569 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
572 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
575 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
578 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
581 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
584 case NODE_FLOATING_POINT:
587 case NODE_CTF_EXPRESSION:
589 case NODE_TYPEALIAS_TARGET:
590 case NODE_TYPEALIAS_ALIAS:
592 case NODE_TYPE_SPECIFIER:
593 case NODE_TYPE_SPECIFIER_LIST:
595 case NODE_TYPE_DECLARATOR:
596 case NODE_ENUMERATOR:
598 case NODE_STRUCT_OR_VARIANT_DECLARATION:
599 case NODE_UNARY_EXPRESSION:
604 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
610 static int reparent_type_specifier(struct ctf_node *node,
611 struct ctf_node *parent)
613 switch (parent->type) {
614 case NODE_TYPE_SPECIFIER_LIST:
615 _bt_list_splice_tail(&node->tmp_head, &parent->u.type_specifier_list.head);
618 case NODE_TYPE_SPECIFIER:
628 case NODE_TYPEALIAS_TARGET:
629 case NODE_TYPEALIAS_ALIAS:
630 case NODE_TYPE_DECLARATOR:
632 case NODE_STRUCT_OR_VARIANT_DECLARATION:
634 case NODE_FLOATING_POINT:
637 case NODE_CTF_EXPRESSION:
639 case NODE_ENUMERATOR:
640 case NODE_UNARY_EXPRESSION:
645 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
651 static int reparent_type_specifier_list(struct ctf_node *node,
652 struct ctf_node *parent)
654 switch (parent->type) {
656 bt_list_add_tail(&node->siblings, &parent->u.root.declaration_list);
659 bt_list_add_tail(&node->siblings, &parent->u.event.declaration_list);
662 bt_list_add_tail(&node->siblings, &parent->u.stream.declaration_list);
665 bt_list_add_tail(&node->siblings, &parent->u.env.declaration_list);
668 bt_list_add_tail(&node->siblings, &parent->u.trace.declaration_list);
671 bt_list_add_tail(&node->siblings, &parent->u.clock.declaration_list);
674 bt_list_add_tail(&node->siblings, &parent->u.callsite.declaration_list);
677 bt_list_add_tail(&node->siblings, &parent->u.variant.declaration_list);
680 bt_list_add_tail(&node->siblings, &parent->u._struct.declaration_list);
683 parent->u._typedef.type_specifier_list = node;
685 case NODE_TYPEALIAS_TARGET:
686 parent->u.typealias_target.type_specifier_list = node;
688 case NODE_TYPEALIAS_ALIAS:
689 parent->u.typealias_alias.type_specifier_list = node;
692 parent->u._enum.container_type = node;
694 case NODE_STRUCT_OR_VARIANT_DECLARATION:
695 parent->u.struct_or_variant_declaration.type_specifier_list = node;
697 case NODE_TYPE_DECLARATOR:
698 case NODE_TYPE_SPECIFIER:
700 case NODE_FLOATING_POINT:
703 case NODE_CTF_EXPRESSION:
705 case NODE_ENUMERATOR:
706 case NODE_UNARY_EXPRESSION:
711 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
717 static int reparent_type_declarator(struct ctf_node *node,
718 struct ctf_node *parent)
720 switch (parent->type) {
721 case NODE_TYPE_DECLARATOR:
722 parent->u.type_declarator.type = TYPEDEC_NESTED;
723 parent->u.type_declarator.u.nested.type_declarator = node;
725 case NODE_STRUCT_OR_VARIANT_DECLARATION:
726 _bt_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.type_declarators);
729 _bt_list_splice_tail(&node->tmp_head, &parent->u._typedef.type_declarators);
731 case NODE_TYPEALIAS_TARGET:
732 _bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_target.type_declarators);
734 case NODE_TYPEALIAS_ALIAS:
735 _bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_alias.type_declarators);
749 case NODE_FLOATING_POINT:
752 case NODE_CTF_EXPRESSION:
753 case NODE_TYPE_SPECIFIER:
754 case NODE_TYPE_SPECIFIER_LIST:
756 case NODE_ENUMERATOR:
757 case NODE_UNARY_EXPRESSION:
762 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
771 * Link node to parent. Returns 0 on success, -EPERM if it is not permitted to
772 * create the link declared by the input, -ENOENT if node or parent is NULL,
773 * -EINVAL if there is an internal structure problem.
775 static int set_parent_node(struct ctf_node *node,
776 struct ctf_node *parent)
778 if (!node || !parent)
781 /* Note: Linking to parent will be done only by an external visitor */
783 switch (node->type) {
785 printfn_fatal(node, "trying to reparent root node");
789 if (parent->type == NODE_ROOT) {
790 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.event);
796 if (parent->type == NODE_ROOT) {
797 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.stream);
803 if (parent->type == NODE_ROOT) {
804 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.env);
810 if (parent->type == NODE_ROOT) {
811 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.trace);
817 if (parent->type == NODE_ROOT) {
818 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.clock);
824 if (parent->type == NODE_ROOT) {
825 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.callsite);
831 case NODE_CTF_EXPRESSION:
832 return reparent_ctf_expression(node, parent);
833 case NODE_UNARY_EXPRESSION:
834 if (parent->type == NODE_TYPE_DECLARATOR)
835 parent->u.type_declarator.bitfield_len = node;
841 return reparent_typedef(node, parent);
842 case NODE_TYPEALIAS_TARGET:
843 if (parent->type == NODE_TYPEALIAS)
844 parent->u.typealias.target = node;
847 case NODE_TYPEALIAS_ALIAS:
848 if (parent->type == NODE_TYPEALIAS)
849 parent->u.typealias.alias = node;
853 return reparent_typealias(node, parent);
856 if (parent->type == NODE_TYPE_DECLARATOR) {
857 _bt_list_splice_tail(&node->tmp_head, &parent->u.type_declarator.pointers);
861 case NODE_TYPE_DECLARATOR:
862 return reparent_type_declarator(node, parent);
864 case NODE_TYPE_SPECIFIER_LIST:
865 return reparent_type_specifier_list(node, parent);
867 case NODE_TYPE_SPECIFIER:
868 return reparent_type_specifier(node, parent);
870 case NODE_FLOATING_POINT:
876 return -EINVAL; /* Dealt with internally within grammar */
878 case NODE_ENUMERATOR:
879 if (parent->type == NODE_ENUM) {
880 _bt_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
885 case NODE_STRUCT_OR_VARIANT_DECLARATION:
886 switch (parent->type) {
888 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
891 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
900 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
907 void yyerror(struct ctf_scanner *scanner, const char *str)
909 printfl_error(yyget_lineno(scanner->scanner),
910 "token \"%s\": %s\n",
911 yyget_text(scanner->scanner), str);
920 #define reparent_error(scanner, str) \
922 yyerror(scanner, YY_("reparent_error: " str)); \
926 static void free_strings(struct bt_list_head *list)
928 struct gc_string *gstr, *tmp;
930 bt_list_for_each_entry_safe(gstr, tmp, list, gc)
934 static struct ctf_ast *ctf_ast_alloc(void)
938 ast = malloc(sizeof(*ast));
941 memset(ast, 0, sizeof(*ast));
942 BT_INIT_LIST_HEAD(&ast->allocated_nodes);
943 ast->root.type = NODE_ROOT;
944 BT_INIT_LIST_HEAD(&ast->root.tmp_head);
945 BT_INIT_LIST_HEAD(&ast->root.u.root.declaration_list);
946 BT_INIT_LIST_HEAD(&ast->root.u.root.trace);
947 BT_INIT_LIST_HEAD(&ast->root.u.root.env);
948 BT_INIT_LIST_HEAD(&ast->root.u.root.stream);
949 BT_INIT_LIST_HEAD(&ast->root.u.root.event);
950 BT_INIT_LIST_HEAD(&ast->root.u.root.clock);
951 BT_INIT_LIST_HEAD(&ast->root.u.root.callsite);
955 static void ctf_ast_free(struct ctf_ast *ast)
957 struct ctf_node *node, *tmp;
959 bt_list_for_each_entry_safe(node, tmp, &ast->allocated_nodes, gc)
964 int ctf_scanner_append_ast(struct ctf_scanner *scanner)
966 return yyparse(scanner);
969 struct ctf_scanner *ctf_scanner_alloc(FILE *input)
971 struct ctf_scanner *scanner;
974 yydebug = babeltrace_debug;
976 scanner = malloc(sizeof(*scanner));
979 memset(scanner, 0, sizeof(*scanner));
981 ret = yylex_init_extra(scanner, &scanner->scanner);
983 printf_fatal("yylex_init error");
984 goto cleanup_scanner;
986 /* Start processing new stream */
987 yyrestart(input, scanner->scanner);
989 scanner->ast = ctf_ast_alloc();
992 init_scope(&scanner->root_scope, NULL);
993 scanner->cs = &scanner->root_scope;
994 BT_INIT_LIST_HEAD(&scanner->allocated_strings);
997 fprintf(stdout, "Scanner input is a%s.\n",
998 isatty(fileno(input)) ? "n interactive tty" :
999 " noninteractive file");
1004 ret = yylex_destroy(scanner->scanner);
1006 printf_fatal("yylex_destroy error");
1012 void ctf_scanner_free(struct ctf_scanner *scanner)
1016 finalize_scope(&scanner->root_scope);
1017 free_strings(&scanner->allocated_strings);
1018 ctf_ast_free(scanner->ast);
1019 ret = yylex_destroy(scanner->scanner);
1021 printf_error("yylex_destroy error");
1030 %parse-param {struct ctf_scanner *scanner}
1031 %lex-param {struct ctf_scanner *scanner}
1033 * Expect two shift-reduce conflicts. Caused by enum name-opt : type {}
1034 * vs struct { int :value; } (unnamed bit-field). The default is to
1035 * shift, so whenever we encounter an enumeration, we are doing the
1036 * proper thing (shift). It is illegal to declare an enumeration
1037 * "bit-field", so it is OK if this situation ends up in a parsing
1042 %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
1043 %token <gs> IDENTIFIER ID_TYPE
1048 unsigned long long ull;
1050 struct gc_string *gs;
1054 %type <gs> STRING_LITERAL CHARACTER_LITERAL
1058 %type <ull> INTEGER_LITERAL
1059 %type <n> postfix_expression unary_expression unary_expression_or_range
1061 %type <n> declaration
1062 %type <n> event_declaration
1063 %type <n> stream_declaration
1064 %type <n> env_declaration
1065 %type <n> trace_declaration
1066 %type <n> clock_declaration
1067 %type <n> callsite_declaration
1068 %type <n> integer_declaration_specifiers
1069 %type <n> declaration_specifiers
1070 %type <n> alias_declaration_specifiers
1072 %type <n> type_declarator_list
1073 %type <n> integer_type_specifier
1074 %type <n> type_specifier
1075 %type <n> struct_type_specifier
1076 %type <n> variant_type_specifier
1077 %type <n> enum_type_specifier
1078 %type <n> struct_or_variant_declaration_list
1079 %type <n> struct_or_variant_declaration
1080 %type <n> struct_or_variant_declarator_list
1081 %type <n> struct_or_variant_declarator
1082 %type <n> enumerator_list
1083 %type <n> enumerator
1084 %type <n> abstract_declarator_list
1085 %type <n> abstract_declarator
1086 %type <n> direct_abstract_declarator
1087 %type <n> alias_abstract_declarator_list
1088 %type <n> alias_abstract_declarator
1089 %type <n> direct_alias_abstract_declarator
1090 %type <n> declarator
1091 %type <n> direct_declarator
1092 %type <n> type_declarator
1093 %type <n> direct_type_declarator
1095 %type <n> ctf_assignment_expression_list
1096 %type <n> ctf_assignment_expression
1103 if (set_parent_node($1, &ctf_scanner_get_ast(scanner)->root))
1104 reparent_error(scanner, "error reparenting to root");
1108 if (set_parent_node($2, &ctf_scanner_get_ast(scanner)->root))
1109 reparent_error(scanner, "error reparenting to root");
1171 /* 2: Phrase structure grammar */
1176 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1177 $$->u.unary_expression.type = UNARY_STRING;
1178 $$->u.unary_expression.u.string = yylval.gs->s;
1182 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1183 $$->u.unary_expression.type = UNARY_STRING;
1184 $$->u.unary_expression.u.string = yylval.gs->s;
1188 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1189 $$->u.unary_expression.type = UNARY_STRING;
1190 $$->u.unary_expression.u.string = yylval.gs->s;
1194 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1195 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1196 $$->u.unary_expression.u.unsigned_constant = $1;
1200 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1201 $$->u.unary_expression.type = UNARY_STRING;
1202 $$->u.unary_expression.u.string = $1->s;
1206 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1207 $$->u.unary_expression.type = UNARY_STRING;
1208 $$->u.unary_expression.u.string = $1->s;
1210 | LPAREN unary_expression RPAREN
1214 | postfix_expression LSBRAC unary_expression RSBRAC
1216 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1217 $$->u.unary_expression.type = UNARY_SBRAC;
1218 $$->u.unary_expression.u.sbrac_exp = $3;
1219 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1220 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1222 | postfix_expression DOT IDENTIFIER
1224 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1225 $$->u.unary_expression.type = UNARY_STRING;
1226 $$->u.unary_expression.u.string = yylval.gs->s;
1227 $$->u.unary_expression.link = UNARY_DOTLINK;
1228 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1229 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1231 | postfix_expression DOT ID_TYPE
1233 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1234 $$->u.unary_expression.type = UNARY_STRING;
1235 $$->u.unary_expression.u.string = yylval.gs->s;
1236 $$->u.unary_expression.link = UNARY_DOTLINK;
1237 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1238 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1240 | postfix_expression RARROW IDENTIFIER
1242 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1243 $$->u.unary_expression.type = UNARY_STRING;
1244 $$->u.unary_expression.u.string = yylval.gs->s;
1245 $$->u.unary_expression.link = UNARY_ARROWLINK;
1246 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1247 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1249 | postfix_expression RARROW ID_TYPE
1251 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1252 $$->u.unary_expression.type = UNARY_STRING;
1253 $$->u.unary_expression.u.string = yylval.gs->s;
1254 $$->u.unary_expression.link = UNARY_ARROWLINK;
1255 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1256 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1263 | PLUS postfix_expression
1266 if ($$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
1267 && $$->u.unary_expression.type != UNARY_SIGNED_CONSTANT) {
1268 reparent_error(scanner, "expecting numeric constant");
1271 | MINUS postfix_expression
1274 if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1275 $$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
1276 $$->u.unary_expression.u.signed_constant =
1277 -($$->u.unary_expression.u.unsigned_constant);
1278 } else if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1279 $$->u.unary_expression.u.signed_constant =
1280 -($$->u.unary_expression.u.signed_constant);
1282 reparent_error(scanner, "expecting numeric constant");
1287 unary_expression_or_range:
1288 unary_expression DOTDOTDOT unary_expression
1291 _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
1292 $3->u.unary_expression.link = UNARY_DOTDOTDOT;
1298 /* 2.2: Declarations */
1301 declaration_specifiers SEMICOLON
1305 | stream_declaration
1313 | callsite_declaration
1315 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
1317 struct ctf_node *list;
1319 $$ = make_node(scanner, NODE_TYPEDEF);
1320 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1321 $$->u._typedef.type_specifier_list = list;
1322 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1323 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1324 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
1326 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
1328 struct ctf_node *list;
1330 $$ = make_node(scanner, NODE_TYPEDEF);
1331 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1332 $$->u._typedef.type_specifier_list = list;
1333 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1334 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
1336 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
1338 struct ctf_node *list;
1340 $$ = make_node(scanner, NODE_TYPEDEF);
1341 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1342 $$->u._typedef.type_specifier_list = list;
1343 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1344 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
1346 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
1348 struct ctf_node *list;
1350 $$ = make_node(scanner, NODE_TYPEALIAS);
1351 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1352 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1354 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1355 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
1356 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1357 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
1359 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1360 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
1361 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1362 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
1367 event_declaration_begin event_declaration_end
1369 $$ = make_node(scanner, NODE_EVENT);
1371 | event_declaration_begin ctf_assignment_expression_list event_declaration_end
1373 $$ = make_node(scanner, NODE_EVENT);
1374 if (set_parent_node($2, $$))
1375 reparent_error(scanner, "event_declaration");
1379 event_declaration_begin:
1381 { push_scope(scanner); }
1384 event_declaration_end:
1386 { pop_scope(scanner); }
1391 stream_declaration_begin stream_declaration_end
1393 $$ = make_node(scanner, NODE_STREAM);
1395 | stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
1397 $$ = make_node(scanner, NODE_STREAM);
1398 if (set_parent_node($2, $$))
1399 reparent_error(scanner, "stream_declaration");
1403 stream_declaration_begin:
1405 { push_scope(scanner); }
1408 stream_declaration_end:
1410 { pop_scope(scanner); }
1414 env_declaration_begin env_declaration_end
1416 $$ = make_node(scanner, NODE_ENV);
1418 | env_declaration_begin ctf_assignment_expression_list env_declaration_end
1420 $$ = make_node(scanner, NODE_ENV);
1421 if (set_parent_node($2, $$))
1422 reparent_error(scanner, "env declaration");
1426 env_declaration_begin:
1428 { push_scope(scanner); }
1431 env_declaration_end:
1433 { pop_scope(scanner); }
1437 trace_declaration_begin trace_declaration_end
1439 $$ = make_node(scanner, NODE_TRACE);
1441 | trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
1443 $$ = make_node(scanner, NODE_TRACE);
1444 if (set_parent_node($2, $$))
1445 reparent_error(scanner, "trace_declaration");
1449 trace_declaration_begin:
1451 { push_scope(scanner); }
1454 trace_declaration_end:
1456 { pop_scope(scanner); }
1460 CLOCK clock_declaration_begin clock_declaration_end
1462 $$ = make_node(scanner, NODE_CLOCK);
1464 | CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
1466 $$ = make_node(scanner, NODE_CLOCK);
1467 if (set_parent_node($3, $$))
1468 reparent_error(scanner, "trace_declaration");
1472 clock_declaration_begin:
1474 { push_scope(scanner); }
1477 clock_declaration_end:
1479 { pop_scope(scanner); }
1482 callsite_declaration:
1483 CALLSITE callsite_declaration_begin callsite_declaration_end
1485 $$ = make_node(scanner, NODE_CALLSITE);
1487 | CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
1489 $$ = make_node(scanner, NODE_CALLSITE);
1490 if (set_parent_node($3, $$))
1491 reparent_error(scanner, "trace_declaration");
1495 callsite_declaration_begin:
1497 { push_scope(scanner); }
1500 callsite_declaration_end:
1502 { pop_scope(scanner); }
1505 integer_declaration_specifiers:
1508 struct ctf_node *node;
1510 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1511 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1512 node->u.type_specifier.type = TYPESPEC_CONST;
1513 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1515 | integer_type_specifier
1517 struct ctf_node *node;
1519 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1521 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1523 | integer_declaration_specifiers CONST
1525 struct ctf_node *node;
1528 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1529 node->u.type_specifier.type = TYPESPEC_CONST;
1530 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1532 | integer_declaration_specifiers integer_type_specifier
1535 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
1539 declaration_specifiers:
1542 struct ctf_node *node;
1544 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1545 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1546 node->u.type_specifier.type = TYPESPEC_CONST;
1547 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1551 struct ctf_node *node;
1553 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1555 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1557 | declaration_specifiers CONST
1559 struct ctf_node *node;
1562 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1563 node->u.type_specifier.type = TYPESPEC_CONST;
1564 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1566 | declaration_specifiers type_specifier
1569 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
1573 type_declarator_list:
1576 | type_declarator_list COMMA type_declarator
1579 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1583 integer_type_specifier:
1586 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1587 $$->u.type_specifier.type = TYPESPEC_CHAR;
1591 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1592 $$->u.type_specifier.type = TYPESPEC_SHORT;
1596 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1597 $$->u.type_specifier.type = TYPESPEC_INT;
1601 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1602 $$->u.type_specifier.type = TYPESPEC_LONG;
1606 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1607 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1611 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1612 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1616 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1617 $$->u.type_specifier.type = TYPESPEC_BOOL;
1621 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1622 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
1623 $$->u.type_specifier.id_type = yylval.gs->s;
1625 | INTEGER LBRAC RBRAC
1627 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1628 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1629 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1631 | INTEGER LBRAC ctf_assignment_expression_list RBRAC
1633 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1634 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1635 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1636 if (set_parent_node($3, $$->u.type_specifier.node))
1637 reparent_error(scanner, "integer reparent error");
1644 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1645 $$->u.type_specifier.type = TYPESPEC_VOID;
1649 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1650 $$->u.type_specifier.type = TYPESPEC_CHAR;
1654 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1655 $$->u.type_specifier.type = TYPESPEC_SHORT;
1659 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1660 $$->u.type_specifier.type = TYPESPEC_INT;
1664 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1665 $$->u.type_specifier.type = TYPESPEC_LONG;
1669 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1670 $$->u.type_specifier.type = TYPESPEC_FLOAT;
1674 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1675 $$->u.type_specifier.type = TYPESPEC_DOUBLE;
1679 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1680 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1684 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1685 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1689 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1690 $$->u.type_specifier.type = TYPESPEC_BOOL;
1694 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1695 $$->u.type_specifier.type = TYPESPEC_COMPLEX;
1699 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1700 $$->u.type_specifier.type = TYPESPEC_IMAGINARY;
1704 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1705 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
1706 $$->u.type_specifier.id_type = yylval.gs->s;
1708 | FLOATING_POINT LBRAC RBRAC
1710 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1711 $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
1712 $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1714 | FLOATING_POINT LBRAC ctf_assignment_expression_list RBRAC
1716 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1717 $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
1718 $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1719 if (set_parent_node($3, $$->u.type_specifier.node))
1720 reparent_error(scanner, "floating point reparent error");
1722 | INTEGER LBRAC RBRAC
1724 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1725 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1726 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1728 | INTEGER LBRAC ctf_assignment_expression_list RBRAC
1730 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1731 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1732 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1733 if (set_parent_node($3, $$->u.type_specifier.node))
1734 reparent_error(scanner, "integer reparent error");
1738 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1739 $$->u.type_specifier.type = TYPESPEC_STRING;
1740 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1742 | STRING LBRAC RBRAC
1744 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1745 $$->u.type_specifier.type = TYPESPEC_STRING;
1746 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1748 | STRING LBRAC ctf_assignment_expression_list RBRAC
1750 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1751 $$->u.type_specifier.type = TYPESPEC_STRING;
1752 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1753 if (set_parent_node($3, $$->u.type_specifier.node))
1754 reparent_error(scanner, "string reparent error");
1756 | ENUM enum_type_specifier
1758 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1759 $$->u.type_specifier.type = TYPESPEC_ENUM;
1760 $$->u.type_specifier.node = $2;
1762 | VARIANT variant_type_specifier
1764 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1765 $$->u.type_specifier.type = TYPESPEC_VARIANT;
1766 $$->u.type_specifier.node = $2;
1768 | STRUCT struct_type_specifier
1770 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1771 $$->u.type_specifier.type = TYPESPEC_STRUCT;
1772 $$->u.type_specifier.node = $2;
1776 struct_type_specifier:
1777 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1779 $$ = make_node(scanner, NODE_STRUCT);
1780 $$->u._struct.has_body = 1;
1781 if ($2 && set_parent_node($2, $$))
1782 reparent_error(scanner, "struct reparent error");
1784 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1786 $$ = make_node(scanner, NODE_STRUCT);
1787 $$->u._struct.has_body = 1;
1788 $$->u._struct.name = $1->s;
1789 if ($3 && set_parent_node($3, $$))
1790 reparent_error(scanner, "struct reparent error");
1792 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1794 $$ = make_node(scanner, NODE_STRUCT);
1795 $$->u._struct.has_body = 1;
1796 $$->u._struct.name = $1->s;
1797 if ($3 && set_parent_node($3, $$))
1798 reparent_error(scanner, "struct reparent error");
1802 $$ = make_node(scanner, NODE_STRUCT);
1803 $$->u._struct.has_body = 0;
1804 $$->u._struct.name = $1->s;
1808 $$ = make_node(scanner, NODE_STRUCT);
1809 $$->u._struct.has_body = 0;
1810 $$->u._struct.name = $1->s;
1812 | struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1814 $$ = make_node(scanner, NODE_STRUCT);
1815 $$->u._struct.has_body = 1;
1816 bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
1817 if ($2 && set_parent_node($2, $$))
1818 reparent_error(scanner, "struct reparent error");
1820 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1822 $$ = make_node(scanner, NODE_STRUCT);
1823 $$->u._struct.has_body = 1;
1824 $$->u._struct.name = $1->s;
1825 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1826 if ($3 && set_parent_node($3, $$))
1827 reparent_error(scanner, "struct reparent error");
1829 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1831 $$ = make_node(scanner, NODE_STRUCT);
1832 $$->u._struct.has_body = 1;
1833 $$->u._struct.name = $1->s;
1834 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1835 if ($3 && set_parent_node($3, $$))
1836 reparent_error(scanner, "struct reparent error");
1840 struct_declaration_begin:
1842 { push_scope(scanner); }
1845 struct_declaration_end:
1847 { pop_scope(scanner); }
1850 variant_type_specifier:
1851 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1853 $$ = make_node(scanner, NODE_VARIANT);
1854 $$->u.variant.has_body = 1;
1855 if ($2 && set_parent_node($2, $$))
1856 reparent_error(scanner, "variant reparent error");
1858 | LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1860 $$ = make_node(scanner, NODE_VARIANT);
1861 $$->u.variant.has_body = 1;
1862 $$->u.variant.choice = $2->s;
1863 if ($5 && set_parent_node($5, $$))
1864 reparent_error(scanner, "variant reparent error");
1866 | LT ID_TYPE GT 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.choice = $2->s;
1871 if ($5 && set_parent_node($5, $$))
1872 reparent_error(scanner, "variant reparent error");
1874 | IDENTIFIER 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 if ($3 && set_parent_node($3, $$))
1880 reparent_error(scanner, "variant reparent error");
1882 | IDENTIFIER LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1884 $$ = make_node(scanner, NODE_VARIANT);
1885 $$->u.variant.has_body = 1;
1886 $$->u.variant.name = $1->s;
1887 $$->u.variant.choice = $3->s;
1888 if ($6 && set_parent_node($6, $$))
1889 reparent_error(scanner, "variant reparent error");
1891 | IDENTIFIER LT IDENTIFIER GT
1893 $$ = make_node(scanner, NODE_VARIANT);
1894 $$->u.variant.has_body = 0;
1895 $$->u.variant.name = $1->s;
1896 $$->u.variant.choice = $3->s;
1898 | IDENTIFIER LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1900 $$ = make_node(scanner, NODE_VARIANT);
1901 $$->u.variant.has_body = 1;
1902 $$->u.variant.name = $1->s;
1903 $$->u.variant.choice = $3->s;
1904 if ($6 && set_parent_node($6, $$))
1905 reparent_error(scanner, "variant reparent error");
1907 | IDENTIFIER LT ID_TYPE GT
1909 $$ = make_node(scanner, NODE_VARIANT);
1910 $$->u.variant.has_body = 0;
1911 $$->u.variant.name = $1->s;
1912 $$->u.variant.choice = $3->s;
1914 | ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1916 $$ = make_node(scanner, NODE_VARIANT);
1917 $$->u.variant.has_body = 1;
1918 $$->u.variant.name = $1->s;
1919 if ($3 && set_parent_node($3, $$))
1920 reparent_error(scanner, "variant reparent error");
1922 | ID_TYPE LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1924 $$ = make_node(scanner, NODE_VARIANT);
1925 $$->u.variant.has_body = 1;
1926 $$->u.variant.name = $1->s;
1927 $$->u.variant.choice = $3->s;
1928 if ($6 && set_parent_node($6, $$))
1929 reparent_error(scanner, "variant reparent error");
1931 | ID_TYPE LT IDENTIFIER GT
1933 $$ = make_node(scanner, NODE_VARIANT);
1934 $$->u.variant.has_body = 0;
1935 $$->u.variant.name = $1->s;
1936 $$->u.variant.choice = $3->s;
1938 | ID_TYPE LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1940 $$ = make_node(scanner, NODE_VARIANT);
1941 $$->u.variant.has_body = 1;
1942 $$->u.variant.name = $1->s;
1943 $$->u.variant.choice = $3->s;
1944 if ($6 && set_parent_node($6, $$))
1945 reparent_error(scanner, "variant reparent error");
1947 | ID_TYPE LT ID_TYPE GT
1949 $$ = make_node(scanner, NODE_VARIANT);
1950 $$->u.variant.has_body = 0;
1951 $$->u.variant.name = $1->s;
1952 $$->u.variant.choice = $3->s;
1956 variant_declaration_begin:
1958 { push_scope(scanner); }
1961 variant_declaration_end:
1963 { pop_scope(scanner); }
1966 enum_type_specifier:
1967 LBRAC enumerator_list RBRAC
1969 $$ = make_node(scanner, NODE_ENUM);
1970 $$->u._enum.has_body = 1;
1971 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
1973 | COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
1975 $$ = make_node(scanner, NODE_ENUM);
1976 $$->u._enum.has_body = 1;
1977 ($$)->u._enum.container_type = $2;
1978 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
1980 | IDENTIFIER LBRAC enumerator_list RBRAC
1982 $$ = make_node(scanner, NODE_ENUM);
1983 $$->u._enum.has_body = 1;
1984 $$->u._enum.enum_id = $1->s;
1985 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1987 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
1989 $$ = make_node(scanner, NODE_ENUM);
1990 $$->u._enum.has_body = 1;
1991 $$->u._enum.enum_id = $1->s;
1992 ($$)->u._enum.container_type = $3;
1993 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
1995 | ID_TYPE LBRAC enumerator_list RBRAC
1997 $$ = make_node(scanner, NODE_ENUM);
1998 $$->u._enum.has_body = 1;
1999 $$->u._enum.enum_id = $1->s;
2000 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2002 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
2004 $$ = make_node(scanner, NODE_ENUM);
2005 $$->u._enum.has_body = 1;
2006 $$->u._enum.enum_id = $1->s;
2007 ($$)->u._enum.container_type = $3;
2008 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2010 | LBRAC enumerator_list COMMA RBRAC
2012 $$ = make_node(scanner, NODE_ENUM);
2013 $$->u._enum.has_body = 1;
2014 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
2016 | COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
2018 $$ = make_node(scanner, NODE_ENUM);
2019 $$->u._enum.has_body = 1;
2020 ($$)->u._enum.container_type = $2;
2021 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2023 | IDENTIFIER LBRAC enumerator_list COMMA RBRAC
2025 $$ = make_node(scanner, NODE_ENUM);
2026 $$->u._enum.has_body = 1;
2027 $$->u._enum.enum_id = $1->s;
2028 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2030 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
2032 $$ = make_node(scanner, NODE_ENUM);
2033 $$->u._enum.has_body = 1;
2034 $$->u._enum.enum_id = $1->s;
2035 ($$)->u._enum.container_type = $3;
2036 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2040 $$ = make_node(scanner, NODE_ENUM);
2041 $$->u._enum.has_body = 0;
2042 $$->u._enum.enum_id = $1->s;
2044 | ID_TYPE LBRAC enumerator_list COMMA RBRAC
2046 $$ = make_node(scanner, NODE_ENUM);
2047 $$->u._enum.has_body = 1;
2048 $$->u._enum.enum_id = $1->s;
2049 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2051 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
2053 $$ = make_node(scanner, NODE_ENUM);
2054 $$->u._enum.has_body = 1;
2055 $$->u._enum.enum_id = $1->s;
2056 ($$)->u._enum.container_type = $3;
2057 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2061 $$ = make_node(scanner, NODE_ENUM);
2062 $$->u._enum.has_body = 0;
2063 $$->u._enum.enum_id = $1->s;
2067 struct_or_variant_declaration_list:
2070 | struct_or_variant_declaration_list struct_or_variant_declaration
2074 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2077 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
2082 struct_or_variant_declaration:
2083 declaration_specifiers struct_or_variant_declarator_list SEMICOLON
2085 struct ctf_node *list;
2087 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2088 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2089 $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
2090 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2091 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
2093 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
2095 struct ctf_node *list;
2097 $$ = make_node(scanner, NODE_TYPEDEF);
2098 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2099 $$->u._typedef.type_specifier_list = list;
2100 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2101 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2102 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
2104 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
2106 struct ctf_node *list;
2108 $$ = make_node(scanner, NODE_TYPEDEF);
2109 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2110 $$->u._typedef.type_specifier_list = list;
2111 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2112 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2114 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
2116 struct ctf_node *list;
2118 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2119 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2120 $$ = make_node(scanner, NODE_TYPEDEF);
2121 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2122 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2124 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
2126 struct ctf_node *list;
2128 $$ = make_node(scanner, NODE_TYPEALIAS);
2129 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2130 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2132 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2133 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
2134 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2135 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
2137 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2138 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
2139 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2140 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
2144 alias_declaration_specifiers:
2147 struct ctf_node *node;
2149 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2150 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2151 node->u.type_specifier.type = TYPESPEC_CONST;
2152 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2156 struct ctf_node *node;
2158 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2160 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2164 struct ctf_node *node;
2166 add_type(scanner, $1);
2167 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2168 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2169 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
2170 node->u.type_specifier.id_type = yylval.gs->s;
2171 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2173 | alias_declaration_specifiers CONST
2175 struct ctf_node *node;
2178 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2179 node->u.type_specifier.type = TYPESPEC_CONST;
2180 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2182 | alias_declaration_specifiers type_specifier
2185 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
2187 | alias_declaration_specifiers IDENTIFIER
2189 struct ctf_node *node;
2191 add_type(scanner, $2);
2193 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2194 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
2195 node->u.type_specifier.id_type = yylval.gs->s;
2196 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2200 struct_or_variant_declarator_list:
2201 struct_or_variant_declarator
2203 | struct_or_variant_declarator_list COMMA struct_or_variant_declarator
2206 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2210 struct_or_variant_declarator:
2213 | COLON unary_expression
2215 | declarator COLON unary_expression
2218 if (set_parent_node($3, $1))
2219 reparent_error(scanner, "struct_or_variant_declarator");
2226 | enumerator_list COMMA enumerator
2229 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2236 $$ = make_node(scanner, NODE_ENUMERATOR);
2237 $$->u.enumerator.id = $1->s;
2241 $$ = make_node(scanner, NODE_ENUMERATOR);
2242 $$->u.enumerator.id = $1->s;
2246 $$ = make_node(scanner, NODE_ENUMERATOR);
2247 $$->u.enumerator.id = $1->s;
2251 $$ = make_node(scanner, NODE_ENUMERATOR);
2252 $$->u.enumerator.id = $1->s;
2254 | IDENTIFIER EQUAL unary_expression_or_range
2256 $$ = make_node(scanner, NODE_ENUMERATOR);
2257 $$->u.enumerator.id = $1->s;
2258 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2260 | ID_TYPE EQUAL unary_expression_or_range
2262 $$ = make_node(scanner, NODE_ENUMERATOR);
2263 $$->u.enumerator.id = $1->s;
2264 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2266 | keywords EQUAL unary_expression_or_range
2268 $$ = make_node(scanner, NODE_ENUMERATOR);
2269 $$->u.enumerator.id = $1->s;
2270 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2272 | STRING_LITERAL EQUAL unary_expression_or_range
2274 $$ = make_node(scanner, NODE_ENUMERATOR);
2275 $$->u.enumerator.id = $1->s;
2276 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2280 abstract_declarator_list:
2283 | abstract_declarator_list COMMA abstract_declarator
2286 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2290 abstract_declarator:
2291 direct_abstract_declarator
2293 | pointer direct_abstract_declarator
2296 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2300 direct_abstract_declarator:
2303 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2304 $$->u.type_declarator.type = TYPEDEC_ID;
2309 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2310 $$->u.type_declarator.type = TYPEDEC_ID;
2311 $$->u.type_declarator.u.id = $1->s;
2313 | LPAREN abstract_declarator RPAREN
2315 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2316 $$->u.type_declarator.type = TYPEDEC_NESTED;
2317 $$->u.type_declarator.u.nested.type_declarator = $2;
2319 | direct_abstract_declarator LSBRAC unary_expression RSBRAC
2321 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2322 $$->u.type_declarator.type = TYPEDEC_NESTED;
2323 $$->u.type_declarator.u.nested.type_declarator = $1;
2324 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2325 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2327 | direct_abstract_declarator LSBRAC RSBRAC
2329 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2330 $$->u.type_declarator.type = TYPEDEC_NESTED;
2331 $$->u.type_declarator.u.nested.type_declarator = $1;
2332 $$->u.type_declarator.u.nested.abstract_array = 1;
2336 alias_abstract_declarator_list:
2337 alias_abstract_declarator
2339 | alias_abstract_declarator_list COMMA alias_abstract_declarator
2342 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2346 alias_abstract_declarator:
2347 direct_alias_abstract_declarator
2349 | pointer direct_alias_abstract_declarator
2352 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2356 direct_alias_abstract_declarator:
2359 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2360 $$->u.type_declarator.type = TYPEDEC_ID;
2363 | LPAREN alias_abstract_declarator RPAREN
2365 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2366 $$->u.type_declarator.type = TYPEDEC_NESTED;
2367 $$->u.type_declarator.u.nested.type_declarator = $2;
2369 | direct_alias_abstract_declarator LSBRAC unary_expression RSBRAC
2371 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2372 $$->u.type_declarator.type = TYPEDEC_NESTED;
2373 $$->u.type_declarator.u.nested.type_declarator = $1;
2374 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2375 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2377 | direct_alias_abstract_declarator LSBRAC RSBRAC
2379 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2380 $$->u.type_declarator.type = TYPEDEC_NESTED;
2381 $$->u.type_declarator.u.nested.type_declarator = $1;
2382 $$->u.type_declarator.u.nested.abstract_array = 1;
2389 | pointer direct_declarator
2392 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2399 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2400 $$->u.type_declarator.type = TYPEDEC_ID;
2401 $$->u.type_declarator.u.id = $1->s;
2403 | LPAREN declarator RPAREN
2405 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2406 $$->u.type_declarator.type = TYPEDEC_NESTED;
2407 $$->u.type_declarator.u.nested.type_declarator = $2;
2409 | direct_declarator LSBRAC unary_expression RSBRAC
2411 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2412 $$->u.type_declarator.type = TYPEDEC_NESTED;
2413 $$->u.type_declarator.u.nested.type_declarator = $1;
2414 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2415 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2420 direct_type_declarator
2422 | pointer direct_type_declarator
2425 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2429 direct_type_declarator:
2432 add_type(scanner, $1);
2433 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2434 $$->u.type_declarator.type = TYPEDEC_ID;
2435 $$->u.type_declarator.u.id = $1->s;
2437 | LPAREN type_declarator RPAREN
2439 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2440 $$->u.type_declarator.type = TYPEDEC_NESTED;
2441 $$->u.type_declarator.u.nested.type_declarator = $2;
2443 | direct_type_declarator LSBRAC unary_expression RSBRAC
2445 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2446 $$->u.type_declarator.type = TYPEDEC_NESTED;
2447 $$->u.type_declarator.u.nested.type_declarator = $1;
2448 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2449 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2456 $$ = make_node(scanner, NODE_POINTER);
2460 $$ = make_node(scanner, NODE_POINTER);
2461 bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
2463 | STAR type_qualifier_list pointer
2465 $$ = make_node(scanner, NODE_POINTER);
2466 $$->u.pointer.const_qualifier = 1;
2467 bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
2471 type_qualifier_list:
2472 /* pointer assumes only const type qualifier */
2474 | type_qualifier_list CONST
2477 /* 2.3: CTF-specific declarations */
2479 ctf_assignment_expression_list:
2480 ctf_assignment_expression SEMICOLON
2482 | ctf_assignment_expression_list ctf_assignment_expression SEMICOLON
2485 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2489 ctf_assignment_expression:
2490 unary_expression EQUAL unary_expression
2493 * Because we have left and right, cannot use
2496 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2497 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2498 if ($1->u.unary_expression.type != UNARY_STRING)
2499 reparent_error(scanner, "ctf_assignment_expression left expects string");
2500 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
2502 | unary_expression TYPEASSIGN declaration_specifiers /* Only allow struct */
2505 * Because we have left and right, cannot use
2508 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2509 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2510 if ($1->u.unary_expression.type != UNARY_STRING)
2511 reparent_error(scanner, "ctf_assignment_expression left expects string");
2512 bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
2514 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list
2516 struct ctf_node *list;
2518 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2519 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2520 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2521 $$ = make_node(scanner, NODE_TYPEDEF);
2522 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2523 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
2525 | TYPEDEF declaration_specifiers type_declarator_list
2527 struct ctf_node *list;
2529 $$ = make_node(scanner, NODE_TYPEDEF);
2530 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2531 $$->u._typedef.type_specifier_list = list;
2532 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2533 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2535 | declaration_specifiers TYPEDEF type_declarator_list
2537 struct ctf_node *list;
2539 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2540 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2541 $$ = make_node(scanner, NODE_TYPEDEF);
2542 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2543 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2545 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
2547 struct ctf_node *list;
2549 $$ = make_node(scanner, NODE_TYPEALIAS);
2550 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2551 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2553 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2554 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
2555 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2556 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
2558 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2559 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
2560 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2561 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);