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
28 #define BT_LOG_OUTPUT_LEVEL ctf_plugin_metadata_log_level
29 #define BT_LOG_TAG "PLUGIN/CTF/META/PARSER"
41 #include "common/list.h"
42 #include "common/assert.h"
47 #include "parser-wrap.h"
49 /* Join two lists, put "add" at the end of "head". */
51 _bt_list_splice_tail (struct bt_list_head *add, struct bt_list_head *head)
53 /* Do nothing if the list which gets added is empty. */
54 if (add != add->next) {
55 add->next->prev = head->prev;
56 add->prev->next = head;
57 head->prev->next = add->next;
58 head->prev = add->prev;
63 int yyparse(struct ctf_scanner *scanner, yyscan_t yyscanner);
65 int yylex(union YYSTYPE *yyval, yyscan_t yyscanner);
67 int yylex_init_extra(struct ctf_scanner *scanner, yyscan_t * ptr_yy_globals);
69 int yylex_destroy(yyscan_t yyscanner);
71 void yyrestart(FILE * in_str, yyscan_t yyscanner);
73 int yyget_lineno(yyscan_t yyscanner);
75 char *yyget_text(yyscan_t yyscanner);
77 static const char *node_type_to_str[] = {
78 #define ENTRY(S) [S] = #S,
79 FOREACH_CTF_NODES(ENTRY)
84 * Static node for out of memory errors. Only "type" is used. lineno is
85 * always left at 0. The rest of the node content can be overwritten,
88 static struct ctf_node error_node = {
93 const char *node_type(struct ctf_node *node)
95 if (node->type < NR_NODE_TYPES)
96 return node_type_to_str[node->type];
101 void setstring(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src)
103 lvalp->s = objstack_alloc(scanner->objstack, strlen(src) + 1);
104 strcpy(lvalp->s, src);
108 int str_check(size_t str_len, size_t offset, size_t len)
111 if (offset + len < offset)
113 if (offset + len > str_len)
119 int bt_isodigit(int c)
137 int parse_base_sequence(const char *src, size_t len, size_t pos,
138 char *buffer, size_t *buf_len, int base)
140 const size_t max_char = 3;
143 while (!str_check(len, pos, 1) && nr_char < max_char) {
148 buffer[nr_char++] = c;
151 } else if (base == 16) {
153 buffer[nr_char++] = c;
158 /* Unsupported base */
162 BT_ASSERT_DBG(nr_char > 0);
163 buffer[nr_char] = '\0';
169 int import_basic_string(struct ctf_scanner *scanner, YYSTYPE *lvalp,
170 size_t len, const char *src, char delim)
172 size_t pos = 0, dpos = 0;
174 if (str_check(len, pos, 1))
176 if (src[pos++] != delim)
179 while (src[pos] != delim) {
182 if (str_check(len, pos, 1))
186 if (str_check(len, pos, 1))
236 if (parse_base_sequence(src, len, pos - 1,
237 oct_buffer, &oct_len, 8))
239 c = strtoul(&oct_buffer[0], NULL, 8);
248 if (parse_base_sequence(src, len, pos,
249 hex_buffer, &hex_len, 16))
251 c = strtoul(&hex_buffer[0], NULL, 16);
259 if (str_check(len, dpos, 1))
261 lvalp->s[dpos++] = c;
264 if (str_check(len, dpos, 1))
266 lvalp->s[dpos++] = '\0';
268 if (str_check(len, pos, 1))
270 if (src[pos++] != delim)
273 if (str_check(len, pos, 1))
275 if (src[pos] != '\0')
280 int import_string(struct ctf_scanner *scanner, YYSTYPE *lvalp,
281 const char *src, char delim)
285 len = strlen(src) + 1;
286 lvalp->s = objstack_alloc(scanner->objstack, len);
288 // TODO: import wide string
289 _BT_LOGE_LINENO(yyget_lineno(scanner),
290 "wide characters are not supported as of this version: "
291 "scanner-addr=%p", scanner);
294 return import_basic_string(scanner, lvalp, len, src, delim);
298 static void init_scope(struct ctf_scanner_scope *scope,
299 struct ctf_scanner_scope *parent)
301 scope->parent = parent;
302 scope->classes = g_hash_table_new_full(g_str_hash, g_str_equal,
306 static void finalize_scope(struct ctf_scanner_scope *scope)
308 g_hash_table_destroy(scope->classes);
311 static void push_scope(struct ctf_scanner *scanner)
313 struct ctf_scanner_scope *ns;
315 BT_LOGT("Pushing scope: scanner-addr=%p", scanner);
316 ns = malloc(sizeof(struct ctf_scanner_scope));
317 init_scope(ns, scanner->cs);
321 static void pop_scope(struct ctf_scanner *scanner)
323 struct ctf_scanner_scope *os;
325 BT_LOGT("Popping scope: scanner-addr=%p", scanner);
327 scanner->cs = os->parent;
332 static int lookup_type(struct ctf_scanner_scope *s, const char *id)
336 ret = GPOINTER_TO_INT(g_hash_table_lookup(s->classes, id));
337 BT_LOGT("Looked up type: scanner-addr=%p, id=\"%s\", ret=%d",
343 int is_type(struct ctf_scanner *scanner, const char *id)
345 struct ctf_scanner_scope *it;
348 for (it = scanner->cs; it; it = it->parent) {
349 if (lookup_type(it, id)) {
354 BT_LOGT("Found if ID is type: scanner-addr=%p, id=\"%s\", ret=%d",
359 static void add_type(struct ctf_scanner *scanner, char *id)
361 BT_LOGT("Adding type: scanner-addr=%p, id=\"%s\"",
363 if (lookup_type(scanner->cs, id))
365 g_hash_table_insert(scanner->cs->classes, id, id);
368 static struct ctf_node *make_node(struct ctf_scanner *scanner,
371 struct ctf_node *node;
373 node = objstack_alloc(scanner->objstack, sizeof(*node));
375 _BT_LOGE_LINENO(yyget_lineno(scanner->scanner),
376 "failed to allocate one stack entry: "
377 "scanner-addr=%p", scanner);
381 node->lineno = yyget_lineno(scanner->scanner);
382 BT_INIT_LIST_HEAD(&node->tmp_head);
383 bt_list_add(&node->siblings, &node->tmp_head);
387 node->type = NODE_ERROR;
388 BT_LOGE("Trying to create root node: scanner-addr=%p",
392 BT_INIT_LIST_HEAD(&node->u.event.declaration_list);
395 BT_INIT_LIST_HEAD(&node->u.stream.declaration_list);
398 BT_INIT_LIST_HEAD(&node->u.env.declaration_list);
401 BT_INIT_LIST_HEAD(&node->u.trace.declaration_list);
404 BT_INIT_LIST_HEAD(&node->u.clock.declaration_list);
407 BT_INIT_LIST_HEAD(&node->u.callsite.declaration_list);
409 case NODE_CTF_EXPRESSION:
410 BT_INIT_LIST_HEAD(&node->u.ctf_expression.left);
411 BT_INIT_LIST_HEAD(&node->u.ctf_expression.right);
413 case NODE_UNARY_EXPRESSION:
416 BT_INIT_LIST_HEAD(&node->u.field_class_def.field_class_declarators);
418 case NODE_TYPEALIAS_TARGET:
419 BT_INIT_LIST_HEAD(&node->u.field_class_alias_target.field_class_declarators);
421 case NODE_TYPEALIAS_ALIAS:
422 BT_INIT_LIST_HEAD(&node->u.field_class_alias_name.field_class_declarators);
426 case NODE_TYPE_SPECIFIER:
428 case NODE_TYPE_SPECIFIER_LIST:
429 BT_INIT_LIST_HEAD(&node->u.field_class_specifier_list.head);
433 case NODE_TYPE_DECLARATOR:
434 BT_INIT_LIST_HEAD(&node->u.field_class_declarator.pointers);
436 case NODE_FLOATING_POINT:
437 BT_INIT_LIST_HEAD(&node->u.floating_point.expressions);
440 BT_INIT_LIST_HEAD(&node->u.integer.expressions);
443 BT_INIT_LIST_HEAD(&node->u.string.expressions);
445 case NODE_ENUMERATOR:
446 BT_INIT_LIST_HEAD(&node->u.enumerator.values);
449 BT_INIT_LIST_HEAD(&node->u._enum.enumerator_list);
451 case NODE_STRUCT_OR_VARIANT_DECLARATION:
452 BT_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.field_class_declarators);
455 BT_INIT_LIST_HEAD(&node->u.variant.declaration_list);
458 BT_INIT_LIST_HEAD(&node->u._struct.declaration_list);
459 BT_INIT_LIST_HEAD(&node->u._struct.min_align);
463 node->type = NODE_ERROR;
464 BT_LOGE("Unknown node type: scanner-addr=%p, node-type=%d",
472 static int reparent_ctf_expression(struct ctf_node *node,
473 struct ctf_node *parent)
475 switch (parent->type) {
477 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
480 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
483 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
486 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
489 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
492 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
494 case NODE_FLOATING_POINT:
495 _bt_list_splice_tail(&node->tmp_head, &parent->u.floating_point.expressions);
498 _bt_list_splice_tail(&node->tmp_head, &parent->u.integer.expressions);
501 _bt_list_splice_tail(&node->tmp_head, &parent->u.string.expressions);
505 case NODE_CTF_EXPRESSION:
507 case NODE_TYPEALIAS_TARGET:
508 case NODE_TYPEALIAS_ALIAS:
510 case NODE_TYPE_SPECIFIER:
511 case NODE_TYPE_SPECIFIER_LIST:
513 case NODE_TYPE_DECLARATOR:
514 case NODE_ENUMERATOR:
516 case NODE_STRUCT_OR_VARIANT_DECLARATION:
519 case NODE_UNARY_EXPRESSION:
524 BT_LOGE("Unknown node type: node-type=%d", parent->type);
530 static int reparent_typedef(struct ctf_node *node, struct ctf_node *parent)
532 switch (parent->type) {
534 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
537 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
540 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
543 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
546 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
549 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
552 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
555 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
558 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
561 case NODE_FLOATING_POINT:
564 case NODE_CTF_EXPRESSION:
566 case NODE_TYPEALIAS_TARGET:
567 case NODE_TYPEALIAS_ALIAS:
569 case NODE_TYPE_SPECIFIER:
570 case NODE_TYPE_SPECIFIER_LIST:
572 case NODE_TYPE_DECLARATOR:
573 case NODE_ENUMERATOR:
575 case NODE_STRUCT_OR_VARIANT_DECLARATION:
576 case NODE_UNARY_EXPRESSION:
581 BT_LOGE("Unknown node type: node-type=%d", parent->type);
587 static int reparent_field_class_alias(struct ctf_node *node, struct ctf_node *parent)
589 switch (parent->type) {
591 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
594 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
597 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
600 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
603 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
606 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
609 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
612 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
615 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
618 case NODE_FLOATING_POINT:
621 case NODE_CTF_EXPRESSION:
623 case NODE_TYPEALIAS_TARGET:
624 case NODE_TYPEALIAS_ALIAS:
626 case NODE_TYPE_SPECIFIER:
627 case NODE_TYPE_SPECIFIER_LIST:
629 case NODE_TYPE_DECLARATOR:
630 case NODE_ENUMERATOR:
632 case NODE_STRUCT_OR_VARIANT_DECLARATION:
633 case NODE_UNARY_EXPRESSION:
638 BT_LOGE("Unknown node type: node-type=%d", parent->type);
644 static int reparent_field_class_specifier(struct ctf_node *node,
645 struct ctf_node *parent)
647 switch (parent->type) {
648 case NODE_TYPE_SPECIFIER_LIST:
649 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_specifier_list.head);
652 case NODE_TYPE_SPECIFIER:
662 case NODE_TYPEALIAS_TARGET:
663 case NODE_TYPEALIAS_ALIAS:
664 case NODE_TYPE_DECLARATOR:
666 case NODE_STRUCT_OR_VARIANT_DECLARATION:
668 case NODE_FLOATING_POINT:
671 case NODE_CTF_EXPRESSION:
673 case NODE_ENUMERATOR:
674 case NODE_UNARY_EXPRESSION:
679 BT_LOGE("Unknown node type: node-type=%d", parent->type);
685 static int reparent_field_class_specifier_list(struct ctf_node *node,
686 struct ctf_node *parent)
688 switch (parent->type) {
690 bt_list_add_tail(&node->siblings, &parent->u.root.declaration_list);
693 bt_list_add_tail(&node->siblings, &parent->u.event.declaration_list);
696 bt_list_add_tail(&node->siblings, &parent->u.stream.declaration_list);
699 bt_list_add_tail(&node->siblings, &parent->u.env.declaration_list);
702 bt_list_add_tail(&node->siblings, &parent->u.trace.declaration_list);
705 bt_list_add_tail(&node->siblings, &parent->u.clock.declaration_list);
708 bt_list_add_tail(&node->siblings, &parent->u.callsite.declaration_list);
711 bt_list_add_tail(&node->siblings, &parent->u.variant.declaration_list);
714 bt_list_add_tail(&node->siblings, &parent->u._struct.declaration_list);
717 parent->u.field_class_def.field_class_specifier_list = node;
719 case NODE_TYPEALIAS_TARGET:
720 parent->u.field_class_alias_target.field_class_specifier_list = node;
722 case NODE_TYPEALIAS_ALIAS:
723 parent->u.field_class_alias_name.field_class_specifier_list = node;
726 parent->u._enum.container_field_class = node;
728 case NODE_STRUCT_OR_VARIANT_DECLARATION:
729 parent->u.struct_or_variant_declaration.field_class_specifier_list = node;
731 case NODE_TYPE_DECLARATOR:
732 case NODE_TYPE_SPECIFIER:
734 case NODE_FLOATING_POINT:
737 case NODE_CTF_EXPRESSION:
739 case NODE_ENUMERATOR:
740 case NODE_UNARY_EXPRESSION:
745 BT_LOGE("Unknown node type: node-type=%d", parent->type);
751 static int reparent_field_class_declarator(struct ctf_node *node,
752 struct ctf_node *parent)
754 switch (parent->type) {
755 case NODE_TYPE_DECLARATOR:
756 parent->u.field_class_declarator.type = TYPEDEC_NESTED;
757 parent->u.field_class_declarator.u.nested.field_class_declarator = node;
759 case NODE_STRUCT_OR_VARIANT_DECLARATION:
760 _bt_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.field_class_declarators);
763 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_def.field_class_declarators);
765 case NODE_TYPEALIAS_TARGET:
766 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_alias_target.field_class_declarators);
768 case NODE_TYPEALIAS_ALIAS:
769 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_alias_name.field_class_declarators);
783 case NODE_FLOATING_POINT:
786 case NODE_CTF_EXPRESSION:
787 case NODE_TYPE_SPECIFIER:
788 case NODE_TYPE_SPECIFIER_LIST:
790 case NODE_ENUMERATOR:
791 case NODE_UNARY_EXPRESSION:
796 BT_LOGE("Unknown node type: node-type=%d", parent->type);
805 * Link node to parent. Returns 0 on success, -EPERM if it is not permitted to
806 * create the link declared by the input, -ENOENT if node or parent is NULL,
807 * -EINVAL if there is an internal structure problem.
809 static int set_parent_node(struct ctf_node *node,
810 struct ctf_node *parent)
812 if (!node || !parent)
815 /* Note: Linking to parent will be done only by an external visitor */
817 switch (node->type) {
819 BT_LOGE_STR("Trying to reparent root node.");
823 if (parent->type == NODE_ROOT) {
824 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.event);
830 if (parent->type == NODE_ROOT) {
831 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.stream);
837 if (parent->type == NODE_ROOT) {
838 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.env);
844 if (parent->type == NODE_ROOT) {
845 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.trace);
851 if (parent->type == NODE_ROOT) {
852 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.clock);
858 if (parent->type == NODE_ROOT) {
859 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.callsite);
865 case NODE_CTF_EXPRESSION:
866 return reparent_ctf_expression(node, parent);
867 case NODE_UNARY_EXPRESSION:
868 if (parent->type == NODE_TYPE_DECLARATOR)
869 parent->u.field_class_declarator.bitfield_len = node;
875 return reparent_typedef(node, parent);
876 case NODE_TYPEALIAS_TARGET:
877 if (parent->type == NODE_TYPEALIAS)
878 parent->u.field_class_alias.target = node;
882 case NODE_TYPEALIAS_ALIAS:
883 if (parent->type == NODE_TYPEALIAS)
884 parent->u.field_class_alias.alias = node;
889 return reparent_field_class_alias(node, parent);
892 if (parent->type == NODE_TYPE_DECLARATOR) {
893 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_declarator.pointers);
897 case NODE_TYPE_DECLARATOR:
898 return reparent_field_class_declarator(node, parent);
900 case NODE_TYPE_SPECIFIER_LIST:
901 return reparent_field_class_specifier_list(node, parent);
903 case NODE_TYPE_SPECIFIER:
904 return reparent_field_class_specifier(node, parent);
906 case NODE_FLOATING_POINT:
912 return -EINVAL; /* Dealt with internally within grammar */
914 case NODE_ENUMERATOR:
915 if (parent->type == NODE_ENUM) {
916 _bt_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
921 case NODE_STRUCT_OR_VARIANT_DECLARATION:
922 switch (parent->type) {
924 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
927 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
936 BT_LOGE("Unknown node type: node-type=%d", parent->type);
943 void yyerror(struct ctf_scanner *scanner, yyscan_t yyscanner, const char *str)
945 _BT_LOGE_LINENO(yyget_lineno(scanner->scanner),
946 "%s: token=\"%s\"", str, yyget_text(scanner->scanner));
955 #define reparent_error(scanner, str) \
957 yyerror(scanner, scanner->scanner, YY_("reparent_error: " str)); \
961 static struct ctf_ast *ctf_ast_alloc(struct ctf_scanner *scanner)
965 ast = objstack_alloc(scanner->objstack, sizeof(*ast));
968 ast->root.type = NODE_ROOT;
969 BT_INIT_LIST_HEAD(&ast->root.tmp_head);
970 BT_INIT_LIST_HEAD(&ast->root.u.root.declaration_list);
971 BT_INIT_LIST_HEAD(&ast->root.u.root.trace);
972 BT_INIT_LIST_HEAD(&ast->root.u.root.env);
973 BT_INIT_LIST_HEAD(&ast->root.u.root.stream);
974 BT_INIT_LIST_HEAD(&ast->root.u.root.event);
975 BT_INIT_LIST_HEAD(&ast->root.u.root.clock);
976 BT_INIT_LIST_HEAD(&ast->root.u.root.callsite);
980 int ctf_scanner_append_ast(struct ctf_scanner *scanner, FILE *input)
982 /* Start processing new stream */
983 yyrestart(input, scanner->scanner);
984 return yyparse(scanner, scanner->scanner);
987 struct ctf_scanner *ctf_scanner_alloc(void)
989 struct ctf_scanner *scanner;
992 scanner = malloc(sizeof(*scanner));
995 memset(scanner, 0, sizeof(*scanner));
996 ret = yylex_init_extra(scanner, &scanner->scanner);
998 BT_LOGE("yylex_init_extra() failed: ret=%d", ret);
999 goto cleanup_scanner;
1001 scanner->objstack = objstack_create();
1002 if (!scanner->objstack)
1004 scanner->ast = ctf_ast_alloc(scanner);
1006 goto cleanup_objstack;
1007 init_scope(&scanner->root_scope, NULL);
1008 scanner->cs = &scanner->root_scope;
1013 objstack_destroy(scanner->objstack);
1015 ret = yylex_destroy(scanner->scanner);
1017 BT_LOGE("yylex_destroy() failed: scanner-addr=%p, ret=%d",
1024 void ctf_scanner_free(struct ctf_scanner *scanner)
1030 finalize_scope(&scanner->root_scope);
1031 objstack_destroy(scanner->objstack);
1032 ret = yylex_destroy(scanner->scanner);
1034 BT_LOGE("yylex_destroy() failed: scanner-addr=%p, ret=%d",
1040 * The bison-provided version of strlen (yystrlen) generates a benign
1041 * -Wnull-dereference warning. That version is used when building on cygwin,
1042 * for example, but you can also enable it by hand (to test) by removing the
1043 * preprocessor conditional around it.
1045 * Define yystrlen such that it will always use strlen. As far as we know,
1046 * strlen provided by all the platforms we use is reliable.
1048 #define yystrlen strlen
1053 * This ends up in parser.h and makes sure those who want to include it pass
1054 * through parser-wrap.h.
1057 #ifndef ALLOW_INCLUDE_PARSER_H
1058 # error "Don't include parser.h directly, include parser-wrap.h instead."
1066 %parse-param {struct ctf_scanner *scanner}
1067 %parse-param {yyscan_t yyscanner}
1068 %lex-param {yyscan_t yyscanner}
1070 * Expect two shift-reduce conflicts. Caused by enum name-opt : type {}
1071 * vs struct { int :value; } (unnamed bit-field). The default is to
1072 * shift, so whenever we encounter an enumeration, we are doing the
1073 * proper thing (shift). It is illegal to declare an enumeration
1074 * "bit-field", so it is OK if this situation ends up in a parsing
1079 %token CTF_INTEGER_LITERAL CTF_STRING_LITERAL CTF_CHARACTER_LITERAL CTF_LSBRAC CTF_RSBRAC CTF_LPAREN CTF_RPAREN CTF_LBRAC CTF_RBRAC CTF_RARROW CTF_STAR CTF_PLUS CTF_MINUS CTF_LT CTF_GT CTF_TYPEASSIGN CTF_COLON CTF_SEMICOLON CTF_DOTDOTDOT CTF_DOT CTF_EQUAL CTF_COMMA CTF_CONST CTF_CHAR CTF_DOUBLE CTF_ENUM CTF_ENV CTF_EVENT CTF_FLOATING_POINT CTF_FLOAT CTF_INTEGER CTF_INT CTF_LONG CTF_SHORT CTF_SIGNED CTF_STREAM CTF_STRING CTF_STRUCT CTF_TRACE CTF_CALLSITE CTF_CLOCK CTF_TYPEALIAS CTF_TYPEDEF CTF_UNSIGNED CTF_VARIANT CTF_VOID CTF_BOOL CTF_COMPLEX CTF_IMAGINARY CTF_TOK_ALIGN
1080 %token <s> IDENTIFIER ID_TYPE
1085 unsigned long long ull;
1091 %type <s> CTF_STRING_LITERAL CTF_CHARACTER_LITERAL
1095 %type <ull> CTF_INTEGER_LITERAL
1096 %type <n> postfix_expression unary_expression unary_expression_or_range
1098 %type <n> declaration
1099 %type <n> event_declaration
1100 %type <n> stream_declaration
1101 %type <n> env_declaration
1102 %type <n> trace_declaration
1103 %type <n> clock_declaration
1104 %type <n> callsite_declaration
1105 %type <n> integer_declaration_specifiers
1106 %type <n> declaration_specifiers
1107 %type <n> alias_declaration_specifiers
1109 %type <n> field_class_declarator_list
1110 %type <n> integer_field_class_specifier
1111 %type <n> field_class_specifier
1112 %type <n> struct_class_specifier
1113 %type <n> variant_field_class_specifier
1114 %type <n> enum_field_class_specifier
1115 %type <n> struct_or_variant_declaration_list
1116 %type <n> struct_or_variant_declaration
1117 %type <n> struct_or_variant_declarator_list
1118 %type <n> struct_or_variant_declarator
1119 %type <n> enumerator_list
1120 %type <n> enumerator
1121 %type <n> abstract_declarator_list
1122 %type <n> abstract_declarator
1123 %type <n> direct_abstract_declarator
1124 %type <n> alias_abstract_declarator_list
1125 %type <n> alias_abstract_declarator
1126 %type <n> direct_alias_abstract_declarator
1127 %type <n> declarator
1128 %type <n> direct_declarator
1129 %type <n> field_class_declarator
1130 %type <n> direct_field_class_declarator
1132 %type <n> ctf_assignment_expression_list
1133 %type <n> ctf_assignment_expression
1140 if (set_parent_node($1, &ctf_scanner_get_ast(scanner)->root))
1141 reparent_error(scanner, "error reparenting to root");
1145 if (set_parent_node($2, &ctf_scanner_get_ast(scanner)->root))
1146 reparent_error(scanner, "error reparenting to root");
1175 | CTF_FLOATING_POINT
1208 /* 2: Phrase structure grammar */
1213 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1214 $$->u.unary_expression.type = UNARY_STRING;
1215 $$->u.unary_expression.u.string = yylval.s;
1219 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1220 $$->u.unary_expression.type = UNARY_STRING;
1221 $$->u.unary_expression.u.string = yylval.s;
1225 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1226 $$->u.unary_expression.type = UNARY_STRING;
1227 $$->u.unary_expression.u.string = yylval.s;
1229 | CTF_INTEGER_LITERAL
1231 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1232 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1233 $$->u.unary_expression.u.unsigned_constant = $1;
1235 | CTF_STRING_LITERAL
1237 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1238 $$->u.unary_expression.type = UNARY_STRING;
1239 $$->u.unary_expression.u.string = $1;
1241 | CTF_CHARACTER_LITERAL
1243 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1244 $$->u.unary_expression.type = UNARY_STRING;
1245 $$->u.unary_expression.u.string = $1;
1247 | CTF_LPAREN unary_expression CTF_RPAREN
1251 | postfix_expression CTF_LSBRAC unary_expression CTF_RSBRAC
1253 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1254 $$->u.unary_expression.type = UNARY_SBRAC;
1255 $$->u.unary_expression.u.sbrac_exp = $3;
1256 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1257 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1259 | postfix_expression CTF_DOT IDENTIFIER
1261 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1262 $$->u.unary_expression.type = UNARY_STRING;
1263 $$->u.unary_expression.u.string = yylval.s;
1264 $$->u.unary_expression.link = UNARY_DOTLINK;
1265 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1266 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1268 | postfix_expression CTF_DOT ID_TYPE
1270 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1271 $$->u.unary_expression.type = UNARY_STRING;
1272 $$->u.unary_expression.u.string = yylval.s;
1273 $$->u.unary_expression.link = UNARY_DOTLINK;
1274 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1275 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1277 | postfix_expression CTF_DOT keywords
1279 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1280 $$->u.unary_expression.type = UNARY_STRING;
1281 $$->u.unary_expression.u.string = yylval.s;
1282 $$->u.unary_expression.link = UNARY_DOTLINK;
1283 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1284 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1286 | postfix_expression CTF_RARROW IDENTIFIER
1288 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1289 $$->u.unary_expression.type = UNARY_STRING;
1290 $$->u.unary_expression.u.string = yylval.s;
1291 $$->u.unary_expression.link = UNARY_ARROWLINK;
1292 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1293 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1295 | postfix_expression CTF_RARROW ID_TYPE
1297 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1298 $$->u.unary_expression.type = UNARY_STRING;
1299 $$->u.unary_expression.u.string = yylval.s;
1300 $$->u.unary_expression.link = UNARY_ARROWLINK;
1301 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1302 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1309 | CTF_PLUS postfix_expression
1312 if ($$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
1313 && $$->u.unary_expression.type != UNARY_SIGNED_CONSTANT) {
1314 reparent_error(scanner, "expecting numeric constant");
1317 | CTF_MINUS postfix_expression
1320 if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1321 $$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
1322 $$->u.unary_expression.u.signed_constant =
1323 -($$->u.unary_expression.u.unsigned_constant);
1324 } else if ($$->u.unary_expression.type == UNARY_SIGNED_CONSTANT) {
1325 $$->u.unary_expression.u.signed_constant =
1326 -($$->u.unary_expression.u.signed_constant);
1328 reparent_error(scanner, "expecting numeric constant");
1333 unary_expression_or_range:
1334 unary_expression CTF_DOTDOTDOT unary_expression
1337 _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
1338 $3->u.unary_expression.link = UNARY_DOTDOTDOT;
1344 /* 2.2: Declarations */
1347 declaration_specifiers CTF_SEMICOLON
1351 | stream_declaration
1359 | callsite_declaration
1361 | declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
1363 struct ctf_node *list;
1365 $$ = make_node(scanner, NODE_TYPEDEF);
1366 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1367 $$->u.field_class_def.field_class_specifier_list = list;
1368 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1369 _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1370 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1372 | CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
1374 struct ctf_node *list;
1376 $$ = make_node(scanner, NODE_TYPEDEF);
1377 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1378 $$->u.field_class_def.field_class_specifier_list = list;
1379 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1380 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1382 | declaration_specifiers CTF_TYPEDEF field_class_declarator_list CTF_SEMICOLON
1384 struct ctf_node *list;
1386 $$ = make_node(scanner, NODE_TYPEDEF);
1387 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1388 $$->u.field_class_def.field_class_specifier_list = list;
1389 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1390 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1392 | CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
1394 struct ctf_node *list;
1396 $$ = make_node(scanner, NODE_TYPEALIAS);
1397 $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1398 $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1400 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1401 $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
1402 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1403 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
1405 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1406 $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
1407 _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1408 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
1413 event_declaration_begin event_declaration_end
1415 $$ = make_node(scanner, NODE_EVENT);
1417 | event_declaration_begin ctf_assignment_expression_list event_declaration_end
1419 $$ = make_node(scanner, NODE_EVENT);
1420 if (set_parent_node($2, $$))
1421 reparent_error(scanner, "event_declaration");
1425 event_declaration_begin:
1427 { push_scope(scanner); }
1430 event_declaration_end:
1431 CTF_RBRAC CTF_SEMICOLON
1432 { pop_scope(scanner); }
1437 stream_declaration_begin stream_declaration_end
1439 $$ = make_node(scanner, NODE_STREAM);
1441 | stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
1443 $$ = make_node(scanner, NODE_STREAM);
1444 if (set_parent_node($2, $$))
1445 reparent_error(scanner, "stream_declaration");
1449 stream_declaration_begin:
1450 CTF_STREAM CTF_LBRAC
1451 { push_scope(scanner); }
1454 stream_declaration_end:
1455 CTF_RBRAC CTF_SEMICOLON
1456 { pop_scope(scanner); }
1460 env_declaration_begin env_declaration_end
1462 $$ = make_node(scanner, NODE_ENV);
1464 | env_declaration_begin ctf_assignment_expression_list env_declaration_end
1466 $$ = make_node(scanner, NODE_ENV);
1467 if (set_parent_node($2, $$))
1468 reparent_error(scanner, "env declaration");
1472 env_declaration_begin:
1474 { push_scope(scanner); }
1477 env_declaration_end:
1478 CTF_RBRAC CTF_SEMICOLON
1479 { pop_scope(scanner); }
1483 trace_declaration_begin trace_declaration_end
1485 $$ = make_node(scanner, NODE_TRACE);
1487 | trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
1489 $$ = make_node(scanner, NODE_TRACE);
1490 if (set_parent_node($2, $$))
1491 reparent_error(scanner, "trace_declaration");
1495 trace_declaration_begin:
1497 { push_scope(scanner); }
1500 trace_declaration_end:
1501 CTF_RBRAC CTF_SEMICOLON
1502 { pop_scope(scanner); }
1506 CTF_CLOCK clock_declaration_begin clock_declaration_end
1508 $$ = make_node(scanner, NODE_CLOCK);
1510 | CTF_CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
1512 $$ = make_node(scanner, NODE_CLOCK);
1513 if (set_parent_node($3, $$))
1514 reparent_error(scanner, "trace_declaration");
1518 clock_declaration_begin:
1520 { push_scope(scanner); }
1523 clock_declaration_end:
1524 CTF_RBRAC CTF_SEMICOLON
1525 { pop_scope(scanner); }
1528 callsite_declaration:
1529 CTF_CALLSITE callsite_declaration_begin callsite_declaration_end
1531 $$ = make_node(scanner, NODE_CALLSITE);
1533 | CTF_CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
1535 $$ = make_node(scanner, NODE_CALLSITE);
1536 if (set_parent_node($3, $$))
1537 reparent_error(scanner, "trace_declaration");
1541 callsite_declaration_begin:
1543 { push_scope(scanner); }
1546 callsite_declaration_end:
1547 CTF_RBRAC CTF_SEMICOLON
1548 { pop_scope(scanner); }
1551 integer_declaration_specifiers:
1554 struct ctf_node *node;
1556 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1557 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1558 node->u.field_class_specifier.type = TYPESPEC_CONST;
1559 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1561 | integer_field_class_specifier
1563 struct ctf_node *node;
1565 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1567 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1569 | integer_declaration_specifiers CTF_CONST
1571 struct ctf_node *node;
1574 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1575 node->u.field_class_specifier.type = TYPESPEC_CONST;
1576 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1578 | integer_declaration_specifiers integer_field_class_specifier
1581 bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
1585 declaration_specifiers:
1588 struct ctf_node *node;
1590 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1591 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1592 node->u.field_class_specifier.type = TYPESPEC_CONST;
1593 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1595 | field_class_specifier
1597 struct ctf_node *node;
1599 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1601 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1603 | declaration_specifiers CTF_CONST
1605 struct ctf_node *node;
1608 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1609 node->u.field_class_specifier.type = TYPESPEC_CONST;
1610 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1612 | declaration_specifiers field_class_specifier
1615 bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
1619 field_class_declarator_list:
1620 field_class_declarator
1622 | field_class_declarator_list CTF_COMMA field_class_declarator
1625 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1629 integer_field_class_specifier:
1632 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1633 $$->u.field_class_specifier.type = TYPESPEC_CHAR;
1637 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1638 $$->u.field_class_specifier.type = TYPESPEC_SHORT;
1642 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1643 $$->u.field_class_specifier.type = TYPESPEC_INT;
1647 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1648 $$->u.field_class_specifier.type = TYPESPEC_LONG;
1652 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1653 $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
1657 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1658 $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
1662 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1663 $$->u.field_class_specifier.type = TYPESPEC_BOOL;
1667 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1668 $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
1669 $$->u.field_class_specifier.id_type = yylval.s;
1671 | CTF_INTEGER CTF_LBRAC CTF_RBRAC
1673 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1674 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1675 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1677 | CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1679 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1680 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1681 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1682 if (set_parent_node($3, $$->u.field_class_specifier.node))
1683 reparent_error(scanner, "integer reparent error");
1687 field_class_specifier:
1690 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1691 $$->u.field_class_specifier.type = TYPESPEC_VOID;
1695 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1696 $$->u.field_class_specifier.type = TYPESPEC_CHAR;
1700 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1701 $$->u.field_class_specifier.type = TYPESPEC_SHORT;
1705 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1706 $$->u.field_class_specifier.type = TYPESPEC_INT;
1710 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1711 $$->u.field_class_specifier.type = TYPESPEC_LONG;
1715 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1716 $$->u.field_class_specifier.type = TYPESPEC_FLOAT;
1720 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1721 $$->u.field_class_specifier.type = TYPESPEC_DOUBLE;
1725 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1726 $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
1730 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1731 $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
1735 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1736 $$->u.field_class_specifier.type = TYPESPEC_BOOL;
1740 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1741 $$->u.field_class_specifier.type = TYPESPEC_COMPLEX;
1745 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1746 $$->u.field_class_specifier.type = TYPESPEC_IMAGINARY;
1750 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1751 $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
1752 $$->u.field_class_specifier.id_type = yylval.s;
1754 | CTF_FLOATING_POINT CTF_LBRAC CTF_RBRAC
1756 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1757 $$->u.field_class_specifier.type = TYPESPEC_FLOATING_POINT;
1758 $$->u.field_class_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1760 | CTF_FLOATING_POINT CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1762 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1763 $$->u.field_class_specifier.type = TYPESPEC_FLOATING_POINT;
1764 $$->u.field_class_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1765 if (set_parent_node($3, $$->u.field_class_specifier.node))
1766 reparent_error(scanner, "floating point reparent error");
1768 | CTF_INTEGER CTF_LBRAC CTF_RBRAC
1770 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1771 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1772 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1774 | CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1776 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1777 $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1778 $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1779 if (set_parent_node($3, $$->u.field_class_specifier.node))
1780 reparent_error(scanner, "integer reparent error");
1784 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1785 $$->u.field_class_specifier.type = TYPESPEC_STRING;
1786 $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1788 | CTF_STRING CTF_LBRAC CTF_RBRAC
1790 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1791 $$->u.field_class_specifier.type = TYPESPEC_STRING;
1792 $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1794 | CTF_STRING CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1796 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1797 $$->u.field_class_specifier.type = TYPESPEC_STRING;
1798 $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1799 if (set_parent_node($3, $$->u.field_class_specifier.node))
1800 reparent_error(scanner, "string reparent error");
1802 | CTF_ENUM enum_field_class_specifier
1804 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1805 $$->u.field_class_specifier.type = TYPESPEC_ENUM;
1806 $$->u.field_class_specifier.node = $2;
1808 | CTF_VARIANT variant_field_class_specifier
1810 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1811 $$->u.field_class_specifier.type = TYPESPEC_VARIANT;
1812 $$->u.field_class_specifier.node = $2;
1814 | CTF_STRUCT struct_class_specifier
1816 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1817 $$->u.field_class_specifier.type = TYPESPEC_STRUCT;
1818 $$->u.field_class_specifier.node = $2;
1822 struct_class_specifier:
1823 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1825 $$ = make_node(scanner, NODE_STRUCT);
1826 $$->u._struct.has_body = 1;
1827 if ($2 && set_parent_node($2, $$))
1828 reparent_error(scanner, "struct reparent error");
1830 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1832 $$ = make_node(scanner, NODE_STRUCT);
1833 $$->u._struct.has_body = 1;
1834 $$->u._struct.name = $1;
1835 if ($3 && set_parent_node($3, $$))
1836 reparent_error(scanner, "struct reparent error");
1838 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1840 $$ = make_node(scanner, NODE_STRUCT);
1841 $$->u._struct.has_body = 1;
1842 $$->u._struct.name = $1;
1843 if ($3 && set_parent_node($3, $$))
1844 reparent_error(scanner, "struct reparent error");
1848 $$ = make_node(scanner, NODE_STRUCT);
1849 $$->u._struct.has_body = 0;
1850 $$->u._struct.name = $1;
1854 $$ = make_node(scanner, NODE_STRUCT);
1855 $$->u._struct.has_body = 0;
1856 $$->u._struct.name = $1;
1858 | struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1860 $$ = make_node(scanner, NODE_STRUCT);
1861 $$->u._struct.has_body = 1;
1862 bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
1863 if ($2 && set_parent_node($2, $$))
1864 reparent_error(scanner, "struct reparent error");
1866 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1868 $$ = make_node(scanner, NODE_STRUCT);
1869 $$->u._struct.has_body = 1;
1870 $$->u._struct.name = $1;
1871 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1872 if ($3 && set_parent_node($3, $$))
1873 reparent_error(scanner, "struct reparent error");
1875 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1877 $$ = make_node(scanner, NODE_STRUCT);
1878 $$->u._struct.has_body = 1;
1879 $$->u._struct.name = $1;
1880 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1881 if ($3 && set_parent_node($3, $$))
1882 reparent_error(scanner, "struct reparent error");
1886 struct_declaration_begin:
1888 { push_scope(scanner); }
1891 struct_declaration_end:
1893 { pop_scope(scanner); }
1896 variant_field_class_specifier:
1897 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1899 $$ = make_node(scanner, NODE_VARIANT);
1900 $$->u.variant.has_body = 1;
1901 if ($2 && set_parent_node($2, $$))
1902 reparent_error(scanner, "variant reparent error");
1904 | CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1906 $$ = make_node(scanner, NODE_VARIANT);
1907 $$->u.variant.has_body = 1;
1908 $$->u.variant.choice = $2;
1909 if ($5 && set_parent_node($5, $$))
1910 reparent_error(scanner, "variant reparent error");
1912 | CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1914 $$ = make_node(scanner, NODE_VARIANT);
1915 $$->u.variant.has_body = 1;
1916 $$->u.variant.choice = $2;
1917 if ($5 && set_parent_node($5, $$))
1918 reparent_error(scanner, "variant reparent error");
1920 | IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1922 $$ = make_node(scanner, NODE_VARIANT);
1923 $$->u.variant.has_body = 1;
1924 $$->u.variant.name = $1;
1925 if ($3 && set_parent_node($3, $$))
1926 reparent_error(scanner, "variant reparent error");
1928 | IDENTIFIER CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1930 $$ = make_node(scanner, NODE_VARIANT);
1931 $$->u.variant.has_body = 1;
1932 $$->u.variant.name = $1;
1933 $$->u.variant.choice = $3;
1934 if ($6 && set_parent_node($6, $$))
1935 reparent_error(scanner, "variant reparent error");
1937 | IDENTIFIER CTF_LT IDENTIFIER CTF_GT
1939 $$ = make_node(scanner, NODE_VARIANT);
1940 $$->u.variant.has_body = 0;
1941 $$->u.variant.name = $1;
1942 $$->u.variant.choice = $3;
1944 | IDENTIFIER CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1946 $$ = make_node(scanner, NODE_VARIANT);
1947 $$->u.variant.has_body = 1;
1948 $$->u.variant.name = $1;
1949 $$->u.variant.choice = $3;
1950 if ($6 && set_parent_node($6, $$))
1951 reparent_error(scanner, "variant reparent error");
1953 | IDENTIFIER CTF_LT ID_TYPE CTF_GT
1955 $$ = make_node(scanner, NODE_VARIANT);
1956 $$->u.variant.has_body = 0;
1957 $$->u.variant.name = $1;
1958 $$->u.variant.choice = $3;
1960 | ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1962 $$ = make_node(scanner, NODE_VARIANT);
1963 $$->u.variant.has_body = 1;
1964 $$->u.variant.name = $1;
1965 if ($3 && set_parent_node($3, $$))
1966 reparent_error(scanner, "variant reparent error");
1968 | ID_TYPE CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1970 $$ = make_node(scanner, NODE_VARIANT);
1971 $$->u.variant.has_body = 1;
1972 $$->u.variant.name = $1;
1973 $$->u.variant.choice = $3;
1974 if ($6 && set_parent_node($6, $$))
1975 reparent_error(scanner, "variant reparent error");
1977 | ID_TYPE CTF_LT IDENTIFIER CTF_GT
1979 $$ = make_node(scanner, NODE_VARIANT);
1980 $$->u.variant.has_body = 0;
1981 $$->u.variant.name = $1;
1982 $$->u.variant.choice = $3;
1984 | ID_TYPE CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1986 $$ = make_node(scanner, NODE_VARIANT);
1987 $$->u.variant.has_body = 1;
1988 $$->u.variant.name = $1;
1989 $$->u.variant.choice = $3;
1990 if ($6 && set_parent_node($6, $$))
1991 reparent_error(scanner, "variant reparent error");
1993 | ID_TYPE CTF_LT ID_TYPE CTF_GT
1995 $$ = make_node(scanner, NODE_VARIANT);
1996 $$->u.variant.has_body = 0;
1997 $$->u.variant.name = $1;
1998 $$->u.variant.choice = $3;
2002 variant_declaration_begin:
2004 { push_scope(scanner); }
2007 variant_declaration_end:
2009 { pop_scope(scanner); }
2012 enum_field_class_specifier:
2013 CTF_LBRAC enumerator_list CTF_RBRAC
2015 $$ = make_node(scanner, NODE_ENUM);
2016 $$->u._enum.has_body = 1;
2017 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
2019 | CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2021 $$ = make_node(scanner, NODE_ENUM);
2022 $$->u._enum.has_body = 1;
2023 ($$)->u._enum.container_field_class = $2;
2024 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2026 | IDENTIFIER CTF_LBRAC enumerator_list CTF_RBRAC
2028 $$ = make_node(scanner, NODE_ENUM);
2029 $$->u._enum.has_body = 1;
2030 $$->u._enum.enum_id = $1;
2031 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2033 | IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2035 $$ = make_node(scanner, NODE_ENUM);
2036 $$->u._enum.has_body = 1;
2037 $$->u._enum.enum_id = $1;
2038 ($$)->u._enum.container_field_class = $3;
2039 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2041 | ID_TYPE CTF_LBRAC enumerator_list CTF_RBRAC
2043 $$ = make_node(scanner, NODE_ENUM);
2044 $$->u._enum.has_body = 1;
2045 $$->u._enum.enum_id = $1;
2046 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2048 | ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2050 $$ = make_node(scanner, NODE_ENUM);
2051 $$->u._enum.has_body = 1;
2052 $$->u._enum.enum_id = $1;
2053 ($$)->u._enum.container_field_class = $3;
2054 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2056 | CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2058 $$ = make_node(scanner, NODE_ENUM);
2059 $$->u._enum.has_body = 1;
2060 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
2062 | CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2064 $$ = make_node(scanner, NODE_ENUM);
2065 $$->u._enum.has_body = 1;
2066 ($$)->u._enum.container_field_class = $2;
2067 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2069 | IDENTIFIER CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2071 $$ = make_node(scanner, NODE_ENUM);
2072 $$->u._enum.has_body = 1;
2073 $$->u._enum.enum_id = $1;
2074 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2076 | IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2078 $$ = make_node(scanner, NODE_ENUM);
2079 $$->u._enum.has_body = 1;
2080 $$->u._enum.enum_id = $1;
2081 ($$)->u._enum.container_field_class = $3;
2082 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2086 $$ = make_node(scanner, NODE_ENUM);
2087 $$->u._enum.has_body = 0;
2088 $$->u._enum.enum_id = $1;
2090 | ID_TYPE CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2092 $$ = make_node(scanner, NODE_ENUM);
2093 $$->u._enum.has_body = 1;
2094 $$->u._enum.enum_id = $1;
2095 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2097 | ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2099 $$ = make_node(scanner, NODE_ENUM);
2100 $$->u._enum.has_body = 1;
2101 $$->u._enum.enum_id = $1;
2102 ($$)->u._enum.container_field_class = $3;
2103 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2107 $$ = make_node(scanner, NODE_ENUM);
2108 $$->u._enum.has_body = 0;
2109 $$->u._enum.enum_id = $1;
2113 struct_or_variant_declaration_list:
2116 | struct_or_variant_declaration_list struct_or_variant_declaration
2120 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2123 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
2128 struct_or_variant_declaration:
2129 declaration_specifiers struct_or_variant_declarator_list CTF_SEMICOLON
2131 struct ctf_node *list;
2133 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2134 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2135 $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
2136 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2137 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.field_class_declarators);
2139 | declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
2141 struct ctf_node *list;
2143 $$ = make_node(scanner, NODE_TYPEDEF);
2144 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2145 $$->u.field_class_def.field_class_specifier_list = list;
2146 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2147 _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2148 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2150 | CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
2152 struct ctf_node *list;
2154 $$ = make_node(scanner, NODE_TYPEDEF);
2155 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2156 $$->u.field_class_def.field_class_specifier_list = list;
2157 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2158 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2160 | declaration_specifiers CTF_TYPEDEF field_class_declarator_list CTF_SEMICOLON
2162 struct ctf_node *list;
2164 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2165 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2166 $$ = make_node(scanner, NODE_TYPEDEF);
2167 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2168 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2170 | CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
2172 struct ctf_node *list;
2174 $$ = make_node(scanner, NODE_TYPEALIAS);
2175 $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2176 $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2178 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2179 $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
2180 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2181 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
2183 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2184 $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
2185 _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2186 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
2190 alias_declaration_specifiers:
2193 struct ctf_node *node;
2195 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2196 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2197 node->u.field_class_specifier.type = TYPESPEC_CONST;
2198 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2200 | field_class_specifier
2202 struct ctf_node *node;
2204 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2206 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2210 struct ctf_node *node;
2212 add_type(scanner, $1);
2213 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2214 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2215 node->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
2216 node->u.field_class_specifier.id_type = yylval.s;
2217 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2219 | alias_declaration_specifiers CTF_CONST
2221 struct ctf_node *node;
2224 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2225 node->u.field_class_specifier.type = TYPESPEC_CONST;
2226 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2228 | alias_declaration_specifiers field_class_specifier
2231 bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
2233 | alias_declaration_specifiers IDENTIFIER
2235 struct ctf_node *node;
2237 add_type(scanner, $2);
2239 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2240 node->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
2241 node->u.field_class_specifier.id_type = yylval.s;
2242 bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2246 struct_or_variant_declarator_list:
2247 struct_or_variant_declarator
2249 | struct_or_variant_declarator_list CTF_COMMA struct_or_variant_declarator
2252 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2256 struct_or_variant_declarator:
2259 | CTF_COLON unary_expression
2261 | declarator CTF_COLON unary_expression
2264 if (set_parent_node($3, $1))
2265 reparent_error(scanner, "struct_or_variant_declarator");
2272 | enumerator_list CTF_COMMA enumerator
2275 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2282 $$ = make_node(scanner, NODE_ENUMERATOR);
2283 $$->u.enumerator.id = $1;
2287 $$ = make_node(scanner, NODE_ENUMERATOR);
2288 $$->u.enumerator.id = $1;
2292 $$ = make_node(scanner, NODE_ENUMERATOR);
2293 $$->u.enumerator.id = $1;
2295 | CTF_STRING_LITERAL
2297 $$ = make_node(scanner, NODE_ENUMERATOR);
2298 $$->u.enumerator.id = $1;
2300 | IDENTIFIER CTF_EQUAL unary_expression_or_range
2302 $$ = make_node(scanner, NODE_ENUMERATOR);
2303 $$->u.enumerator.id = $1;
2304 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2306 | ID_TYPE CTF_EQUAL unary_expression_or_range
2308 $$ = make_node(scanner, NODE_ENUMERATOR);
2309 $$->u.enumerator.id = $1;
2310 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2312 | keywords CTF_EQUAL unary_expression_or_range
2314 $$ = make_node(scanner, NODE_ENUMERATOR);
2315 $$->u.enumerator.id = $1;
2316 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2318 | CTF_STRING_LITERAL CTF_EQUAL unary_expression_or_range
2320 $$ = make_node(scanner, NODE_ENUMERATOR);
2321 $$->u.enumerator.id = $1;
2322 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2326 abstract_declarator_list:
2329 | abstract_declarator_list CTF_COMMA abstract_declarator
2332 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2336 abstract_declarator:
2337 direct_abstract_declarator
2339 | pointer direct_abstract_declarator
2342 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2346 direct_abstract_declarator:
2349 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2350 $$->u.field_class_declarator.type = TYPEDEC_ID;
2355 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2356 $$->u.field_class_declarator.type = TYPEDEC_ID;
2357 $$->u.field_class_declarator.u.id = $1;
2359 | CTF_LPAREN abstract_declarator CTF_RPAREN
2361 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2362 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2363 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2365 | direct_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2367 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2368 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2369 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2370 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2371 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2373 | direct_abstract_declarator CTF_LSBRAC CTF_RSBRAC
2375 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2376 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2377 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2378 $$->u.field_class_declarator.u.nested.abstract_array = 1;
2382 alias_abstract_declarator_list:
2383 alias_abstract_declarator
2385 | alias_abstract_declarator_list CTF_COMMA alias_abstract_declarator
2388 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2392 alias_abstract_declarator:
2393 direct_alias_abstract_declarator
2395 | pointer direct_alias_abstract_declarator
2398 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2402 direct_alias_abstract_declarator:
2405 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2406 $$->u.field_class_declarator.type = TYPEDEC_ID;
2409 | CTF_LPAREN alias_abstract_declarator CTF_RPAREN
2411 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2412 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2413 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2415 | direct_alias_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2417 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2418 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2419 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2420 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2421 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2423 | direct_alias_abstract_declarator CTF_LSBRAC CTF_RSBRAC
2425 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2426 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2427 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2428 $$->u.field_class_declarator.u.nested.abstract_array = 1;
2435 | pointer direct_declarator
2438 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2445 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2446 $$->u.field_class_declarator.type = TYPEDEC_ID;
2447 $$->u.field_class_declarator.u.id = $1;
2449 | CTF_LPAREN declarator CTF_RPAREN
2451 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2452 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2453 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2455 | direct_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2457 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2458 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2459 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2460 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2461 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2465 field_class_declarator:
2466 direct_field_class_declarator
2468 | pointer direct_field_class_declarator
2471 bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2475 direct_field_class_declarator:
2478 add_type(scanner, $1);
2479 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2480 $$->u.field_class_declarator.type = TYPEDEC_ID;
2481 $$->u.field_class_declarator.u.id = $1;
2483 | CTF_LPAREN field_class_declarator CTF_RPAREN
2485 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2486 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2487 $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2489 | direct_field_class_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2491 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2492 $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2493 $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2494 BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2495 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2502 $$ = make_node(scanner, NODE_POINTER);
2506 $$ = make_node(scanner, NODE_POINTER);
2507 bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
2509 | CTF_STAR type_qualifier_list pointer
2511 $$ = make_node(scanner, NODE_POINTER);
2512 $$->u.pointer.const_qualifier = 1;
2513 bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
2517 type_qualifier_list:
2518 /* pointer assumes only const type qualifier */
2520 | type_qualifier_list CTF_CONST
2523 /* 2.3: CTF-specific declarations */
2525 ctf_assignment_expression_list:
2526 ctf_assignment_expression CTF_SEMICOLON
2528 | ctf_assignment_expression_list ctf_assignment_expression CTF_SEMICOLON
2531 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2535 ctf_assignment_expression:
2536 unary_expression CTF_EQUAL unary_expression
2539 * Because we have left and right, cannot use
2542 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2543 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2544 if ($1->u.unary_expression.type != UNARY_STRING)
2545 reparent_error(scanner, "ctf_assignment_expression left expects string");
2546 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
2548 | unary_expression CTF_TYPEASSIGN declaration_specifiers /* Only allow struct */
2551 * Because we have left and right, cannot use
2554 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2555 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2556 if ($1->u.unary_expression.type != UNARY_STRING)
2557 reparent_error(scanner, "ctf_assignment_expression left expects string");
2558 bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
2560 | declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list
2562 struct ctf_node *list;
2564 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2565 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2566 _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2567 $$ = make_node(scanner, NODE_TYPEDEF);
2568 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2569 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2571 | CTF_TYPEDEF declaration_specifiers field_class_declarator_list
2573 struct ctf_node *list;
2575 $$ = make_node(scanner, NODE_TYPEDEF);
2576 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2577 $$->u.field_class_def.field_class_specifier_list = list;
2578 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2579 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2581 | declaration_specifiers CTF_TYPEDEF field_class_declarator_list
2583 struct ctf_node *list;
2585 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2586 _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2587 $$ = make_node(scanner, NODE_TYPEDEF);
2588 ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2589 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2591 | CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
2593 struct ctf_node *list;
2595 $$ = make_node(scanner, NODE_TYPEALIAS);
2596 $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2597 $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2599 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2600 $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
2601 _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2602 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
2604 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2605 $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
2606 _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2607 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);