5 * Common Trace Format Metadata Grammar.
7 * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
9 * Permission is hereby granted, free of charge, to any person obtaining a copy
10 * of this software and associated documentation files (the "Software"), to deal
11 * in the Software without restriction, including without limitation the rights
12 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 * copies of the Software, and to permit persons to whom the Software is
14 * furnished to do so, subject to the following conditions:
16 * The above copyright notice and this permission notice shall be included in
17 * all copies or substantial portions of the Software.
28 #include <babeltrace/list.h>
29 #include "ctf-scanner.h"
30 #include "ctf-parser.h"
33 /* Join two lists, put "add" at the end of "head". */
35 _cds_list_splice_tail (struct cds_list_head *add, struct cds_list_head *head)
37 /* Do nothing if the list which gets added is empty. */
38 if (add != add->next) {
39 add->next->prev = head->prev;
40 add->prev->next = head;
41 head->prev->next = add->next;
42 head->prev = add->prev;
46 #define printf_dbg(fmt, args...) fprintf(stderr, "%s: " fmt, __func__, ## args)
48 int yyparse(struct ctf_scanner *scanner);
49 int yylex(union YYSTYPE *yyval, struct ctf_scanner *scanner);
50 int yylex_init_extra(struct ctf_scanner *scanner, yyscan_t * ptr_yy_globals);
51 int yylex_destroy(yyscan_t yyscanner) ;
52 void yyset_in(FILE * in_str, yyscan_t scanner);
57 struct cds_list_head gc;
62 static const char *node_type_to_str[] = {
63 [ NODE_UNKNOWN ] = "NODE_UNKNOWN",
64 [ NODE_ROOT ] = "NODE_ROOT",
65 [ NODE_EVENT ] = "NODE_EVENT",
66 [ NODE_STREAM ] = "NODE_STREAM",
67 [ NODE_TRACE ] = "NODE_TRACE",
68 [ NODE_CTF_EXPRESSION ] = "NODE_CTF_EXPRESSION",
69 [ NODE_UNARY_EXPRESSION ] = "NODE_UNARY_EXPRESSION",
70 [ NODE_TYPEDEF ] = "NODE_TYPEDEF",
71 [ NODE_TYPEALIAS_TARGET ] = "NODE_TYPEALIAS_TARGET",
72 [ NODE_TYPEALIAS_ALIAS ] = "NODE_TYPEALIAS_ALIAS",
73 [ NODE_TYPEALIAS ] = "NODE_TYPEALIAS",
74 [ NODE_TYPE_SPECIFIER ] = "NODE_TYPE_SPECIFIER",
75 [ NODE_POINTER ] = "NODE_POINTER",
76 [ NODE_TYPE_DECLARATOR ] = "NODE_TYPE_DECLARATOR",
77 [ NODE_FLOATING_POINT ] = "NODE_FLOATING_POINT",
78 [ NODE_INTEGER ] = "NODE_INTEGER",
79 [ NODE_STRING ] = "NODE_STRING",
80 [ NODE_ENUMERATOR ] = "NODE_ENUMERATOR",
81 [ NODE_ENUM ] = "NODE_ENUM",
82 [ NODE_STRUCT_OR_VARIANT_DECLARATION ] = "NODE_STRUCT_OR_VARIANT_DECLARATION",
83 [ NODE_VARIANT ] = "NODE_VARIANT",
84 [ NODE_STRUCT ] = "NODE_STRUCT",
87 const char *node_type(struct ctf_node *node)
89 if (node->type < NR_NODE_TYPES)
90 return node_type_to_str[node->type];
95 static struct gc_string *gc_string_alloc(struct ctf_scanner *scanner,
98 struct gc_string *gstr;
101 /* TODO: could be faster with find first bit or glib Gstring */
102 /* sizeof long to account for malloc header (int or long ?) */
103 for (alloclen = 8; alloclen < sizeof(long) + sizeof(*gstr) + len;
106 gstr = malloc(alloclen);
107 cds_list_add(&gstr->gc, &scanner->allocated_strings);
108 gstr->alloclen = alloclen;
113 * note: never use gc_string_append on a string that has external references.
114 * gsrc will be garbage collected immediately, and gstr might be.
115 * 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 cds_list_del(&gstr->gc);
139 strcat(gstr->s, gsrc->s);
141 cds_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_dbg("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_dbg("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_dbg("lookup %p %s %d\n", s, id, ret);
195 int is_type(struct ctf_scanner *scanner, const char *id)
197 struct ctf_scanner_scope *it;
200 for (it = scanner->cs; it != NULL; it = it->parent) {
201 if (lookup_type(it, id)) {
206 printf_dbg("is type %s %d\n", id, ret);
210 static void add_type(struct ctf_scanner *scanner, struct gc_string *id)
212 printf_dbg("add type %s\n", id->s);
213 if (lookup_type(scanner->cs, id->s))
215 g_hash_table_insert(scanner->cs->types, id->s, id->s);
218 static struct ctf_node *make_node(struct ctf_scanner *scanner,
221 struct ctf_ast *ast = ctf_scanner_get_ast(scanner);
222 struct ctf_node *node;
224 node = malloc(sizeof(*node));
227 memset(node, 0, sizeof(*node));
229 CDS_INIT_LIST_HEAD(&node->tmp_head);
230 cds_list_add(&node->gc, &ast->allocated_nodes);
231 cds_list_add(&node->siblings, &node->tmp_head);
235 fprintf(stderr, "[error] %s: trying to create root node\n", __func__);
239 CDS_INIT_LIST_HEAD(&node->u.event.declaration_list);
242 CDS_INIT_LIST_HEAD(&node->u.stream.declaration_list);
245 CDS_INIT_LIST_HEAD(&node->u.trace.declaration_list);
248 case NODE_CTF_EXPRESSION:
249 CDS_INIT_LIST_HEAD(&node->u.ctf_expression.left);
250 CDS_INIT_LIST_HEAD(&node->u.ctf_expression.right);
252 case NODE_UNARY_EXPRESSION:
256 CDS_INIT_LIST_HEAD(&node->u._typedef.declaration_specifier);
257 CDS_INIT_LIST_HEAD(&node->u._typedef.type_declarators);
259 case NODE_TYPEALIAS_TARGET:
260 CDS_INIT_LIST_HEAD(&node->u.typealias_target.declaration_specifier);
261 CDS_INIT_LIST_HEAD(&node->u.typealias_target.type_declarators);
263 case NODE_TYPEALIAS_ALIAS:
264 CDS_INIT_LIST_HEAD(&node->u.typealias_alias.declaration_specifier);
265 CDS_INIT_LIST_HEAD(&node->u.typealias_alias.type_declarators);
270 case NODE_TYPE_SPECIFIER:
274 case NODE_TYPE_DECLARATOR:
275 CDS_INIT_LIST_HEAD(&node->u.type_declarator.pointers);
278 case NODE_FLOATING_POINT:
279 CDS_INIT_LIST_HEAD(&node->u.floating_point.expressions);
282 CDS_INIT_LIST_HEAD(&node->u.integer.expressions);
285 CDS_INIT_LIST_HEAD(&node->u.string.expressions);
287 case NODE_ENUMERATOR:
288 CDS_INIT_LIST_HEAD(&node->u.enumerator.values);
291 CDS_INIT_LIST_HEAD(&node->u._enum.enumerator_list);
293 case NODE_STRUCT_OR_VARIANT_DECLARATION:
294 CDS_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.declaration_specifier);
295 CDS_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.type_declarators);
298 CDS_INIT_LIST_HEAD(&node->u.variant.declaration_list);
301 CDS_INIT_LIST_HEAD(&node->u._struct.declaration_list);
306 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
314 static int reparent_ctf_expression(struct ctf_node *node,
315 struct ctf_node *parent)
317 switch (parent->type) {
319 _cds_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
322 _cds_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
325 _cds_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
327 case NODE_FLOATING_POINT:
328 _cds_list_splice_tail(&node->tmp_head, &parent->u.floating_point.expressions);
331 _cds_list_splice_tail(&node->tmp_head, &parent->u.integer.expressions);
334 _cds_list_splice_tail(&node->tmp_head, &parent->u.string.expressions);
338 case NODE_CTF_EXPRESSION:
340 case NODE_TYPEALIAS_TARGET:
341 case NODE_TYPEALIAS_ALIAS:
343 case NODE_TYPE_SPECIFIER:
345 case NODE_TYPE_DECLARATOR:
346 case NODE_ENUMERATOR:
348 case NODE_STRUCT_OR_VARIANT_DECLARATION:
351 case NODE_UNARY_EXPRESSION:
356 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
363 static int reparent_typedef(struct ctf_node *node, struct ctf_node *parent)
365 switch (parent->type) {
367 _cds_list_splice_tail(&node->tmp_head, &parent->u.root._typedef);
370 _cds_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
373 _cds_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
376 _cds_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
379 _cds_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
382 _cds_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
385 case NODE_FLOATING_POINT:
388 case NODE_CTF_EXPRESSION:
390 case NODE_TYPEALIAS_TARGET:
391 case NODE_TYPEALIAS_ALIAS:
393 case NODE_TYPE_SPECIFIER:
395 case NODE_TYPE_DECLARATOR:
396 case NODE_ENUMERATOR:
398 case NODE_STRUCT_OR_VARIANT_DECLARATION:
399 case NODE_UNARY_EXPRESSION:
404 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
411 static int reparent_typealias(struct ctf_node *node, struct ctf_node *parent)
413 switch (parent->type) {
415 _cds_list_splice_tail(&node->tmp_head, &parent->u.root.typealias);
418 _cds_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
421 _cds_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
424 _cds_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
427 _cds_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
430 _cds_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
433 case NODE_FLOATING_POINT:
436 case NODE_CTF_EXPRESSION:
438 case NODE_TYPEALIAS_TARGET:
439 case NODE_TYPEALIAS_ALIAS:
441 case NODE_TYPE_SPECIFIER:
443 case NODE_TYPE_DECLARATOR:
444 case NODE_ENUMERATOR:
446 case NODE_STRUCT_OR_VARIANT_DECLARATION:
447 case NODE_UNARY_EXPRESSION:
452 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
459 static int reparent_type_specifier(struct ctf_node *node,
460 struct ctf_node *parent)
462 switch (parent->type) {
464 _cds_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_specifier);
467 _cds_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
470 _cds_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
473 _cds_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
476 _cds_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
479 _cds_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
482 _cds_list_splice_tail(&node->tmp_head, &parent->u._typedef.declaration_specifier);
484 case NODE_TYPEALIAS_TARGET:
485 _cds_list_splice_tail(&node->tmp_head, &parent->u.typealias_target.declaration_specifier);
487 case NODE_TYPEALIAS_ALIAS:
488 _cds_list_splice_tail(&node->tmp_head, &parent->u.typealias_alias.declaration_specifier);
490 case NODE_TYPE_DECLARATOR:
491 parent->u.type_declarator.type = TYPEDEC_NESTED;
492 parent->u.type_declarator.u.nested.length = node;
495 parent->u._enum.container_type = node;
497 case NODE_STRUCT_OR_VARIANT_DECLARATION:
498 _cds_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.declaration_specifier);
501 case NODE_FLOATING_POINT:
504 case NODE_CTF_EXPRESSION:
505 case NODE_TYPE_SPECIFIER:
507 case NODE_ENUMERATOR:
508 case NODE_UNARY_EXPRESSION:
513 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
520 static int reparent_type_declarator(struct ctf_node *node,
521 struct ctf_node *parent)
523 switch (parent->type) {
524 case NODE_TYPE_DECLARATOR:
525 parent->u.type_declarator.type = TYPEDEC_NESTED;
526 parent->u.type_declarator.u.nested.type_declarator = node;
528 case NODE_STRUCT_OR_VARIANT_DECLARATION:
529 _cds_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.type_declarators);
532 _cds_list_splice_tail(&node->tmp_head, &parent->u._typedef.type_declarators);
534 case NODE_TYPEALIAS_TARGET:
535 _cds_list_splice_tail(&node->tmp_head, &parent->u.typealias_target.type_declarators);
537 case NODE_TYPEALIAS_ALIAS:
538 _cds_list_splice_tail(&node->tmp_head, &parent->u.typealias_alias.type_declarators);
549 case NODE_FLOATING_POINT:
552 case NODE_CTF_EXPRESSION:
553 case NODE_TYPE_SPECIFIER:
555 case NODE_ENUMERATOR:
556 case NODE_UNARY_EXPRESSION:
561 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
571 * Link node to parent. Returns 0 on success, -EPERM if it is not permitted to
572 * create the link declared by the input, -ENOENT if node or parent is NULL,
573 * -EINVAL if there is an internal structure problem.
575 static int set_parent_node(struct ctf_node *node,
576 struct ctf_node *parent)
578 if (!node || !parent)
581 /* Note: Linking to parent will be done only by an external visitor */
583 switch (node->type) {
585 fprintf(stderr, "[error] %s: trying to reparent root node\n", __func__);
589 if (parent->type == NODE_ROOT) {
590 _cds_list_splice_tail(&node->tmp_head, &parent->u.root.event);
595 if (parent->type == NODE_ROOT) {
596 _cds_list_splice_tail(&node->tmp_head, &parent->u.root.stream);
601 if (parent->type == NODE_ROOT) {
602 _cds_list_splice_tail(&node->tmp_head, &parent->u.root.trace);
607 case NODE_CTF_EXPRESSION:
608 return reparent_ctf_expression(node, parent);
609 case NODE_UNARY_EXPRESSION:
610 if (parent->type == NODE_TYPE_DECLARATOR)
611 parent->u.type_declarator.bitfield_len = node;
617 return reparent_typedef(node, parent);
618 case NODE_TYPEALIAS_TARGET:
619 if (parent->type == NODE_TYPEALIAS)
620 parent->u.typealias.target = node;
623 case NODE_TYPEALIAS_ALIAS:
624 if (parent->type == NODE_TYPEALIAS)
625 parent->u.typealias.alias = node;
629 return reparent_typealias(node, parent);
632 if (parent->type == NODE_TYPE_DECLARATOR) {
633 _cds_list_splice_tail(&node->tmp_head, &parent->u.type_declarator.pointers);
637 case NODE_TYPE_DECLARATOR:
638 return reparent_type_declarator(node, parent);
640 case NODE_TYPE_SPECIFIER:
641 case NODE_FLOATING_POINT:
647 return reparent_type_specifier(node, parent);
649 case NODE_ENUMERATOR:
650 if (parent->type == NODE_ENUM) {
651 _cds_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
655 case NODE_STRUCT_OR_VARIANT_DECLARATION:
656 switch (parent->type) {
658 _cds_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
661 _cds_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
670 fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
677 void yyerror(struct ctf_scanner *scanner, const char *str)
679 fprintf(stderr, "error %s\n", str);
687 #define reparent_error(scanner, str) \
689 yyerror(scanner, YY_("reparent_error: " str "\n")); \
693 static void free_strings(struct cds_list_head *list)
695 struct gc_string *gstr, *tmp;
697 cds_list_for_each_entry_safe(gstr, tmp, list, gc)
701 static struct ctf_ast *ctf_ast_alloc(void)
705 ast = malloc(sizeof(*ast));
708 memset(ast, 0, sizeof(*ast));
709 CDS_INIT_LIST_HEAD(&ast->allocated_nodes);
710 ast->root.type = NODE_ROOT;
711 CDS_INIT_LIST_HEAD(&ast->root.tmp_head);
712 CDS_INIT_LIST_HEAD(&ast->root.u.root._typedef);
713 CDS_INIT_LIST_HEAD(&ast->root.u.root.typealias);
714 CDS_INIT_LIST_HEAD(&ast->root.u.root.declaration_specifier);
715 CDS_INIT_LIST_HEAD(&ast->root.u.root.trace);
716 CDS_INIT_LIST_HEAD(&ast->root.u.root.stream);
717 CDS_INIT_LIST_HEAD(&ast->root.u.root.event);
721 static void ctf_ast_free(struct ctf_ast *ast)
723 struct ctf_node *node, *tmp;
725 cds_list_for_each_entry_safe(node, tmp, &ast->allocated_nodes, gc)
729 int ctf_scanner_append_ast(struct ctf_scanner *scanner)
731 return yyparse(scanner);
734 struct ctf_scanner *ctf_scanner_alloc(FILE *input)
736 struct ctf_scanner *scanner;
739 scanner = malloc(sizeof(*scanner));
742 memset(scanner, 0, sizeof(*scanner));
744 ret = yylex_init_extra(scanner, &scanner->scanner);
746 fprintf(stderr, "yylex_init error\n");
747 goto cleanup_scanner;
749 yyset_in(input, scanner);
751 scanner->ast = ctf_ast_alloc();
754 init_scope(&scanner->root_scope, NULL);
755 scanner->cs = &scanner->root_scope;
756 CDS_INIT_LIST_HEAD(&scanner->allocated_strings);
761 ret = yylex_destroy(scanner->scanner);
763 fprintf(stderr, "yylex_destroy error\n");
769 void ctf_scanner_free(struct ctf_scanner *scanner)
773 finalize_scope(&scanner->root_scope);
774 free_strings(&scanner->allocated_strings);
775 ctf_ast_free(scanner->ast);
776 ret = yylex_destroy(scanner->scanner);
778 fprintf(stderr, "yylex_destroy error\n");
786 %parse-param {struct ctf_scanner *scanner}
787 %lex-param {struct ctf_scanner *scanner}
789 %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 EVENT FLOATING_POINT FLOAT INTEGER INT LONG SHORT SIGNED STREAM STRING STRUCT TRACE TYPEALIAS TYPEDEF UNSIGNED VARIANT VOID _BOOL _COMPLEX _IMAGINARY DECIMAL_CONSTANT OCTAL_CONSTANT HEXADECIMAL_CONSTANT
790 %token <gs> IDENTIFIER ID_TYPE
796 struct gc_string *gs;
801 %type <gs> s_char s_char_sequence c_char c_char_sequence
803 %type <n> postfix_expression unary_expression unary_expression_or_range
805 %type <n> declaration
806 %type <n> event_declaration
807 %type <n> stream_declaration
808 %type <n> trace_declaration
809 %type <n> declaration_specifiers
811 %type <n> type_declarator_list
812 %type <n> abstract_type_declarator_list
813 %type <n> type_specifier
814 %type <n> struct_type_specifier
815 %type <n> variant_type_specifier
816 %type <n> type_specifier_or_integer_constant
817 %type <n> enum_type_specifier
818 %type <n> struct_or_variant_declaration_list
819 %type <n> struct_or_variant_declaration
820 %type <n> specifier_qualifier_list
821 %type <n> struct_or_variant_declarator_list
822 %type <n> struct_or_variant_declarator
823 %type <n> enumerator_list
825 %type <n> abstract_declarator_list
826 %type <n> abstract_declarator
827 %type <n> direct_abstract_declarator
829 %type <n> direct_declarator
830 %type <n> type_declarator
831 %type <n> direct_type_declarator
832 %type <n> abstract_type_declarator
833 %type <n> direct_abstract_type_declarator
835 %type <n> ctf_assignment_expression_list
836 %type <n> ctf_assignment_expression
843 if (set_parent_node($1, &ctf_scanner_get_ast(scanner)->root))
844 reparent_error(scanner, "error reparenting to root");
848 if (set_parent_node($2, &ctf_scanner_get_ast(scanner)->root))
849 reparent_error(scanner, "error reparenting to root");
905 | c_char_sequence c_char
906 { $$ = gc_string_append(scanner, $1, $2); }
914 reparent_error(scanner, "escape sequences not supported yet");
918 /* 1.6 String literals */
923 | s_char_sequence s_char
924 { $$ = gc_string_append(scanner, $1, $2); }
932 reparent_error(scanner, "escape sequences not supported yet");
936 /* 2: Phrase structure grammar */
941 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
942 $$->u.unary_expression.type = UNARY_STRING;
943 $$->u.unary_expression.u.string = yylval.gs->s;
947 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
948 $$->u.unary_expression.type = UNARY_STRING;
949 $$->u.unary_expression.u.string = yylval.gs->s;
953 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
954 $$->u.unary_expression.type = UNARY_STRING;
955 $$->u.unary_expression.u.string = yylval.gs->s;
960 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
961 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
962 sscanf(yylval.gs->s, "%" PRIu64,
963 &$$->u.unary_expression.u.unsigned_constant);
967 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
968 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
969 sscanf(yylval.gs->s, "0%" PRIo64,
970 &$$->u.unary_expression.u.unsigned_constant);
972 | HEXADECIMAL_CONSTANT
974 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
975 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
976 sscanf(yylval.gs->s, "0x%" PRIx64,
977 &$$->u.unary_expression.u.unsigned_constant);
979 | STRING_LITERAL_START DQUOTE
981 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
982 $$->u.unary_expression.type = UNARY_STRING;
983 $$->u.unary_expression.u.string = "";
985 | STRING_LITERAL_START s_char_sequence DQUOTE
987 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
988 $$->u.unary_expression.type = UNARY_STRING;
989 $$->u.unary_expression.u.string = $2->s;
991 | CHARACTER_CONSTANT_START c_char_sequence SQUOTE
993 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
994 $$->u.unary_expression.type = UNARY_STRING;
995 $$->u.unary_expression.u.string = $2->s;
997 | LPAREN unary_expression RPAREN
999 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1000 $$->u.unary_expression.type = UNARY_NESTED;
1001 $$->u.unary_expression.u.nested_exp = $2;
1003 | postfix_expression LSBRAC unary_expression RSBRAC
1005 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1006 $$->u.unary_expression.type = UNARY_SBRAC;
1007 $$->u.unary_expression.u.sbrac_exp = $3;
1008 cds_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1009 cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1011 | postfix_expression DOT IDENTIFIER
1013 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1014 $$->u.unary_expression.type = UNARY_STRING;
1015 $$->u.unary_expression.u.string = yylval.gs->s;
1016 $$->u.unary_expression.link = UNARY_DOTLINK;
1017 cds_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1018 cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1020 | postfix_expression DOT ID_TYPE
1022 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1023 $$->u.unary_expression.type = UNARY_STRING;
1024 $$->u.unary_expression.u.string = yylval.gs->s;
1025 $$->u.unary_expression.link = UNARY_DOTLINK;
1026 cds_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1027 cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1029 | postfix_expression RARROW IDENTIFIER
1031 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1032 $$->u.unary_expression.type = UNARY_STRING;
1033 $$->u.unary_expression.u.string = yylval.gs->s;
1034 $$->u.unary_expression.link = UNARY_ARROWLINK;
1035 cds_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1036 cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1038 | postfix_expression RARROW ID_TYPE
1040 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1041 $$->u.unary_expression.type = UNARY_STRING;
1042 $$->u.unary_expression.u.string = yylval.gs->s;
1043 $$->u.unary_expression.link = UNARY_ARROWLINK;
1044 cds_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1045 cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1052 | PLUS postfix_expression
1054 | MINUS postfix_expression
1057 if ($$->u.unary_expression.type != UNARY_SIGNED_CONSTANT
1058 && $$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT)
1059 reparent_error(scanner, "expecting numeric constant");
1061 if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1062 $$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
1063 $$->u.unary_expression.u.signed_constant =
1064 -($$->u.unary_expression.u.unsigned_constant);
1066 $$->u.unary_expression.u.signed_constant =
1067 -($$->u.unary_expression.u.signed_constant);
1072 unary_expression_or_range:
1073 unary_expression DOTDOTDOT unary_expression
1076 _cds_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
1077 $3->u.unary_expression.link = UNARY_DOTDOTDOT;
1083 /* 2.2: Declarations */
1086 declaration_specifiers SEMICOLON
1090 | stream_declaration
1094 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
1096 $$ = make_node(scanner, NODE_TYPEDEF);
1097 _cds_list_splice_tail(&($1)->tmp_head, &($$)->u._typedef.declaration_specifier);
1098 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.declaration_specifier);
1099 _cds_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
1101 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
1103 $$ = make_node(scanner, NODE_TYPEDEF);
1104 _cds_list_splice_tail(&($2)->tmp_head, &($$)->u._typedef.declaration_specifier);
1105 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
1107 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
1109 $$ = make_node(scanner, NODE_TYPEDEF);
1110 _cds_list_splice_tail(&($1)->tmp_head, &($$)->u._typedef.declaration_specifier);
1111 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
1113 | TYPEALIAS declaration_specifiers abstract_declarator_list COLON declaration_specifiers abstract_type_declarator_list SEMICOLON
1115 $$ = make_node(scanner, NODE_TYPEALIAS);
1116 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1117 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1118 _cds_list_splice_tail(&($2)->tmp_head, &($$)->u.typealias.target->u.typealias_target.declaration_specifier);
1119 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
1120 _cds_list_splice_tail(&($5)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.declaration_specifier);
1121 _cds_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
1123 | TYPEALIAS declaration_specifiers abstract_declarator_list COLON type_declarator_list SEMICOLON
1125 $$ = make_node(scanner, NODE_TYPEALIAS);
1126 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1127 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1128 _cds_list_splice_tail(&($2)->tmp_head, &($$)->u.typealias.target->u.typealias_target.declaration_specifier);
1129 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.declaration_specifier);
1130 _cds_list_splice_tail(&($5)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
1135 event_declaration_begin event_declaration_end
1137 $$ = make_node(scanner, NODE_EVENT);
1139 | event_declaration_begin ctf_assignment_expression_list event_declaration_end
1141 $$ = make_node(scanner, NODE_EVENT);
1142 if (set_parent_node($2, $$))
1143 reparent_error(scanner, "event_declaration");
1147 event_declaration_begin:
1149 { push_scope(scanner); }
1152 event_declaration_end:
1154 { pop_scope(scanner); }
1159 stream_declaration_begin stream_declaration_end
1161 $$ = make_node(scanner, NODE_STREAM);
1163 | stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
1165 $$ = make_node(scanner, NODE_STREAM);
1166 if (set_parent_node($2, $$))
1167 reparent_error(scanner, "stream_declaration");
1171 stream_declaration_begin:
1173 { push_scope(scanner); }
1176 stream_declaration_end:
1178 { pop_scope(scanner); }
1183 trace_declaration_begin trace_declaration_end
1185 $$ = make_node(scanner, NODE_TRACE);
1187 | trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
1189 $$ = make_node(scanner, NODE_TRACE);
1190 if (set_parent_node($2, $$))
1191 reparent_error(scanner, "trace_declaration");
1195 trace_declaration_begin:
1197 { push_scope(scanner); }
1200 trace_declaration_end:
1202 { pop_scope(scanner); }
1205 declaration_specifiers:
1208 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1209 $$->u.type_specifier.type = TYPESPEC_CONST;
1213 | declaration_specifiers CONST
1215 struct ctf_node *node;
1218 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1219 node->u.type_specifier.type = TYPESPEC_CONST;
1220 cds_list_add_tail(&node->siblings, &($$)->tmp_head);
1222 | declaration_specifiers type_specifier
1225 cds_list_add_tail(&($2)->siblings, &($$)->tmp_head);
1229 type_declarator_list:
1232 | type_declarator_list COMMA type_declarator
1235 cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1239 abstract_type_declarator_list:
1240 abstract_type_declarator
1242 | abstract_type_declarator_list COMMA abstract_type_declarator
1245 cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1252 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1253 $$->u.type_specifier.type = TYPESPEC_VOID;
1257 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1258 $$->u.type_specifier.type = TYPESPEC_CHAR;
1262 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1263 $$->u.type_specifier.type = TYPESPEC_SHORT;
1267 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1268 $$->u.type_specifier.type = TYPESPEC_INT;
1272 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1273 $$->u.type_specifier.type = TYPESPEC_LONG;
1277 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1278 $$->u.type_specifier.type = TYPESPEC_FLOAT;
1282 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1283 $$->u.type_specifier.type = TYPESPEC_DOUBLE;
1287 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1288 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1292 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1293 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1297 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1298 $$->u.type_specifier.type = TYPESPEC_BOOL;
1302 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1303 $$->u.type_specifier.type = TYPESPEC_COMPLEX;
1307 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1308 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
1309 $$->u.type_specifier.id_type = yylval.gs->s;
1311 | FLOATING_POINT LBRAC RBRAC
1313 $$ = make_node(scanner, NODE_FLOATING_POINT);
1315 | FLOATING_POINT LBRAC ctf_assignment_expression_list RBRAC
1317 $$ = make_node(scanner, NODE_FLOATING_POINT);
1318 if (set_parent_node($3, $$))
1319 reparent_error(scanner, "floating point reparent error");
1321 | INTEGER LBRAC RBRAC
1323 $$ = make_node(scanner, NODE_INTEGER);
1325 | INTEGER LBRAC ctf_assignment_expression_list RBRAC
1327 $$ = make_node(scanner, NODE_INTEGER);
1328 if (set_parent_node($3, $$))
1329 reparent_error(scanner, "integer reparent error");
1331 | STRING LBRAC RBRAC
1333 $$ = make_node(scanner, NODE_STRING);
1335 | STRING LBRAC ctf_assignment_expression_list RBRAC
1337 $$ = make_node(scanner, NODE_STRING);
1338 if (set_parent_node($3, $$))
1339 reparent_error(scanner, "string reparent error");
1341 | ENUM enum_type_specifier
1343 | VARIANT variant_type_specifier
1345 | STRUCT struct_type_specifier
1349 struct_type_specifier:
1350 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1352 $$ = make_node(scanner, NODE_STRUCT);
1353 if (set_parent_node($2, $$))
1354 reparent_error(scanner, "struct reparent error");
1356 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1358 $$ = make_node(scanner, NODE_STRUCT);
1359 $$->u._struct.name = $1->s;
1360 if (set_parent_node($3, $$))
1361 reparent_error(scanner, "struct reparent error");
1363 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1365 $$ = make_node(scanner, NODE_STRUCT);
1366 $$->u._struct.name = $1->s;
1367 if (set_parent_node($3, $$))
1368 reparent_error(scanner, "struct reparent error");
1372 $$ = make_node(scanner, NODE_STRUCT);
1373 $$->u._struct.name = $1->s;
1377 $$ = make_node(scanner, NODE_STRUCT);
1378 $$->u._struct.name = $1->s;
1382 struct_declaration_begin:
1384 { push_scope(scanner); }
1387 struct_declaration_end:
1389 { pop_scope(scanner); }
1392 variant_type_specifier:
1393 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1395 $$ = make_node(scanner, NODE_VARIANT);
1396 if (set_parent_node($2, $$))
1397 reparent_error(scanner, "variant reparent error");
1399 | LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1401 $$ = make_node(scanner, NODE_VARIANT);
1402 $$->u.variant.choice = $2->s;
1403 if (set_parent_node($5, $$))
1404 reparent_error(scanner, "variant reparent error");
1406 | LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1408 $$ = make_node(scanner, NODE_VARIANT);
1409 $$->u.variant.choice = $2->s;
1410 if (set_parent_node($5, $$))
1411 reparent_error(scanner, "variant reparent error");
1413 | IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1415 $$ = make_node(scanner, NODE_VARIANT);
1416 $$->u.variant.name = $1->s;
1417 if (set_parent_node($3, $$))
1418 reparent_error(scanner, "variant reparent error");
1420 | IDENTIFIER LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1422 $$ = make_node(scanner, NODE_VARIANT);
1423 $$->u.variant.name = $1->s;
1424 $$->u.variant.choice = $3->s;
1425 if (set_parent_node($6, $$))
1426 reparent_error(scanner, "variant reparent error");
1428 | IDENTIFIER LT IDENTIFIER GT
1430 $$ = make_node(scanner, NODE_VARIANT);
1431 $$->u.variant.name = $1->s;
1432 $$->u.variant.choice = $3->s;
1434 | IDENTIFIER LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1436 $$ = make_node(scanner, NODE_VARIANT);
1437 $$->u.variant.name = $1->s;
1438 $$->u.variant.choice = $3->s;
1439 if (set_parent_node($6, $$))
1440 reparent_error(scanner, "variant reparent error");
1442 | IDENTIFIER LT ID_TYPE GT
1444 $$ = make_node(scanner, NODE_VARIANT);
1445 $$->u.variant.name = $1->s;
1446 $$->u.variant.choice = $3->s;
1448 | ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1450 $$ = make_node(scanner, NODE_VARIANT);
1451 $$->u.variant.name = $1->s;
1452 if (set_parent_node($3, $$))
1453 reparent_error(scanner, "variant reparent error");
1455 | ID_TYPE LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1457 $$ = make_node(scanner, NODE_VARIANT);
1458 $$->u.variant.name = $1->s;
1459 $$->u.variant.choice = $3->s;
1460 if (set_parent_node($6, $$))
1461 reparent_error(scanner, "variant reparent error");
1463 | ID_TYPE LT IDENTIFIER GT
1465 $$ = make_node(scanner, NODE_VARIANT);
1466 $$->u.variant.name = $1->s;
1467 $$->u.variant.choice = $3->s;
1469 | ID_TYPE LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1471 $$ = make_node(scanner, NODE_VARIANT);
1472 $$->u.variant.name = $1->s;
1473 $$->u.variant.choice = $3->s;
1474 if (set_parent_node($6, $$))
1475 reparent_error(scanner, "variant reparent error");
1477 | ID_TYPE LT ID_TYPE GT
1479 $$ = make_node(scanner, NODE_VARIANT);
1480 $$->u.variant.name = $1->s;
1481 $$->u.variant.choice = $3->s;
1485 variant_declaration_begin:
1487 { push_scope(scanner); }
1490 variant_declaration_end:
1492 { pop_scope(scanner); }
1495 type_specifier_or_integer_constant:
1496 declaration_specifiers
1500 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1501 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1502 sscanf(yylval.gs->s, "%" PRIu64,
1503 &$$->u.unary_expression.u.unsigned_constant);
1507 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1508 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1509 sscanf(yylval.gs->s, "0%" PRIo64,
1510 &$$->u.unary_expression.u.unsigned_constant);
1512 | HEXADECIMAL_CONSTANT
1514 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1515 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1516 sscanf(yylval.gs->s, "0x%" PRIx64,
1517 &$$->u.unary_expression.u.unsigned_constant);
1521 enum_type_specifier:
1522 LBRAC enumerator_list RBRAC
1524 $$ = make_node(scanner, NODE_ENUM);
1525 _cds_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
1527 | LT type_specifier_or_integer_constant GT LBRAC enumerator_list RBRAC
1529 $$ = make_node(scanner, NODE_ENUM);
1530 $$->u._enum.container_type = $2;
1531 _cds_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
1533 | IDENTIFIER LBRAC enumerator_list RBRAC
1535 $$ = make_node(scanner, NODE_ENUM);
1536 $$->u._enum.enum_id = $1->s;
1537 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1539 | IDENTIFIER LT type_specifier_or_integer_constant GT LBRAC enumerator_list RBRAC
1541 $$ = make_node(scanner, NODE_ENUM);
1542 $$->u._enum.enum_id = $1->s;
1543 $$->u._enum.container_type = $3;
1544 _cds_list_splice_tail(&($6)->tmp_head, &($$)->u._enum.enumerator_list);
1546 | ID_TYPE LBRAC enumerator_list RBRAC
1548 $$ = make_node(scanner, NODE_ENUM);
1549 $$->u._enum.enum_id = $1->s;
1550 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1552 | ID_TYPE LT type_specifier_or_integer_constant GT LBRAC enumerator_list RBRAC
1554 $$ = make_node(scanner, NODE_ENUM);
1555 $$->u._enum.enum_id = $1->s;
1556 $$->u._enum.container_type = $3;
1557 _cds_list_splice_tail(&($6)->tmp_head, &($$)->u._enum.enumerator_list);
1559 | LBRAC enumerator_list COMMA RBRAC
1561 $$ = make_node(scanner, NODE_ENUM);
1562 _cds_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
1564 | LT type_specifier_or_integer_constant GT LBRAC enumerator_list COMMA RBRAC
1566 $$ = make_node(scanner, NODE_ENUM);
1567 $$->u._enum.container_type = $2;
1568 _cds_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
1570 | IDENTIFIER LBRAC enumerator_list COMMA RBRAC
1572 $$ = make_node(scanner, NODE_ENUM);
1573 $$->u._enum.enum_id = $1->s;
1574 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1576 | IDENTIFIER LT type_specifier_or_integer_constant GT LBRAC enumerator_list COMMA RBRAC
1578 $$ = make_node(scanner, NODE_ENUM);
1579 $$->u._enum.enum_id = $1->s;
1580 $$->u._enum.container_type = $3;
1581 _cds_list_splice_tail(&($6)->tmp_head, &($$)->u._enum.enumerator_list);
1585 $$ = make_node(scanner, NODE_ENUM);
1586 $$->u._enum.enum_id = $1->s;
1588 | IDENTIFIER LT type_specifier_or_integer_constant GT
1590 $$ = make_node(scanner, NODE_ENUM);
1591 $$->u._enum.enum_id = $1->s;
1592 $$->u._enum.container_type = $3;
1594 | ID_TYPE LBRAC enumerator_list COMMA RBRAC
1596 $$ = make_node(scanner, NODE_ENUM);
1597 $$->u._enum.enum_id = $1->s;
1598 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
1600 | ID_TYPE LT type_specifier_or_integer_constant GT LBRAC enumerator_list COMMA RBRAC
1602 $$ = make_node(scanner, NODE_ENUM);
1603 $$->u._enum.enum_id = $1->s;
1604 $$->u._enum.container_type = $3;
1605 _cds_list_splice_tail(&($6)->tmp_head, &($$)->u._enum.enumerator_list);
1609 $$ = make_node(scanner, NODE_ENUM);
1610 $$->u._enum.enum_id = $1->s;
1612 | ID_TYPE LT type_specifier_or_integer_constant GT
1614 $$ = make_node(scanner, NODE_ENUM);
1615 $$->u._enum.enum_id = $1->s;
1616 $$->u._enum.container_type = $3;
1620 struct_or_variant_declaration_list:
1623 | struct_or_variant_declaration_list struct_or_variant_declaration
1627 cds_list_add_tail(&($2)->siblings, &($$)->tmp_head);
1630 cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1635 struct_or_variant_declaration:
1636 specifier_qualifier_list struct_or_variant_declarator_list SEMICOLON
1638 $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
1639 _cds_list_splice_tail(&($1)->tmp_head, &($$)->u.struct_or_variant_declaration.declaration_specifier);
1640 _cds_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
1642 | specifier_qualifier_list TYPEDEF specifier_qualifier_list type_declarator_list SEMICOLON
1644 $$ = make_node(scanner, NODE_TYPEDEF);
1645 _cds_list_splice_tail(&($1)->tmp_head, &($$)->u._typedef.declaration_specifier);
1646 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.declaration_specifier);
1647 _cds_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
1649 | TYPEDEF specifier_qualifier_list type_declarator_list SEMICOLON
1651 $$ = make_node(scanner, NODE_TYPEDEF);
1652 _cds_list_splice_tail(&($2)->tmp_head, &($$)->u._typedef.declaration_specifier);
1653 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
1655 | specifier_qualifier_list TYPEDEF type_declarator_list SEMICOLON
1657 $$ = make_node(scanner, NODE_TYPEDEF);
1658 _cds_list_splice_tail(&($1)->tmp_head, &($$)->u._typedef.declaration_specifier);
1659 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
1661 | TYPEALIAS specifier_qualifier_list abstract_declarator_list COLON specifier_qualifier_list abstract_type_declarator_list SEMICOLON
1663 $$ = make_node(scanner, NODE_TYPEALIAS);
1664 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1665 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1666 _cds_list_splice_tail(&($2)->tmp_head, &($$)->u.typealias.target->u.typealias_target.declaration_specifier);
1667 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
1668 _cds_list_splice_tail(&($5)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.declaration_specifier);
1669 _cds_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
1671 | TYPEALIAS specifier_qualifier_list abstract_declarator_list COLON type_declarator_list SEMICOLON
1673 $$ = make_node(scanner, NODE_TYPEALIAS);
1674 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1675 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1676 _cds_list_splice_tail(&($2)->tmp_head, &($$)->u.typealias.target->u.typealias_target.declaration_specifier);
1677 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.declaration_specifier);
1678 _cds_list_splice_tail(&($5)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
1682 specifier_qualifier_list:
1685 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1686 $$->u.type_specifier.type = TYPESPEC_CONST;
1690 | specifier_qualifier_list CONST
1692 struct ctf_node *node;
1695 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1696 node->u.type_specifier.type = TYPESPEC_CONST;
1697 cds_list_add_tail(&node->siblings, &($$)->tmp_head);
1699 | specifier_qualifier_list type_specifier
1702 cds_list_add_tail(&($2)->siblings, &($$)->tmp_head);
1706 struct_or_variant_declarator_list:
1707 struct_or_variant_declarator
1709 | struct_or_variant_declarator_list COMMA struct_or_variant_declarator
1712 cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1716 struct_or_variant_declarator:
1719 | COLON unary_expression
1721 | declarator COLON unary_expression
1724 if (set_parent_node($3, $1))
1725 reparent_error(scanner, "struct_or_variant_declarator");
1732 | enumerator_list COMMA enumerator
1735 cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1742 $$ = make_node(scanner, NODE_ENUMERATOR);
1743 $$->u.enumerator.id = $1->s;
1747 $$ = make_node(scanner, NODE_ENUMERATOR);
1748 $$->u.enumerator.id = $1->s;
1752 $$ = make_node(scanner, NODE_ENUMERATOR);
1753 $$->u.enumerator.id = $1->s;
1755 | STRING_LITERAL_START DQUOTE
1757 $$ = make_node(scanner, NODE_ENUMERATOR);
1758 $$->u.enumerator.id = "";
1760 | STRING_LITERAL_START s_char_sequence DQUOTE
1762 $$ = make_node(scanner, NODE_ENUMERATOR);
1763 $$->u.enumerator.id = $2->s;
1765 | IDENTIFIER EQUAL unary_expression_or_range
1767 $$ = make_node(scanner, NODE_ENUMERATOR);
1768 $$->u.enumerator.id = $1->s;
1769 cds_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
1771 | ID_TYPE EQUAL unary_expression_or_range
1773 $$ = make_node(scanner, NODE_ENUMERATOR);
1774 $$->u.enumerator.id = $1->s;
1775 cds_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
1777 | keywords EQUAL unary_expression_or_range
1779 $$ = make_node(scanner, NODE_ENUMERATOR);
1780 $$->u.enumerator.id = $1->s;
1781 cds_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
1783 | STRING_LITERAL_START DQUOTE EQUAL unary_expression_or_range
1785 $$ = make_node(scanner, NODE_ENUMERATOR);
1786 $$->u.enumerator.id = "";
1787 cds_list_splice(&($4)->tmp_head, &($$)->u.enumerator.values);
1789 | STRING_LITERAL_START s_char_sequence DQUOTE EQUAL unary_expression_or_range
1791 $$ = make_node(scanner, NODE_ENUMERATOR);
1792 $$->u.enumerator.id = $2->s;
1793 cds_list_splice(&($5)->tmp_head, &($$)->u.enumerator.values);
1797 abstract_declarator_list:
1800 | abstract_declarator_list COMMA abstract_declarator
1803 cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1807 abstract_declarator:
1808 direct_abstract_declarator
1810 | pointer direct_abstract_declarator
1813 cds_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
1817 direct_abstract_declarator:
1820 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1821 $$->u.type_declarator.type = TYPEDEC_ID;
1826 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1827 $$->u.type_declarator.type = TYPEDEC_ID;
1828 $$->u.type_declarator.u.id = $1->s;
1830 | LPAREN abstract_declarator RPAREN
1832 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1833 $$->u.type_declarator.type = TYPEDEC_NESTED;
1834 $$->u.type_declarator.u.nested.type_declarator = $2;
1836 | direct_abstract_declarator LSBRAC type_specifier_or_integer_constant RSBRAC
1838 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1839 $$->u.type_declarator.type = TYPEDEC_NESTED;
1840 $$->u.type_declarator.u.nested.type_declarator = $1;
1841 $$->u.type_declarator.u.nested.length = $3;
1843 | direct_abstract_declarator LSBRAC RSBRAC
1845 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1846 $$->u.type_declarator.type = TYPEDEC_NESTED;
1847 $$->u.type_declarator.u.nested.type_declarator = $1;
1848 $$->u.type_declarator.u.nested.abstract_array = 1;
1855 | pointer direct_declarator
1858 cds_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
1865 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1866 $$->u.type_declarator.type = TYPEDEC_ID;
1867 $$->u.type_declarator.u.id = $1->s;
1869 | LPAREN declarator RPAREN
1871 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1872 $$->u.type_declarator.type = TYPEDEC_NESTED;
1873 $$->u.type_declarator.u.nested.type_declarator = $2;
1875 | direct_declarator LSBRAC type_specifier_or_integer_constant RSBRAC
1877 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1878 $$->u.type_declarator.type = TYPEDEC_NESTED;
1879 $$->u.type_declarator.u.nested.type_declarator = $1;
1880 $$->u.type_declarator.u.nested.length = $3;
1885 direct_type_declarator
1887 | pointer direct_type_declarator
1890 cds_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
1894 direct_type_declarator:
1897 add_type(scanner, $1);
1898 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1899 $$->u.type_declarator.type = TYPEDEC_ID;
1900 $$->u.type_declarator.u.id = $1->s;
1902 | LPAREN type_declarator RPAREN
1904 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1905 $$->u.type_declarator.type = TYPEDEC_NESTED;
1906 $$->u.type_declarator.u.nested.type_declarator = $2;
1908 | direct_type_declarator LSBRAC type_specifier_or_integer_constant RSBRAC
1910 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1911 $$->u.type_declarator.type = TYPEDEC_NESTED;
1912 $$->u.type_declarator.u.nested.type_declarator = $1;
1913 $$->u.type_declarator.u.nested.length = $3;
1917 abstract_type_declarator:
1918 direct_abstract_type_declarator
1920 | pointer direct_abstract_type_declarator
1923 cds_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
1927 direct_abstract_type_declarator:
1930 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1931 $$->u.type_declarator.type = TYPEDEC_ID;
1936 add_type(scanner, $1);
1937 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1938 $$->u.type_declarator.type = TYPEDEC_ID;
1939 $$->u.type_declarator.u.id = $1->s;
1941 | LPAREN abstract_type_declarator RPAREN
1943 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1944 $$->u.type_declarator.type = TYPEDEC_NESTED;
1945 $$->u.type_declarator.u.nested.type_declarator = $2;
1947 | direct_abstract_type_declarator LSBRAC type_specifier_or_integer_constant RSBRAC
1949 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1950 $$->u.type_declarator.type = TYPEDEC_NESTED;
1951 $$->u.type_declarator.u.nested.type_declarator = $1;
1952 $$->u.type_declarator.u.nested.length = $3;
1954 | direct_abstract_type_declarator LSBRAC RSBRAC
1956 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
1957 $$->u.type_declarator.type = TYPEDEC_NESTED;
1958 $$->u.type_declarator.u.nested.type_declarator = $1;
1959 $$->u.type_declarator.u.nested.abstract_array = 1;
1966 $$ = make_node(scanner, NODE_POINTER);
1970 $$ = make_node(scanner, NODE_POINTER);
1971 cds_list_splice(&($2)->tmp_head, &($$)->tmp_head);
1973 | STAR type_qualifier_list pointer
1975 $$ = make_node(scanner, NODE_POINTER);
1976 $$->u.pointer.const_qualifier = 1;
1977 cds_list_splice(&($3)->tmp_head, &($$)->tmp_head);
1981 type_qualifier_list:
1982 /* pointer assumes only const type qualifier */
1984 | type_qualifier_list CONST
1987 /* 2.3: CTF-specific declarations */
1989 ctf_assignment_expression_list:
1990 ctf_assignment_expression SEMICOLON
1992 | ctf_assignment_expression_list ctf_assignment_expression SEMICOLON
1995 cds_list_add_tail(&($2)->siblings, &($$)->tmp_head);
1999 ctf_assignment_expression:
2000 unary_expression EQUAL unary_expression
2003 * Because we have left and right, cannot use
2006 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2007 _cds_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2008 if ($1->u.unary_expression.type != UNARY_STRING)
2009 reparent_error(scanner, "ctf_assignment_expression left expects string");
2010 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
2012 | unary_expression TYPEASSIGN type_specifier
2015 * Because we have left and right, cannot use
2018 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2019 _cds_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2020 if ($1->u.unary_expression.type != UNARY_STRING)
2021 reparent_error(scanner, "ctf_assignment_expression left expects string");
2022 cds_list_add(&($3)->siblings, &($3)->tmp_head);
2023 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
2025 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list
2027 $$ = make_node(scanner, NODE_TYPEDEF);
2028 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.declaration_specifier);
2029 _cds_list_splice_tail(&($1)->tmp_head, &($$)->u._typedef.declaration_specifier);
2030 _cds_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
2032 | TYPEDEF declaration_specifiers type_declarator_list
2034 $$ = make_node(scanner, NODE_TYPEDEF);
2035 _cds_list_splice_tail(&($2)->tmp_head, &($$)->u._typedef.declaration_specifier);
2036 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2038 | declaration_specifiers TYPEDEF type_declarator_list
2040 $$ = make_node(scanner, NODE_TYPEDEF);
2041 _cds_list_splice_tail(&($1)->tmp_head, &($$)->u._typedef.declaration_specifier);
2042 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
2044 | TYPEALIAS declaration_specifiers abstract_declarator_list COLON declaration_specifiers abstract_type_declarator_list
2046 $$ = make_node(scanner, NODE_TYPEALIAS);
2047 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2048 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2049 _cds_list_splice_tail(&($2)->tmp_head, &($$)->u.typealias.target->u.typealias_target.declaration_specifier);
2050 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
2051 _cds_list_splice_tail(&($5)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.declaration_specifier);
2052 _cds_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
2054 | TYPEALIAS declaration_specifiers abstract_declarator_list COLON type_declarator_list
2056 $$ = make_node(scanner, NODE_TYPEALIAS);
2057 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2058 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2059 _cds_list_splice_tail(&($2)->tmp_head, &($$)->u.typealias.target->u.typealias_target.declaration_specifier);
2060 _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.declaration_specifier);
2061 _cds_list_splice_tail(&($5)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);