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
36 #include <babeltrace/list.h>
37 #include <babeltrace/babeltrace-internal.h>
38 #include "ctf-scanner.h"
39 #include "ctf-parser.h"
45 /* Join two lists, put "add" at the end of "head". */
47 _bt_list_splice_tail (struct bt_list_head *add, struct bt_list_head *head)
49 /* Do nothing if the list which gets added is empty. */
50 if (add != add->next) {
51 add->next->prev = head->prev;
52 add->prev->next = head;
53 head->prev->next = add->next;
54 head->prev = add->prev;
59 int yyparse(struct ctf_scanner *scanner);
61 int yylex(union YYSTYPE *yyval, struct ctf_scanner *scanner);
63 int yylex_init_extra(struct ctf_scanner *scanner, yyscan_t * ptr_yy_globals);
65 int yylex_destroy(yyscan_t yyscanner);
67 void yyrestart(FILE * in_str, yyscan_t scanner);
69 int yyget_lineno(yyscan_t yyscanner);
71 char *yyget_text(yyscan_t yyscanner);
74 struct bt_list_head gc;
79 static const char *node_type_to_str[] = {
80 #define ENTRY(S) [S] = #S,
81 FOREACH_CTF_NODES(ENTRY)
86 const char *node_type(struct ctf_node *node)
88 if (node->type < NR_NODE_TYPES)
89 return node_type_to_str[node->type];
94 static struct gc_string *gc_string_alloc(struct ctf_scanner *scanner,
97 struct gc_string *gstr;
100 /* TODO: could be faster with find first bit or glib Gstring */
101 /* sizeof long to account for malloc header (int or long ?) */
102 for (alloclen = 8; alloclen < sizeof(long) + sizeof(*gstr) + len;
105 gstr = malloc(alloclen);
106 bt_list_add(&gstr->gc, &scanner->allocated_strings);
107 gstr->alloclen = alloclen;
112 * note: never use gc_string_append on a string that has external references.
113 * gsrc will be garbage collected immediately, and gstr might be.
114 * Should only be used to append characters to a string literal or constant.
117 struct gc_string *gc_string_append(struct ctf_scanner *scanner,
118 struct gc_string *gstr,
119 struct gc_string *gsrc)
121 size_t newlen = strlen(gsrc->s) + strlen(gstr->s) + 1;
124 /* TODO: could be faster with find first bit or glib Gstring */
125 /* sizeof long to account for malloc header (int or long ?) */
126 for (alloclen = 8; alloclen < sizeof(long) + sizeof(*gstr) + newlen;
129 if (alloclen > gstr->alloclen) {
130 struct gc_string *newgstr;
132 newgstr = gc_string_alloc(scanner, newlen);
133 strcpy(newgstr->s, gstr->s);
134 strcat(newgstr->s, gsrc->s);
135 bt_list_del(&gstr->gc);
139 strcat(gstr->s, gsrc->s);
141 bt_list_del(&gsrc->gc);
146 void setstring(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src)
148 lvalp->gs = gc_string_alloc(scanner, strlen(src) + 1);
149 strcpy(lvalp->gs->s, src);
152 static void init_scope(struct ctf_scanner_scope *scope,
153 struct ctf_scanner_scope *parent)
155 scope->parent = parent;
156 scope->types = g_hash_table_new_full(g_str_hash, g_str_equal,
160 static void finalize_scope(struct ctf_scanner_scope *scope)
162 g_hash_table_destroy(scope->types);
165 static void push_scope(struct ctf_scanner *scanner)
167 struct ctf_scanner_scope *ns;
169 printf_debug("push scope\n");
170 ns = malloc(sizeof(struct ctf_scanner_scope));
171 init_scope(ns, scanner->cs);
175 static void pop_scope(struct ctf_scanner *scanner)
177 struct ctf_scanner_scope *os;
179 printf_debug("pop scope\n");
181 scanner->cs = os->parent;
186 static int lookup_type(struct ctf_scanner_scope *s, const char *id)
190 ret = (int) (long) g_hash_table_lookup(s->types, id);
191 printf_debug("lookup %p %s %d\n", s, id, ret);
196 int is_type(struct ctf_scanner *scanner, const char *id)
198 struct ctf_scanner_scope *it;
201 for (it = scanner->cs; it != NULL; it = it->parent) {
202 if (lookup_type(it, id)) {
207 printf_debug("is type %s %d\n", id, ret);
211 static void add_type(struct ctf_scanner *scanner, struct gc_string *id)
213 printf_debug("add type %s\n", id->s);
214 if (lookup_type(scanner->cs, id->s))
216 g_hash_table_insert(scanner->cs->types, id->s, id->s);
219 static struct ctf_node *make_node(struct ctf_scanner *scanner,
222 struct ctf_ast *ast = ctf_scanner_get_ast(scanner);
223 struct ctf_node *node;
225 node = malloc(sizeof(*node));
228 memset(node, 0, sizeof(*node));
230 node->lineno = yyget_lineno(scanner->scanner);
231 BT_INIT_LIST_HEAD(&node->tmp_head);
232 bt_list_add(&node->gc, &ast->allocated_nodes);
233 bt_list_add(&node->siblings, &node->tmp_head);
237 printfn_fatal(node, "trying to create root node");
241 BT_INIT_LIST_HEAD(&node->u.event.declaration_list);
244 BT_INIT_LIST_HEAD(&node->u.stream.declaration_list);
247 BT_INIT_LIST_HEAD(&node->u.env.declaration_list);
250 BT_INIT_LIST_HEAD(&node->u.trace.declaration_list);
253 BT_INIT_LIST_HEAD(&node->u.clock.declaration_list);
256 BT_INIT_LIST_HEAD(&node->u.callsite.declaration_list);
259 case NODE_CTF_EXPRESSION:
260 BT_INIT_LIST_HEAD(&node->u.ctf_expression.left);
261 BT_INIT_LIST_HEAD(&node->u.ctf_expression.right);
263 case NODE_UNARY_EXPRESSION:
267 BT_INIT_LIST_HEAD(&node->u._typedef.type_declarators);
269 case NODE_TYPEALIAS_TARGET:
270 BT_INIT_LIST_HEAD(&node->u.typealias_target.type_declarators);
272 case NODE_TYPEALIAS_ALIAS:
273 BT_INIT_LIST_HEAD(&node->u.typealias_alias.type_declarators);
278 case NODE_TYPE_SPECIFIER:
280 case NODE_TYPE_SPECIFIER_LIST:
281 BT_INIT_LIST_HEAD(&node->u.type_specifier_list.head);
285 case NODE_TYPE_DECLARATOR:
286 BT_INIT_LIST_HEAD(&node->u.type_declarator.pointers);
289 case NODE_FLOATING_POINT:
290 BT_INIT_LIST_HEAD(&node->u.floating_point.expressions);
293 BT_INIT_LIST_HEAD(&node->u.integer.expressions);
296 BT_INIT_LIST_HEAD(&node->u.string.expressions);
298 case NODE_ENUMERATOR:
299 BT_INIT_LIST_HEAD(&node->u.enumerator.values);
302 BT_INIT_LIST_HEAD(&node->u._enum.enumerator_list);
304 case NODE_STRUCT_OR_VARIANT_DECLARATION:
305 BT_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.type_declarators);
308 BT_INIT_LIST_HEAD(&node->u.variant.declaration_list);
311 BT_INIT_LIST_HEAD(&node->u._struct.declaration_list);
312 BT_INIT_LIST_HEAD(&node->u._struct.min_align);
317 printfn_fatal(node, "unknown node type '%d'", (int) type);
324 static int reparent_ctf_expression(struct ctf_node *node,
325 struct ctf_node *parent)
327 switch (parent->type) {
329 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
332 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
335 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
338 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
341 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
344 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
346 case NODE_FLOATING_POINT:
347 _bt_list_splice_tail(&node->tmp_head, &parent->u.floating_point.expressions);
350 _bt_list_splice_tail(&node->tmp_head, &parent->u.integer.expressions);
353 _bt_list_splice_tail(&node->tmp_head, &parent->u.string.expressions);
357 case NODE_CTF_EXPRESSION:
359 case NODE_TYPEALIAS_TARGET:
360 case NODE_TYPEALIAS_ALIAS:
362 case NODE_TYPE_SPECIFIER:
363 case NODE_TYPE_SPECIFIER_LIST:
365 case NODE_TYPE_DECLARATOR:
366 case NODE_ENUMERATOR:
368 case NODE_STRUCT_OR_VARIANT_DECLARATION:
371 case NODE_UNARY_EXPRESSION:
376 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
382 static int reparent_typedef(struct ctf_node *node, struct ctf_node *parent)
384 switch (parent->type) {
386 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
389 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
392 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
395 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
398 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
401 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
404 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
407 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
410 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
413 case NODE_FLOATING_POINT:
416 case NODE_CTF_EXPRESSION:
418 case NODE_TYPEALIAS_TARGET:
419 case NODE_TYPEALIAS_ALIAS:
421 case NODE_TYPE_SPECIFIER:
422 case NODE_TYPE_SPECIFIER_LIST:
424 case NODE_TYPE_DECLARATOR:
425 case NODE_ENUMERATOR:
427 case NODE_STRUCT_OR_VARIANT_DECLARATION:
428 case NODE_UNARY_EXPRESSION:
433 printfn_fatal(node, "unknown node type %d", parent->type);
439 static int reparent_typealias(struct ctf_node *node, struct ctf_node *parent)
441 switch (parent->type) {
443 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
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);
464 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
467 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
470 case NODE_FLOATING_POINT:
473 case NODE_CTF_EXPRESSION:
475 case NODE_TYPEALIAS_TARGET:
476 case NODE_TYPEALIAS_ALIAS:
478 case NODE_TYPE_SPECIFIER:
479 case NODE_TYPE_SPECIFIER_LIST:
481 case NODE_TYPE_DECLARATOR:
482 case NODE_ENUMERATOR:
484 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_type_specifier(struct ctf_node *node,
497 struct ctf_node *parent)
499 switch (parent->type) {
500 case NODE_TYPE_SPECIFIER_LIST:
501 _bt_list_splice_tail(&node->tmp_head, &parent->u.type_specifier_list.head);
504 case NODE_TYPE_SPECIFIER:
514 case NODE_TYPEALIAS_TARGET:
515 case NODE_TYPEALIAS_ALIAS:
516 case NODE_TYPE_DECLARATOR:
518 case NODE_STRUCT_OR_VARIANT_DECLARATION:
520 case NODE_FLOATING_POINT:
523 case NODE_CTF_EXPRESSION:
525 case NODE_ENUMERATOR:
526 case NODE_UNARY_EXPRESSION:
531 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
537 static int reparent_type_specifier_list(struct ctf_node *node,
538 struct ctf_node *parent)
540 switch (parent->type) {
542 bt_list_add_tail(&node->siblings, &parent->u.root.declaration_list);
545 bt_list_add_tail(&node->siblings, &parent->u.event.declaration_list);
548 bt_list_add_tail(&node->siblings, &parent->u.stream.declaration_list);
551 bt_list_add_tail(&node->siblings, &parent->u.env.declaration_list);
554 bt_list_add_tail(&node->siblings, &parent->u.trace.declaration_list);
557 bt_list_add_tail(&node->siblings, &parent->u.clock.declaration_list);
560 bt_list_add_tail(&node->siblings, &parent->u.callsite.declaration_list);
563 bt_list_add_tail(&node->siblings, &parent->u.variant.declaration_list);
566 bt_list_add_tail(&node->siblings, &parent->u._struct.declaration_list);
569 parent->u._typedef.type_specifier_list = node;
571 case NODE_TYPEALIAS_TARGET:
572 parent->u.typealias_target.type_specifier_list = node;
574 case NODE_TYPEALIAS_ALIAS:
575 parent->u.typealias_alias.type_specifier_list = node;
578 parent->u._enum.container_type = node;
580 case NODE_STRUCT_OR_VARIANT_DECLARATION:
581 parent->u.struct_or_variant_declaration.type_specifier_list = node;
583 case NODE_TYPE_DECLARATOR:
584 case NODE_TYPE_SPECIFIER:
586 case NODE_FLOATING_POINT:
589 case NODE_CTF_EXPRESSION:
591 case NODE_ENUMERATOR:
592 case NODE_UNARY_EXPRESSION:
597 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
603 static int reparent_type_declarator(struct ctf_node *node,
604 struct ctf_node *parent)
606 switch (parent->type) {
607 case NODE_TYPE_DECLARATOR:
608 parent->u.type_declarator.type = TYPEDEC_NESTED;
609 parent->u.type_declarator.u.nested.type_declarator = node;
611 case NODE_STRUCT_OR_VARIANT_DECLARATION:
612 _bt_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.type_declarators);
615 _bt_list_splice_tail(&node->tmp_head, &parent->u._typedef.type_declarators);
617 case NODE_TYPEALIAS_TARGET:
618 _bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_target.type_declarators);
620 case NODE_TYPEALIAS_ALIAS:
621 _bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_alias.type_declarators);
635 case NODE_FLOATING_POINT:
638 case NODE_CTF_EXPRESSION:
639 case NODE_TYPE_SPECIFIER:
640 case NODE_TYPE_SPECIFIER_LIST:
642 case NODE_ENUMERATOR:
643 case NODE_UNARY_EXPRESSION:
648 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
657 * Link node to parent. Returns 0 on success, -EPERM if it is not permitted to
658 * create the link declared by the input, -ENOENT if node or parent is NULL,
659 * -EINVAL if there is an internal structure problem.
661 static int set_parent_node(struct ctf_node *node,
662 struct ctf_node *parent)
664 if (!node || !parent)
667 /* Note: Linking to parent will be done only by an external visitor */
669 switch (node->type) {
671 printfn_fatal(node, "trying to reparent root node");
675 if (parent->type == NODE_ROOT) {
676 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.event);
682 if (parent->type == NODE_ROOT) {
683 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.stream);
689 if (parent->type == NODE_ROOT) {
690 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.env);
696 if (parent->type == NODE_ROOT) {
697 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.trace);
703 if (parent->type == NODE_ROOT) {
704 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.clock);
710 if (parent->type == NODE_ROOT) {
711 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.callsite);
717 case NODE_CTF_EXPRESSION:
718 return reparent_ctf_expression(node, parent);
719 case NODE_UNARY_EXPRESSION:
720 if (parent->type == NODE_TYPE_DECLARATOR)
721 parent->u.type_declarator.bitfield_len = node;
727 return reparent_typedef(node, parent);
728 case NODE_TYPEALIAS_TARGET:
729 if (parent->type == NODE_TYPEALIAS)
730 parent->u.typealias.target = node;
733 case NODE_TYPEALIAS_ALIAS:
734 if (parent->type == NODE_TYPEALIAS)
735 parent->u.typealias.alias = node;
739 return reparent_typealias(node, parent);
742 if (parent->type == NODE_TYPE_DECLARATOR) {
743 _bt_list_splice_tail(&node->tmp_head, &parent->u.type_declarator.pointers);
747 case NODE_TYPE_DECLARATOR:
748 return reparent_type_declarator(node, parent);
750 case NODE_TYPE_SPECIFIER_LIST:
751 return reparent_type_specifier_list(node, parent);
753 case NODE_TYPE_SPECIFIER:
754 return reparent_type_specifier(node, parent);
756 case NODE_FLOATING_POINT:
762 return -EINVAL; /* Dealt with internally within grammar */
764 case NODE_ENUMERATOR:
765 if (parent->type == NODE_ENUM) {
766 _bt_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
771 case NODE_STRUCT_OR_VARIANT_DECLARATION:
772 switch (parent->type) {
774 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
777 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
786 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
793 void yyerror(struct ctf_scanner *scanner, const char *str)
795 printfl_error(yyget_lineno(scanner->scanner),
796 "token \"%s\": %s\n",
797 yyget_text(scanner->scanner), str);
806 #define reparent_error(scanner, str) \
808 yyerror(scanner, YY_("reparent_error: " str)); \
812 static void free_strings(struct bt_list_head *list)
814 struct gc_string *gstr, *tmp;
816 bt_list_for_each_entry_safe(gstr, tmp, list, gc)
820 static struct ctf_ast *ctf_ast_alloc(void)
824 ast = malloc(sizeof(*ast));
827 memset(ast, 0, sizeof(*ast));
828 BT_INIT_LIST_HEAD(&ast->allocated_nodes);
829 ast->root.type = NODE_ROOT;
830 BT_INIT_LIST_HEAD(&ast->root.tmp_head);
831 BT_INIT_LIST_HEAD(&ast->root.u.root.declaration_list);
832 BT_INIT_LIST_HEAD(&ast->root.u.root.trace);
833 BT_INIT_LIST_HEAD(&ast->root.u.root.env);
834 BT_INIT_LIST_HEAD(&ast->root.u.root.stream);
835 BT_INIT_LIST_HEAD(&ast->root.u.root.event);
836 BT_INIT_LIST_HEAD(&ast->root.u.root.clock);
837 BT_INIT_LIST_HEAD(&ast->root.u.root.callsite);
841 static void ctf_ast_free(struct ctf_ast *ast)
843 struct ctf_node *node, *tmp;
845 bt_list_for_each_entry_safe(node, tmp, &ast->allocated_nodes, gc)
850 int ctf_scanner_append_ast(struct ctf_scanner *scanner)
852 return yyparse(scanner);
855 struct ctf_scanner *ctf_scanner_alloc(FILE *input)
857 struct ctf_scanner *scanner;
860 yydebug = babeltrace_debug;
862 scanner = malloc(sizeof(*scanner));
865 memset(scanner, 0, sizeof(*scanner));
867 ret = yylex_init_extra(scanner, &scanner->scanner);
869 printf_fatal("yylex_init error");
870 goto cleanup_scanner;
872 /* Start processing new stream */
873 yyrestart(input, scanner->scanner);
875 scanner->ast = ctf_ast_alloc();
878 init_scope(&scanner->root_scope, NULL);
879 scanner->cs = &scanner->root_scope;
880 BT_INIT_LIST_HEAD(&scanner->allocated_strings);
883 fprintf(stdout, "Scanner input is a%s.\n",
884 isatty(fileno(input)) ? "n interactive tty" :
885 " noninteractive file");
890 ret = yylex_destroy(scanner->scanner);
892 printf_fatal("yylex_destroy error");
898 void ctf_scanner_free(struct ctf_scanner *scanner)
902 finalize_scope(&scanner->root_scope);
903 free_strings(&scanner->allocated_strings);
904 ctf_ast_free(scanner->ast);
905 ret = yylex_destroy(scanner->scanner);
907 printf_error("yylex_destroy error");
916 %parse-param {struct ctf_scanner *scanner}
917 %lex-param {struct ctf_scanner *scanner}
919 * Expect two shift-reduce conflicts. Caused by enum name-opt : type {}
920 * vs struct { int :value; } (unnamed bit-field). The default is to
921 * shift, so whenever we encounter an enumeration, we are doing the
922 * proper thing (shift). It is illegal to declare an enumeration
923 * "bit-field", so it is OK if this situation ends up in a parsing
928 %token CHARACTER_CONSTANT_START SQUOTE STRING_LITERAL_START DQUOTE ESCSEQ CHAR_STRING_TOKEN LSBRAC RSBRAC LPAREN RPAREN LBRAC RBRAC RARROW STAR PLUS MINUS LT GT TYPEASSIGN COLON SEMICOLON DOTDOTDOT DOT EQUAL COMMA CONST CHAR DOUBLE ENUM ENV EVENT FLOATING_POINT FLOAT INTEGER INT LONG SHORT SIGNED STREAM STRING STRUCT TRACE CALLSITE CLOCK TYPEALIAS TYPEDEF UNSIGNED VARIANT VOID _BOOL _COMPLEX _IMAGINARY DECIMAL_CONSTANT OCTAL_CONSTANT HEXADECIMAL_CONSTANT TOK_ALIGN
929 %token <gs> IDENTIFIER ID_TYPE
935 struct gc_string *gs;
940 %type <gs> s_char s_char_sequence c_char c_char_sequence
942 %type <n> postfix_expression unary_expression unary_expression_or_range
944 %type <n> declaration
945 %type <n> event_declaration
946 %type <n> stream_declaration
947 %type <n> env_declaration
948 %type <n> trace_declaration
949 %type <n> clock_declaration
950 %type <n> callsite_declaration
951 %type <n> integer_declaration_specifiers
952 %type <n> declaration_specifiers
953 %type <n> alias_declaration_specifiers
955 %type <n> type_declarator_list
956 %type <n> integer_type_specifier
957 %type <n> type_specifier
958 %type <n> struct_type_specifier
959 %type <n> variant_type_specifier
960 %type <n> enum_type_specifier
961 %type <n> struct_or_variant_declaration_list
962 %type <n> struct_or_variant_declaration
963 %type <n> struct_or_variant_declarator_list
964 %type <n> struct_or_variant_declarator
965 %type <n> enumerator_list
967 %type <n> abstract_declarator_list
968 %type <n> abstract_declarator
969 %type <n> direct_abstract_declarator
970 %type <n> alias_abstract_declarator_list
971 %type <n> alias_abstract_declarator
972 %type <n> direct_alias_abstract_declarator
974 %type <n> direct_declarator
975 %type <n> type_declarator
976 %type <n> direct_type_declarator
978 %type <n> ctf_assignment_expression_list
979 %type <n> ctf_assignment_expression
986 if (set_parent_node($1, &ctf_scanner_get_ast(scanner)->root))
987 reparent_error(scanner, "error reparenting to root");
991 if (set_parent_node($2, &ctf_scanner_get_ast(scanner)->root))
992 reparent_error(scanner, "error reparenting to root");
1058 | c_char_sequence c_char
1059 { $$ = gc_string_append(scanner, $1, $2); }
1067 reparent_error(scanner, "escape sequences not supported yet");
1071 /* 1.6 String literals */
1076 | s_char_sequence s_char
1077 { $$ = gc_string_append(scanner, $1, $2); }
1085 reparent_error(scanner, "escape sequences not supported yet");
1089 /* 2: Phrase structure grammar */
1094 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1095 $$->u.unary_expression.type = UNARY_STRING;
1096 $$->u.unary_expression.u.string = yylval.gs->s;
1100 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1101 $$->u.unary_expression.type = UNARY_STRING;
1102 $$->u.unary_expression.u.string = yylval.gs->s;
1106 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1107 $$->u.unary_expression.type = UNARY_STRING;
1108 $$->u.unary_expression.u.string = yylval.gs->s;
1112 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1113 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1114 sscanf(yylval.gs->s, "%" PRIu64,
1115 &$$->u.unary_expression.u.unsigned_constant);
1119 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1120 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1121 sscanf(yylval.gs->s, "0%" PRIo64,
1122 &$$->u.unary_expression.u.unsigned_constant);
1124 | HEXADECIMAL_CONSTANT
1126 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1127 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1128 sscanf(yylval.gs->s, "0x%" PRIx64,
1129 &$$->u.unary_expression.u.unsigned_constant);
1131 | STRING_LITERAL_START DQUOTE
1133 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1134 $$->u.unary_expression.type = UNARY_STRING;
1135 $$->u.unary_expression.u.string = "";
1137 | STRING_LITERAL_START s_char_sequence DQUOTE
1139 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1140 $$->u.unary_expression.type = UNARY_STRING;
1141 $$->u.unary_expression.u.string = $2->s;
1143 | CHARACTER_CONSTANT_START c_char_sequence SQUOTE
1145 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1146 $$->u.unary_expression.type = UNARY_STRING;
1147 $$->u.unary_expression.u.string = $2->s;
1149 | LPAREN unary_expression RPAREN
1151 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1152 $$->u.unary_expression.type = UNARY_NESTED;
1153 $$->u.unary_expression.u.nested_exp = $2;
1155 | postfix_expression LSBRAC unary_expression RSBRAC
1157 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1158 $$->u.unary_expression.type = UNARY_SBRAC;
1159 $$->u.unary_expression.u.sbrac_exp = $3;
1160 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1161 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1163 | postfix_expression DOT IDENTIFIER
1165 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1166 $$->u.unary_expression.type = UNARY_STRING;
1167 $$->u.unary_expression.u.string = yylval.gs->s;
1168 $$->u.unary_expression.link = UNARY_DOTLINK;
1169 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1170 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1172 | postfix_expression DOT ID_TYPE
1174 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1175 $$->u.unary_expression.type = UNARY_STRING;
1176 $$->u.unary_expression.u.string = yylval.gs->s;
1177 $$->u.unary_expression.link = UNARY_DOTLINK;
1178 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1179 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1181 | postfix_expression RARROW IDENTIFIER
1183 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1184 $$->u.unary_expression.type = UNARY_STRING;
1185 $$->u.unary_expression.u.string = yylval.gs->s;
1186 $$->u.unary_expression.link = UNARY_ARROWLINK;
1187 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1188 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1190 | postfix_expression RARROW ID_TYPE
1192 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1193 $$->u.unary_expression.type = UNARY_STRING;
1194 $$->u.unary_expression.u.string = yylval.gs->s;
1195 $$->u.unary_expression.link = UNARY_ARROWLINK;
1196 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1197 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1204 | PLUS postfix_expression
1207 if ($$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
1208 && $$->u.unary_expression.type != UNARY_SIGNED_CONSTANT) {
1209 reparent_error(scanner, "expecting numeric constant");
1212 | MINUS postfix_expression
1215 if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1216 $$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
1217 $$->u.unary_expression.u.signed_constant =
1218 -($$->u.unary_expression.u.unsigned_constant);
1219 } else if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1220 $$->u.unary_expression.u.signed_constant =
1221 -($$->u.unary_expression.u.signed_constant);
1223 reparent_error(scanner, "expecting numeric constant");
1228 unary_expression_or_range:
1229 unary_expression DOTDOTDOT unary_expression
1232 _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
1233 $3->u.unary_expression.link = UNARY_DOTDOTDOT;
1239 /* 2.2: Declarations */
1242 declaration_specifiers SEMICOLON
1246 | stream_declaration
1254 | callsite_declaration
1256 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
1258 struct ctf_node *list;
1260 $$ = make_node(scanner, NODE_TYPEDEF);
1261 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1262 $$->u._typedef.type_specifier_list = list;
1263 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1264 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1265 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
1267 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
1269 struct ctf_node *list;
1271 $$ = make_node(scanner, NODE_TYPEDEF);
1272 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1273 $$->u._typedef.type_specifier_list = list;
1274 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1275 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
1277 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
1279 struct ctf_node *list;
1281 $$ = make_node(scanner, NODE_TYPEDEF);
1282 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1283 $$->u._typedef.type_specifier_list = list;
1284 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1285 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
1287 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
1289 struct ctf_node *list;
1291 $$ = make_node(scanner, NODE_TYPEALIAS);
1292 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1293 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1295 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1296 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
1297 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1298 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
1300 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1301 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
1302 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1303 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
1308 event_declaration_begin event_declaration_end
1310 $$ = make_node(scanner, NODE_EVENT);
1312 | event_declaration_begin ctf_assignment_expression_list event_declaration_end
1314 $$ = make_node(scanner, NODE_EVENT);
1315 if (set_parent_node($2, $$))
1316 reparent_error(scanner, "event_declaration");
1320 event_declaration_begin:
1322 { push_scope(scanner); }
1325 event_declaration_end:
1327 { pop_scope(scanner); }
1332 stream_declaration_begin stream_declaration_end
1334 $$ = make_node(scanner, NODE_STREAM);
1336 | stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
1338 $$ = make_node(scanner, NODE_STREAM);
1339 if (set_parent_node($2, $$))
1340 reparent_error(scanner, "stream_declaration");
1344 stream_declaration_begin:
1346 { push_scope(scanner); }
1349 stream_declaration_end:
1351 { pop_scope(scanner); }
1355 env_declaration_begin env_declaration_end
1357 $$ = make_node(scanner, NODE_ENV);
1359 | env_declaration_begin ctf_assignment_expression_list env_declaration_end
1361 $$ = make_node(scanner, NODE_ENV);
1362 if (set_parent_node($2, $$))
1363 reparent_error(scanner, "env declaration");
1367 env_declaration_begin:
1369 { push_scope(scanner); }
1372 env_declaration_end:
1374 { pop_scope(scanner); }
1378 trace_declaration_begin trace_declaration_end
1380 $$ = make_node(scanner, NODE_TRACE);
1382 | trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
1384 $$ = make_node(scanner, NODE_TRACE);
1385 if (set_parent_node($2, $$))
1386 reparent_error(scanner, "trace_declaration");
1390 trace_declaration_begin:
1392 { push_scope(scanner); }
1395 trace_declaration_end:
1397 { pop_scope(scanner); }
1401 CLOCK clock_declaration_begin clock_declaration_end
1403 $$ = make_node(scanner, NODE_CLOCK);
1405 | CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
1407 $$ = make_node(scanner, NODE_CLOCK);
1408 if (set_parent_node($3, $$))
1409 reparent_error(scanner, "trace_declaration");
1413 clock_declaration_begin:
1415 { push_scope(scanner); }
1418 clock_declaration_end:
1420 { pop_scope(scanner); }
1423 callsite_declaration:
1424 CALLSITE callsite_declaration_begin callsite_declaration_end
1426 $$ = make_node(scanner, NODE_CALLSITE);
1428 | CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
1430 $$ = make_node(scanner, NODE_CALLSITE);
1431 if (set_parent_node($3, $$))
1432 reparent_error(scanner, "trace_declaration");
1436 callsite_declaration_begin:
1438 { push_scope(scanner); }
1441 callsite_declaration_end:
1443 { pop_scope(scanner); }
1446 integer_declaration_specifiers:
1449 struct ctf_node *node;
1451 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1452 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1453 node->u.type_specifier.type = TYPESPEC_CONST;
1454 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1456 | integer_type_specifier
1458 struct ctf_node *node;
1460 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1462 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1464 | integer_declaration_specifiers CONST
1466 struct ctf_node *node;
1469 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1470 node->u.type_specifier.type = TYPESPEC_CONST;
1471 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1473 | integer_declaration_specifiers integer_type_specifier
1476 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
1480 declaration_specifiers:
1483 struct ctf_node *node;
1485 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1486 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1487 node->u.type_specifier.type = TYPESPEC_CONST;
1488 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1492 struct ctf_node *node;
1494 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1496 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1498 | declaration_specifiers CONST
1500 struct ctf_node *node;
1503 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1504 node->u.type_specifier.type = TYPESPEC_CONST;
1505 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1507 | declaration_specifiers type_specifier
1510 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
1514 type_declarator_list:
1517 | type_declarator_list COMMA type_declarator
1520 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1524 integer_type_specifier:
1527 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1528 $$->u.type_specifier.type = TYPESPEC_CHAR;
1532 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1533 $$->u.type_specifier.type = TYPESPEC_SHORT;
1537 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1538 $$->u.type_specifier.type = TYPESPEC_INT;
1542 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1543 $$->u.type_specifier.type = TYPESPEC_LONG;
1547 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1548 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1552 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1553 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1557 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1558 $$->u.type_specifier.type = TYPESPEC_BOOL;
1562 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1563 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
1564 $$->u.type_specifier.id_type = yylval.gs->s;
1566 | INTEGER LBRAC RBRAC
1568 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1569 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1570 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1572 | INTEGER LBRAC ctf_assignment_expression_list RBRAC
1574 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1575 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1576 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1577 if (set_parent_node($3, $$->u.type_specifier.node))
1578 reparent_error(scanner, "integer reparent error");
1585 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1586 $$->u.type_specifier.type = TYPESPEC_VOID;
1590 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1591 $$->u.type_specifier.type = TYPESPEC_CHAR;
1595 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1596 $$->u.type_specifier.type = TYPESPEC_SHORT;
1600 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1601 $$->u.type_specifier.type = TYPESPEC_INT;
1605 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1606 $$->u.type_specifier.type = TYPESPEC_LONG;
1610 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1611 $$->u.type_specifier.type = TYPESPEC_FLOAT;
1615 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1616 $$->u.type_specifier.type = TYPESPEC_DOUBLE;
1620 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1621 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1625 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1626 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1630 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1631 $$->u.type_specifier.type = TYPESPEC_BOOL;
1635 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1636 $$->u.type_specifier.type = TYPESPEC_COMPLEX;
1640 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1641 $$->u.type_specifier.type = TYPESPEC_IMAGINARY;
1645 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1646 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
1647 $$->u.type_specifier.id_type = yylval.gs->s;
1649 | FLOATING_POINT LBRAC RBRAC
1651 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1652 $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
1653 $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1655 | FLOATING_POINT LBRAC ctf_assignment_expression_list RBRAC
1657 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1658 $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
1659 $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1660 if (set_parent_node($3, $$->u.type_specifier.node))
1661 reparent_error(scanner, "floating point reparent error");
1663 | INTEGER LBRAC RBRAC
1665 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1666 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1667 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1669 | INTEGER LBRAC ctf_assignment_expression_list RBRAC
1671 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1672 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1673 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1674 if (set_parent_node($3, $$->u.type_specifier.node))
1675 reparent_error(scanner, "integer reparent error");
1679 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1680 $$->u.type_specifier.type = TYPESPEC_STRING;
1681 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1683 | STRING LBRAC RBRAC
1685 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1686 $$->u.type_specifier.type = TYPESPEC_STRING;
1687 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1689 | STRING LBRAC ctf_assignment_expression_list RBRAC
1691 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1692 $$->u.type_specifier.type = TYPESPEC_STRING;
1693 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1694 if (set_parent_node($3, $$->u.type_specifier.node))
1695 reparent_error(scanner, "string reparent error");
1697 | ENUM enum_type_specifier
1699 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1700 $$->u.type_specifier.type = TYPESPEC_ENUM;
1701 $$->u.type_specifier.node = $2;
1703 | VARIANT variant_type_specifier
1705 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1706 $$->u.type_specifier.type = TYPESPEC_VARIANT;
1707 $$->u.type_specifier.node = $2;
1709 | STRUCT struct_type_specifier
1711 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1712 $$->u.type_specifier.type = TYPESPEC_STRUCT;
1713 $$->u.type_specifier.node = $2;
1717 struct_type_specifier:
1718 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1720 $$ = make_node(scanner, NODE_STRUCT);
1721 $$->u._struct.has_body = 1;
1722 if ($2 && set_parent_node($2, $$))
1723 reparent_error(scanner, "struct reparent error");
1725 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1727 $$ = make_node(scanner, NODE_STRUCT);
1728 $$->u._struct.has_body = 1;
1729 $$->u._struct.name = $1->s;
1730 if ($3 && set_parent_node($3, $$))
1731 reparent_error(scanner, "struct reparent error");
1733 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1735 $$ = make_node(scanner, NODE_STRUCT);
1736 $$->u._struct.has_body = 1;
1737 $$->u._struct.name = $1->s;
1738 if ($3 && set_parent_node($3, $$))
1739 reparent_error(scanner, "struct reparent error");
1743 $$ = make_node(scanner, NODE_STRUCT);
1744 $$->u._struct.has_body = 0;
1745 $$->u._struct.name = $1->s;
1749 $$ = make_node(scanner, NODE_STRUCT);
1750 $$->u._struct.has_body = 0;
1751 $$->u._struct.name = $1->s;
1753 | struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1755 $$ = make_node(scanner, NODE_STRUCT);
1756 $$->u._struct.has_body = 1;
1757 bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
1758 if ($2 && set_parent_node($2, $$))
1759 reparent_error(scanner, "struct reparent error");
1761 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1763 $$ = make_node(scanner, NODE_STRUCT);
1764 $$->u._struct.has_body = 1;
1765 $$->u._struct.name = $1->s;
1766 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1767 if ($3 && set_parent_node($3, $$))
1768 reparent_error(scanner, "struct reparent error");
1770 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1772 $$ = make_node(scanner, NODE_STRUCT);
1773 $$->u._struct.has_body = 1;
1774 $$->u._struct.name = $1->s;
1775 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1776 if ($3 && set_parent_node($3, $$))
1777 reparent_error(scanner, "struct reparent error");
1781 struct_declaration_begin:
1783 { push_scope(scanner); }
1786 struct_declaration_end:
1788 { pop_scope(scanner); }
1791 variant_type_specifier:
1792 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1794 $$ = make_node(scanner, NODE_VARIANT);
1795 $$->u.variant.has_body = 1;
1796 if ($2 && set_parent_node($2, $$))
1797 reparent_error(scanner, "variant reparent error");
1799 | LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1801 $$ = make_node(scanner, NODE_VARIANT);
1802 $$->u.variant.has_body = 1;
1803 $$->u.variant.choice = $2->s;
1804 if ($5 && set_parent_node($5, $$))
1805 reparent_error(scanner, "variant reparent error");
1807 | LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1809 $$ = make_node(scanner, NODE_VARIANT);
1810 $$->u.variant.has_body = 1;
1811 $$->u.variant.choice = $2->s;
1812 if ($5 && set_parent_node($5, $$))
1813 reparent_error(scanner, "variant reparent error");
1815 | IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1817 $$ = make_node(scanner, NODE_VARIANT);
1818 $$->u.variant.has_body = 1;
1819 $$->u.variant.name = $1->s;
1820 if ($3 && set_parent_node($3, $$))
1821 reparent_error(scanner, "variant reparent error");
1823 | IDENTIFIER LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1825 $$ = make_node(scanner, NODE_VARIANT);
1826 $$->u.variant.has_body = 1;
1827 $$->u.variant.name = $1->s;
1828 $$->u.variant.choice = $3->s;
1829 if ($6 && set_parent_node($6, $$))
1830 reparent_error(scanner, "variant reparent error");
1832 | IDENTIFIER LT IDENTIFIER GT
1834 $$ = make_node(scanner, NODE_VARIANT);
1835 $$->u.variant.has_body = 0;
1836 $$->u.variant.name = $1->s;
1837 $$->u.variant.choice = $3->s;
1839 | IDENTIFIER LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1841 $$ = make_node(scanner, NODE_VARIANT);
1842 $$->u.variant.has_body = 1;
1843 $$->u.variant.name = $1->s;
1844 $$->u.variant.choice = $3->s;
1845 if ($6 && set_parent_node($6, $$))
1846 reparent_error(scanner, "variant reparent error");
1848 | IDENTIFIER LT ID_TYPE GT
1850 $$ = make_node(scanner, NODE_VARIANT);
1851 $$->u.variant.has_body = 0;
1852 $$->u.variant.name = $1->s;
1853 $$->u.variant.choice = $3->s;
1855 | ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1857 $$ = make_node(scanner, NODE_VARIANT);
1858 $$->u.variant.has_body = 1;
1859 $$->u.variant.name = $1->s;
1860 if ($3 && set_parent_node($3, $$))
1861 reparent_error(scanner, "variant reparent error");
1863 | ID_TYPE LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1865 $$ = make_node(scanner, NODE_VARIANT);
1866 $$->u.variant.has_body = 1;
1867 $$->u.variant.name = $1->s;
1868 $$->u.variant.choice = $3->s;
1869 if ($6 && set_parent_node($6, $$))
1870 reparent_error(scanner, "variant reparent error");
1872 | ID_TYPE LT IDENTIFIER GT
1874 $$ = make_node(scanner, NODE_VARIANT);
1875 $$->u.variant.has_body = 0;
1876 $$->u.variant.name = $1->s;
1877 $$->u.variant.choice = $3->s;
1879 | ID_TYPE LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1881 $$ = make_node(scanner, NODE_VARIANT);
1882 $$->u.variant.has_body = 1;
1883 $$->u.variant.name = $1->s;
1884 $$->u.variant.choice = $3->s;
1885 if ($6 && set_parent_node($6, $$))
1886 reparent_error(scanner, "variant reparent error");
1888 | ID_TYPE LT ID_TYPE GT
1890 $$ = make_node(scanner, NODE_VARIANT);
1891 $$->u.variant.has_body = 0;
1892 $$->u.variant.name = $1->s;
1893 $$->u.variant.choice = $3->s;
1897 variant_declaration_begin:
1899 { push_scope(scanner); }
1902 variant_declaration_end:
1904 { pop_scope(scanner); }
1907 enum_type_specifier:
1908 LBRAC enumerator_list RBRAC
1910 $$ = make_node(scanner, NODE_ENUM);
1911 $$->u._enum.has_body = 1;
1912 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
1914 | COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
1916 $$ = make_node(scanner, NODE_ENUM);
1917 $$->u._enum.has_body = 1;
1918 ($$)->u._enum.container_type = $2;
1919 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
1921 | IDENTIFIER LBRAC enumerator_list RBRAC
1923 $$ = make_node(scanner, NODE_ENUM);
1924 $$->u._enum.has_body = 1;
1925 $$->u._enum.enum_id = $1->s;
1926 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1928 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
1930 $$ = make_node(scanner, NODE_ENUM);
1931 $$->u._enum.has_body = 1;
1932 $$->u._enum.enum_id = $1->s;
1933 ($$)->u._enum.container_type = $3;
1934 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
1936 | ID_TYPE LBRAC enumerator_list RBRAC
1938 $$ = make_node(scanner, NODE_ENUM);
1939 $$->u._enum.has_body = 1;
1940 $$->u._enum.enum_id = $1->s;
1941 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1943 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
1945 $$ = make_node(scanner, NODE_ENUM);
1946 $$->u._enum.has_body = 1;
1947 $$->u._enum.enum_id = $1->s;
1948 ($$)->u._enum.container_type = $3;
1949 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
1951 | LBRAC enumerator_list COMMA RBRAC
1953 $$ = make_node(scanner, NODE_ENUM);
1954 $$->u._enum.has_body = 1;
1955 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
1957 | COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
1959 $$ = make_node(scanner, NODE_ENUM);
1960 $$->u._enum.has_body = 1;
1961 ($$)->u._enum.container_type = $2;
1962 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
1964 | IDENTIFIER LBRAC enumerator_list COMMA RBRAC
1966 $$ = make_node(scanner, NODE_ENUM);
1967 $$->u._enum.has_body = 1;
1968 $$->u._enum.enum_id = $1->s;
1969 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1971 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
1973 $$ = make_node(scanner, NODE_ENUM);
1974 $$->u._enum.has_body = 1;
1975 $$->u._enum.enum_id = $1->s;
1976 ($$)->u._enum.container_type = $3;
1977 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
1981 $$ = make_node(scanner, NODE_ENUM);
1982 $$->u._enum.has_body = 0;
1983 $$->u._enum.enum_id = $1->s;
1985 | ID_TYPE LBRAC enumerator_list COMMA RBRAC
1987 $$ = make_node(scanner, NODE_ENUM);
1988 $$->u._enum.has_body = 1;
1989 $$->u._enum.enum_id = $1->s;
1990 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1992 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
1994 $$ = make_node(scanner, NODE_ENUM);
1995 $$->u._enum.has_body = 1;
1996 $$->u._enum.enum_id = $1->s;
1997 ($$)->u._enum.container_type = $3;
1998 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2002 $$ = make_node(scanner, NODE_ENUM);
2003 $$->u._enum.has_body = 0;
2004 $$->u._enum.enum_id = $1->s;
2008 struct_or_variant_declaration_list:
2011 | struct_or_variant_declaration_list struct_or_variant_declaration
2015 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2018 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
2023 struct_or_variant_declaration:
2024 declaration_specifiers struct_or_variant_declarator_list SEMICOLON
2026 struct ctf_node *list;
2028 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2029 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2030 $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
2031 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2032 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
2034 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
2036 struct ctf_node *list;
2038 $$ = make_node(scanner, NODE_TYPEDEF);
2039 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2040 $$->u._typedef.type_specifier_list = list;
2041 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2042 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2043 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
2045 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
2047 struct ctf_node *list;
2049 $$ = make_node(scanner, NODE_TYPEDEF);
2050 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2051 $$->u._typedef.type_specifier_list = list;
2052 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2053 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2055 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
2057 struct ctf_node *list;
2059 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2060 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2061 $$ = make_node(scanner, NODE_TYPEDEF);
2062 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2063 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2065 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
2067 struct ctf_node *list;
2069 $$ = make_node(scanner, NODE_TYPEALIAS);
2070 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2071 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2073 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2074 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
2075 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2076 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
2078 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2079 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
2080 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2081 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
2085 alias_declaration_specifiers:
2088 struct ctf_node *node;
2090 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2091 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2092 node->u.type_specifier.type = TYPESPEC_CONST;
2093 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2097 struct ctf_node *node;
2099 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2101 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2105 struct ctf_node *node;
2107 add_type(scanner, $1);
2108 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2109 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2110 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
2111 node->u.type_specifier.id_type = yylval.gs->s;
2112 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2114 | alias_declaration_specifiers CONST
2116 struct ctf_node *node;
2119 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2120 node->u.type_specifier.type = TYPESPEC_CONST;
2121 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2123 | alias_declaration_specifiers type_specifier
2126 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
2128 | alias_declaration_specifiers IDENTIFIER
2130 struct ctf_node *node;
2132 add_type(scanner, $2);
2134 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2135 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
2136 node->u.type_specifier.id_type = yylval.gs->s;
2137 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
2141 struct_or_variant_declarator_list:
2142 struct_or_variant_declarator
2144 | struct_or_variant_declarator_list COMMA struct_or_variant_declarator
2147 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2151 struct_or_variant_declarator:
2154 | COLON unary_expression
2156 | declarator COLON unary_expression
2159 if (set_parent_node($3, $1))
2160 reparent_error(scanner, "struct_or_variant_declarator");
2167 | enumerator_list COMMA enumerator
2170 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2177 $$ = make_node(scanner, NODE_ENUMERATOR);
2178 $$->u.enumerator.id = $1->s;
2182 $$ = make_node(scanner, NODE_ENUMERATOR);
2183 $$->u.enumerator.id = $1->s;
2187 $$ = make_node(scanner, NODE_ENUMERATOR);
2188 $$->u.enumerator.id = $1->s;
2190 | STRING_LITERAL_START DQUOTE
2192 $$ = make_node(scanner, NODE_ENUMERATOR);
2193 $$->u.enumerator.id = "";
2195 | STRING_LITERAL_START s_char_sequence DQUOTE
2197 $$ = make_node(scanner, NODE_ENUMERATOR);
2198 $$->u.enumerator.id = $2->s;
2200 | IDENTIFIER EQUAL unary_expression_or_range
2202 $$ = make_node(scanner, NODE_ENUMERATOR);
2203 $$->u.enumerator.id = $1->s;
2204 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2206 | ID_TYPE EQUAL unary_expression_or_range
2208 $$ = make_node(scanner, NODE_ENUMERATOR);
2209 $$->u.enumerator.id = $1->s;
2210 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2212 | keywords EQUAL unary_expression_or_range
2214 $$ = make_node(scanner, NODE_ENUMERATOR);
2215 $$->u.enumerator.id = $1->s;
2216 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2218 | STRING_LITERAL_START DQUOTE EQUAL unary_expression_or_range
2220 $$ = make_node(scanner, NODE_ENUMERATOR);
2221 $$->u.enumerator.id = "";
2222 bt_list_splice(&($4)->tmp_head, &($$)->u.enumerator.values);
2224 | STRING_LITERAL_START s_char_sequence DQUOTE EQUAL unary_expression_or_range
2226 $$ = make_node(scanner, NODE_ENUMERATOR);
2227 $$->u.enumerator.id = $2->s;
2228 bt_list_splice(&($5)->tmp_head, &($$)->u.enumerator.values);
2232 abstract_declarator_list:
2235 | abstract_declarator_list COMMA abstract_declarator
2238 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2242 abstract_declarator:
2243 direct_abstract_declarator
2245 | pointer direct_abstract_declarator
2248 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2252 direct_abstract_declarator:
2255 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2256 $$->u.type_declarator.type = TYPEDEC_ID;
2261 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2262 $$->u.type_declarator.type = TYPEDEC_ID;
2263 $$->u.type_declarator.u.id = $1->s;
2265 | LPAREN abstract_declarator RPAREN
2267 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2268 $$->u.type_declarator.type = TYPEDEC_NESTED;
2269 $$->u.type_declarator.u.nested.type_declarator = $2;
2271 | direct_abstract_declarator LSBRAC unary_expression RSBRAC
2273 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2274 $$->u.type_declarator.type = TYPEDEC_NESTED;
2275 $$->u.type_declarator.u.nested.type_declarator = $1;
2276 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2277 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2279 | direct_abstract_declarator LSBRAC RSBRAC
2281 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2282 $$->u.type_declarator.type = TYPEDEC_NESTED;
2283 $$->u.type_declarator.u.nested.type_declarator = $1;
2284 $$->u.type_declarator.u.nested.abstract_array = 1;
2288 alias_abstract_declarator_list:
2289 alias_abstract_declarator
2291 | alias_abstract_declarator_list COMMA alias_abstract_declarator
2294 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2298 alias_abstract_declarator:
2299 direct_alias_abstract_declarator
2301 | pointer direct_alias_abstract_declarator
2304 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2308 direct_alias_abstract_declarator:
2311 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2312 $$->u.type_declarator.type = TYPEDEC_ID;
2315 | LPAREN alias_abstract_declarator RPAREN
2317 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2318 $$->u.type_declarator.type = TYPEDEC_NESTED;
2319 $$->u.type_declarator.u.nested.type_declarator = $2;
2321 | direct_alias_abstract_declarator LSBRAC unary_expression RSBRAC
2323 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2324 $$->u.type_declarator.type = TYPEDEC_NESTED;
2325 $$->u.type_declarator.u.nested.type_declarator = $1;
2326 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2327 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2329 | direct_alias_abstract_declarator LSBRAC RSBRAC
2331 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2332 $$->u.type_declarator.type = TYPEDEC_NESTED;
2333 $$->u.type_declarator.u.nested.type_declarator = $1;
2334 $$->u.type_declarator.u.nested.abstract_array = 1;
2341 | pointer direct_declarator
2344 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2351 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2352 $$->u.type_declarator.type = TYPEDEC_ID;
2353 $$->u.type_declarator.u.id = $1->s;
2355 | LPAREN declarator RPAREN
2357 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2358 $$->u.type_declarator.type = TYPEDEC_NESTED;
2359 $$->u.type_declarator.u.nested.type_declarator = $2;
2361 | direct_declarator LSBRAC unary_expression RSBRAC
2363 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2364 $$->u.type_declarator.type = TYPEDEC_NESTED;
2365 $$->u.type_declarator.u.nested.type_declarator = $1;
2366 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2367 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2372 direct_type_declarator
2374 | pointer direct_type_declarator
2377 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
2381 direct_type_declarator:
2384 add_type(scanner, $1);
2385 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2386 $$->u.type_declarator.type = TYPEDEC_ID;
2387 $$->u.type_declarator.u.id = $1->s;
2389 | LPAREN type_declarator RPAREN
2391 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2392 $$->u.type_declarator.type = TYPEDEC_NESTED;
2393 $$->u.type_declarator.u.nested.type_declarator = $2;
2395 | direct_type_declarator LSBRAC unary_expression RSBRAC
2397 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2398 $$->u.type_declarator.type = TYPEDEC_NESTED;
2399 $$->u.type_declarator.u.nested.type_declarator = $1;
2400 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2401 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
2408 $$ = make_node(scanner, NODE_POINTER);
2412 $$ = make_node(scanner, NODE_POINTER);
2413 bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
2415 | STAR type_qualifier_list pointer
2417 $$ = make_node(scanner, NODE_POINTER);
2418 $$->u.pointer.const_qualifier = 1;
2419 bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
2423 type_qualifier_list:
2424 /* pointer assumes only const type qualifier */
2426 | type_qualifier_list CONST
2429 /* 2.3: CTF-specific declarations */
2431 ctf_assignment_expression_list:
2432 ctf_assignment_expression SEMICOLON
2434 | ctf_assignment_expression_list ctf_assignment_expression SEMICOLON
2437 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2441 ctf_assignment_expression:
2442 unary_expression EQUAL unary_expression
2445 * Because we have left and right, cannot use
2448 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2449 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2450 if ($1->u.unary_expression.type != UNARY_STRING)
2451 reparent_error(scanner, "ctf_assignment_expression left expects string");
2452 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
2454 | unary_expression TYPEASSIGN declaration_specifiers /* Only allow struct */
2457 * Because we have left and right, cannot use
2460 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2461 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2462 if ($1->u.unary_expression.type != UNARY_STRING)
2463 reparent_error(scanner, "ctf_assignment_expression left expects string");
2464 bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
2466 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list
2468 struct ctf_node *list;
2470 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2471 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2472 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2473 $$ = make_node(scanner, NODE_TYPEDEF);
2474 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2475 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
2477 | TYPEDEF declaration_specifiers type_declarator_list
2479 struct ctf_node *list;
2481 $$ = make_node(scanner, NODE_TYPEDEF);
2482 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2483 $$->u._typedef.type_specifier_list = list;
2484 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2485 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2487 | declaration_specifiers TYPEDEF type_declarator_list
2489 struct ctf_node *list;
2491 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2492 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2493 $$ = make_node(scanner, NODE_TYPEDEF);
2494 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
2495 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2497 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
2499 struct ctf_node *list;
2501 $$ = make_node(scanner, NODE_TYPEALIAS);
2502 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2503 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2505 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2506 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
2507 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2508 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
2510 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2511 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
2512 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2513 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);