projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Remove unused gc field
[babeltrace.git] / formats / ctf / metadata / ctf-parser.y
CommitLineData
8b9d5b5e
MD		 1%{
2/*
c59a87f5 3 * ctf-parser.y
8b9d5b5e
MD		 4 *
5 * Common Trace Format Metadata Grammar.
c59a87f5
MD		 6 *
7 * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 *
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:
15 *
16 * The above copyright notice and this permission notice shall be included in
17 * all copies or substantial portions of the Software.
c462e188
MD		 18 *
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
25 * SOFTWARE.
8b9d5b5e
MD		 26 */
27
28#include <stdio.h>
d876a5ba 29#include <ctype.h>
8b9d5b5e
MD		 30#include <unistd.h>
31#include <string.h>
32#include <stdlib.h>
33#include <assert.h>
8b9d5b5e 34#include <glib.h>
02b234c4 35#include <errno.h>
380d60b1 36#include <inttypes.h>
fe41395a 37#include <babeltrace/list.h>
70bd0a12 38#include <babeltrace/babeltrace-internal.h>
34d3acc4 39#include "ctf-scanner.h"
8b9d5b5e
MD		 40#include "ctf-parser.h"
41#include "ctf-ast.h"
8aa95b17 42#include "objstack.h"
8b9d5b5e 43
5d6c80a5 44BT_HIDDEN
a3983482
MD		 45int yydebug;
46
48a01768
MD		 47/* Join two lists, put "add" at the end of "head". */
48static inline void
3122e6f0 49_bt_list_splice_tail (struct bt_list_head *add, struct bt_list_head *head)
48a01768
MD		 50{
51 /* Do nothing if the list which gets added is empty. */
52 if (add != add->next) {
53 add->next->prev = head->prev;
54 add->prev->next = head;
55 head->prev->next = add->next;
56 head->prev = add->prev;
57 }
58}
59
5d6c80a5 60BT_HIDDEN
34d3acc4 61int yyparse(struct ctf_scanner *scanner);
5d6c80a5 62BT_HIDDEN
34d3acc4 63int yylex(union YYSTYPE *yyval, struct ctf_scanner *scanner);
5d6c80a5 64BT_HIDDEN
34d3acc4 65int yylex_init_extra(struct ctf_scanner *scanner, yyscan_t * ptr_yy_globals);
5d6c80a5 66BT_HIDDEN
61e9d0ce 67int yylex_destroy(yyscan_t yyscanner);
5d6c80a5 68BT_HIDDEN
65102a8c 69void yyrestart(FILE * in_str, yyscan_t scanner);
8c834e5a
MD		 70BT_HIDDEN
71int yyget_lineno(yyscan_t yyscanner);
740aad26
MD		 72BT_HIDDEN
73char *yyget_text(yyscan_t yyscanner);
8b9d5b5e 74
34f7b02c 75static const char *node_type_to_str[] = {
590ca879
EB		 76#define ENTRY(S) [S] = #S,
77 FOREACH_CTF_NODES(ENTRY)
78#undef ENTRY
34f7b02c
MD		 79};
80
ff201942
MD		 81/*
82 * Static node for out of memory errors. Only "type" is used. lineno is
83 * always left at 0. The rest of the node content can be overwritten,
84 * but is never used.
85 */
86static struct ctf_node error_node = {
bdb55bcb
MD		 87 .type = NODE_ERROR,
88};
89
5d6c80a5 90BT_HIDDEN
34f7b02c
MD		 91const char *node_type(struct ctf_node *node)
92{
93 if (node->type < NR_NODE_TYPES)
94 return node_type_to_str[node->type];
95 else
96 return NULL;
97}
98
34d3acc4 99void setstring(struct ctf_scanner *scanner, YYSTYPE *lvalp, const char *src)
8b9d5b5e 100{
8aa95b17
MD		 101 lvalp->s = objstack_alloc(scanner->objstack, strlen(src) + 1);
102 strcpy(lvalp->s, src);
8b9d5b5e
MD		 103}
104
d876a5ba
EB		 105static
106int str_check(size_t str_len, size_t offset, size_t len)
107{
108 /* check overflow */
109 if (offset + len < offset)
110 return -1;
111 if (offset + len > str_len)
112 return -1;
113 return 0;
114}
115
697b1050
MD		 116static
117int bt_isodigit(int c)
118{
119 switch (c) {
120 case '0':
121 case '1':
122 case '2':
123 case '3':
124 case '4':
125 case '5':
126 case '6':
127 case '7':
128 return 1;
129 default:
130 return 0;
131 }
132}
133
134static
135int parse_base_sequence(const char *src, size_t len, size_t pos,
136 char *buffer, size_t *buf_len, int base)
137{
138 const size_t max_char = 3;
139 int nr_char = 0;
140
141 while (!str_check(len, pos, 1) && nr_char < max_char) {
142 char c = src[pos++];
143
144 if (base == 8) {
145 if (bt_isodigit(c))
146 buffer[nr_char++] = c;
147 else
148 break;
149 } else if (base == 16) {
150 if (isxdigit(c))
151 buffer[nr_char++] = c;
152 else
153 break;
154
155 } else {
156 /* Unsupported base */
157 return -1;
158 }
159 }
160 assert(nr_char > 0);
161 buffer[nr_char] = '\0';
162 *buf_len = nr_char;
163 return 0;
164}
165
d876a5ba
EB		 166static
167int import_basic_string(struct ctf_scanner *scanner, YYSTYPE *lvalp,
168 size_t len, const char *src, char delim)
169{
170 size_t pos = 0, dpos = 0;
171
172 if (str_check(len, pos, 1))
173 return -1;
174 if (src[pos++] != delim)
175 return -1;
176
177 while (src[pos] != delim) {
178 char c;
179
180 if (str_check(len, pos, 1))
181 return -1;
182 c = src[pos++];
183 if (c == '\\') {
184 if (str_check(len, pos, 1))
185 return -1;
186 c = src[pos++];
187
188 switch (c) {
d876a5ba
EB		 189 case 'a':
190 c = '\a';
191 break;
192 case 'b':
193 c = '\b';
194 break;
195 case 'f':
196 c = '\f';
197 break;
198 case 'n':
199 c = '\n';
200 break;
201 case 'r':
202 c = '\r';
203 break;
204 case 't':
205 c = '\t';
206 break;
207 case 'v':
208 c = '\v';
209 break;
210 case '\\':
211 c = '\\';
212 break;
213 case '\'':
214 c = '\'';
215 break;
216 case '\"':
217 c = '\"';
218 break;
219 case '?':
220 c = '?';
221 break;
697b1050
MD		 222 case '0':
223 case '1':
224 case '2':
225 case '3':
226 case '4':
227 case '5':
228 case '6':
229 case '7':
d876a5ba 230 {
697b1050
MD		 231 char oct_buffer[4];
232 size_t oct_len;
d876a5ba 233
697b1050
MD		 234 if (parse_base_sequence(src, len, pos - 1,
235 oct_buffer, &oct_len, 8))
d876a5ba 236 return -1;
d876a5ba 237 c = strtoul(&oct_buffer[0], NULL, 8);
697b1050 238 pos += oct_len - 1;
d876a5ba
EB		 239 break;
240 }
241 case 'x':
242 {
697b1050
MD		 243 char hex_buffer[4];
244 size_t hex_len;
d876a5ba 245
697b1050
MD		 246 if (parse_base_sequence(src, len, pos,
247 hex_buffer, &hex_len, 16))
d876a5ba 248 return -1;
d876a5ba
EB		 249 c = strtoul(&hex_buffer[0], NULL, 16);
250 pos += hex_len;
251 break;
252 }
253 default:
254 return -1;
255 }
256 }
257 if (str_check(len, dpos, 1))
258 return -1;
8aa95b17 259 lvalp->s[dpos++] = c;
d876a5ba
EB		 260 }
261
262 if (str_check(len, dpos, 1))
263 return -1;
8aa95b17 264 lvalp->s[dpos++] = '\0';
d876a5ba
EB		 265
266 if (str_check(len, pos, 1))
267 return -1;
268 if (src[pos++] != delim)
269 return -1;
270
271 if (str_check(len, pos, 1))
272 return -1;
273 if (src[pos] != '\0')
274 return -1;
275 return 0;
276}
277
278int import_string(struct ctf_scanner *scanner, YYSTYPE *lvalp,
279 const char *src, char delim)
280{
281 size_t len;
282
283 len = strlen(src) + 1;
8aa95b17 284 lvalp->s = objstack_alloc(scanner->objstack, len);
d876a5ba
EB		 285 if (src[0] == 'L') {
286 // TODO: import wide string
287 printfl_error(yyget_lineno(scanner),
288 "Wide string not supported yet.");
289 return -1;
290 } else {
291 return import_basic_string(scanner, lvalp, len, src, delim);
292 }
293}
294
609bd1bf
MD		 295static void init_scope(struct ctf_scanner_scope *scope,
296 struct ctf_scanner_scope *parent)
8b9d5b5e
MD		 297{
298 scope->parent = parent;
299 scope->types = g_hash_table_new_full(g_str_hash, g_str_equal,
6dc474b8 300 NULL, NULL);
8b9d5b5e
MD		 301}
302
609bd1bf 303static void finalize_scope(struct ctf_scanner_scope *scope)
8b9d5b5e
MD		 304{
305 g_hash_table_destroy(scope->types);
306}
307
34d3acc4 308static void push_scope(struct ctf_scanner *scanner)
8b9d5b5e 309{
609bd1bf 310 struct ctf_scanner_scope *ns;
8b9d5b5e 311
a3983482 312 printf_debug("push scope\n");
609bd1bf 313 ns = malloc(sizeof(struct ctf_scanner_scope));
34d3acc4
MD		 314 init_scope(ns, scanner->cs);
315 scanner->cs = ns;
8b9d5b5e
MD		 316}
317
34d3acc4 318static void pop_scope(struct ctf_scanner *scanner)
8b9d5b5e 319{
609bd1bf 320 struct ctf_scanner_scope *os;
8b9d5b5e 321
a3983482 322 printf_debug("pop scope\n");
34d3acc4
MD		 323 os = scanner->cs;
324 scanner->cs = os->parent;
8b9d5b5e
MD		 325 finalize_scope(os);
326 free(os);
327}
328
609bd1bf 329static int lookup_type(struct ctf_scanner_scope *s, const char *id)
8b9d5b5e
MD		 330{
331 int ret;
332
380d60b1 333 ret = (int) (long) g_hash_table_lookup(s->types, id);
a3983482 334 printf_debug("lookup %p %s %d\n", s, id, ret);
8b9d5b5e
MD		 335 return ret;
336}
337
5d6c80a5 338BT_HIDDEN
34d3acc4 339int is_type(struct ctf_scanner *scanner, const char *id)
8b9d5b5e 340{
609bd1bf 341 struct ctf_scanner_scope *it;
8b9d5b5e
MD		 342 int ret = 0;
343
34d3acc4 344 for (it = scanner->cs; it != NULL; it = it->parent) {
8b9d5b5e
MD		 345 if (lookup_type(it, id)) {
346 ret = 1;
347 break;
348 }
349 }
a3983482 350 printf_debug("is type %s %d\n", id, ret);
8b9d5b5e
MD		 351 return ret;
352}
353
8aa95b17 354static void add_type(struct ctf_scanner *scanner, char *id)
8b9d5b5e 355{
8aa95b17
MD		 356 printf_debug("add type %s\n", id);
357 if (lookup_type(scanner->cs, id))
8b9d5b5e 358 return;
8aa95b17 359 g_hash_table_insert(scanner->cs->types, id, id);
8b9d5b5e
MD		 360}
361
02b234c4
MD		 362static struct ctf_node *make_node(struct ctf_scanner *scanner,
363 enum node_type type)
364{
02b234c4
MD		 365 struct ctf_node *node;
366
2caa2f14 367 node = objstack_alloc(scanner->objstack, sizeof(*node));
bdb55bcb 368 if (!node) {
ff201942 369 printfl_fatal(yyget_lineno(scanner->scanner), "out of memory");
bdb55bcb
MD		 370 return &error_node;
371 }
02b234c4 372 node->type = type;
5c5c3455 373 node->lineno = yyget_lineno(scanner->scanner);
3122e6f0 374 BT_INIT_LIST_HEAD(&node->tmp_head);
3122e6f0 375 bt_list_add(&node->siblings, &node->tmp_head);
02b234c4
MD		 376
377 switch (type) {
378 case NODE_ROOT:
bdb55bcb 379 node->type = NODE_ERROR;
c55adfb9 380 printfn_fatal(node, "trying to create root node");
02b234c4
MD		 381 break;
382
383 case NODE_EVENT:
3122e6f0 384 BT_INIT_LIST_HEAD(&node->u.event.declaration_list);
02b234c4
MD		 385 break;
386 case NODE_STREAM:
3122e6f0 387 BT_INIT_LIST_HEAD(&node->u.stream.declaration_list);
02b234c4 388 break;
e2c76a4d 389 case NODE_ENV:
3122e6f0 390 BT_INIT_LIST_HEAD(&node->u.env.declaration_list);
e2c76a4d 391 break;
02b234c4 392 case NODE_TRACE:
3122e6f0 393 BT_INIT_LIST_HEAD(&node->u.trace.declaration_list);
02b234c4 394 break;
73d15916 395 case NODE_CLOCK:
3122e6f0 396 BT_INIT_LIST_HEAD(&node->u.clock.declaration_list);
73d15916 397 break;
f133896d
MD		 398 case NODE_CALLSITE:
399 BT_INIT_LIST_HEAD(&node->u.callsite.declaration_list);
400 break;
02b234c4
MD		 401
402 case NODE_CTF_EXPRESSION:
3122e6f0
JD		 403 BT_INIT_LIST_HEAD(&node->u.ctf_expression.left);
404 BT_INIT_LIST_HEAD(&node->u.ctf_expression.right);
02b234c4 405 break;
6dc474b8
MD		 406 case NODE_UNARY_EXPRESSION:
407 break;
02b234c4
MD		 408
409 case NODE_TYPEDEF:
3122e6f0 410 BT_INIT_LIST_HEAD(&node->u._typedef.type_declarators);
02b234c4
MD		 411 break;
412 case NODE_TYPEALIAS_TARGET:
3122e6f0 413 BT_INIT_LIST_HEAD(&node->u.typealias_target.type_declarators);
02b234c4
MD		 414 break;
415 case NODE_TYPEALIAS_ALIAS:
3122e6f0 416 BT_INIT_LIST_HEAD(&node->u.typealias_alias.type_declarators);
02b234c4
MD		 417 break;
418 case NODE_TYPEALIAS:
419 break;
420
421 case NODE_TYPE_SPECIFIER:
422 break;
3e11b713 423 case NODE_TYPE_SPECIFIER_LIST:
3122e6f0 424 BT_INIT_LIST_HEAD(&node->u.type_specifier_list.head);
3e11b713 425 break;
02b234c4
MD		 426 case NODE_POINTER:
427 break;
428 case NODE_TYPE_DECLARATOR:
3122e6f0 429 BT_INIT_LIST_HEAD(&node->u.type_declarator.pointers);
02b234c4
MD		 430 break;
431
432 case NODE_FLOATING_POINT:
3122e6f0 433 BT_INIT_LIST_HEAD(&node->u.floating_point.expressions);
02b234c4
MD		 434 break;
435 case NODE_INTEGER:
3122e6f0 436 BT_INIT_LIST_HEAD(&node->u.integer.expressions);
02b234c4
MD		 437 break;
438 case NODE_STRING:
3122e6f0 439 BT_INIT_LIST_HEAD(&node->u.string.expressions);
02b234c4
MD		 440 break;
441 case NODE_ENUMERATOR:
3122e6f0 442 BT_INIT_LIST_HEAD(&node->u.enumerator.values);
02b234c4
MD		 443 break;
444 case NODE_ENUM:
3122e6f0 445 BT_INIT_LIST_HEAD(&node->u._enum.enumerator_list);
02b234c4
MD		 446 break;
447 case NODE_STRUCT_OR_VARIANT_DECLARATION:
3122e6f0 448 BT_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.type_declarators);
02b234c4
MD		 449 break;
450 case NODE_VARIANT:
3122e6f0 451 BT_INIT_LIST_HEAD(&node->u.variant.declaration_list);
02b234c4
MD		 452 break;
453 case NODE_STRUCT:
3122e6f0
JD		 454 BT_INIT_LIST_HEAD(&node->u._struct.declaration_list);
455 BT_INIT_LIST_HEAD(&node->u._struct.min_align);
02b234c4
MD		 456 break;
457
458 case NODE_UNKNOWN:
459 default:
bdb55bcb 460 node->type = NODE_ERROR;
c55adfb9 461 printfn_fatal(node, "unknown node type '%d'", (int) type);
02b234c4
MD		 462 break;
463 }
464
465 return node;
466}
467
468static int reparent_ctf_expression(struct ctf_node *node,
469 struct ctf_node *parent)
470{
471 switch (parent->type) {
472 case NODE_EVENT:
3122e6f0 473 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
02b234c4
MD		 474 break;
475 case NODE_STREAM:
3122e6f0 476 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
02b234c4 477 break;
e2c76a4d 478 case NODE_ENV:
3122e6f0 479 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
e2c76a4d 480 break;
02b234c4 481 case NODE_TRACE:
3122e6f0 482 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
02b234c4 483 break;
73d15916 484 case NODE_CLOCK:
3122e6f0 485 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
73d15916 486 break;
f133896d
MD		 487 case NODE_CALLSITE:
488 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
489 break;
02b234c4 490 case NODE_FLOATING_POINT:
3122e6f0 491 _bt_list_splice_tail(&node->tmp_head, &parent->u.floating_point.expressions);
02b234c4
MD		 492 break;
493 case NODE_INTEGER:
3122e6f0 494 _bt_list_splice_tail(&node->tmp_head, &parent->u.integer.expressions);
02b234c4
MD		 495 break;
496 case NODE_STRING:
3122e6f0 497 _bt_list_splice_tail(&node->tmp_head, &parent->u.string.expressions);
02b234c4
MD		 498 break;
499
500 case NODE_ROOT:
501 case NODE_CTF_EXPRESSION:
502 case NODE_TYPEDEF:
503 case NODE_TYPEALIAS_TARGET:
504 case NODE_TYPEALIAS_ALIAS:
505 case NODE_TYPEALIAS:
506 case NODE_TYPE_SPECIFIER:
3e11b713 507 case NODE_TYPE_SPECIFIER_LIST:
02b234c4
MD		 508 case NODE_POINTER:
509 case NODE_TYPE_DECLARATOR:
510 case NODE_ENUMERATOR:
511 case NODE_ENUM:
512 case NODE_STRUCT_OR_VARIANT_DECLARATION:
513 case NODE_VARIANT:
514 case NODE_STRUCT:
6dc474b8 515 case NODE_UNARY_EXPRESSION:
02b234c4
MD		 516 return -EPERM;
517
518 case NODE_UNKNOWN:
519 default:
c55adfb9 520 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
02b234c4
MD		 521 return -EINVAL;
522 }
523 return 0;
524}
525
526static int reparent_typedef(struct ctf_node *node, struct ctf_node *parent)
527{
528 switch (parent->type) {
529 case NODE_ROOT:
3122e6f0 530 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
02b234c4
MD		 531 break;
532 case NODE_EVENT:
3122e6f0 533 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
02b234c4
MD		 534 break;
535 case NODE_STREAM:
3122e6f0 536 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
02b234c4 537 break;
e2c76a4d 538 case NODE_ENV:
3122e6f0 539 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
e2c76a4d 540 break;
02b234c4 541 case NODE_TRACE:
3122e6f0 542 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
02b234c4 543 break;
73d15916 544 case NODE_CLOCK:
3122e6f0 545 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
73d15916 546 break;
f133896d
MD		 547 case NODE_CALLSITE:
548 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
549 break;
02b234c4 550 case NODE_VARIANT:
3122e6f0 551 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
02b234c4
MD		 552 break;
553 case NODE_STRUCT:
3122e6f0 554 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
02b234c4
MD		 555 break;
556
557 case NODE_FLOATING_POINT:
558 case NODE_INTEGER:
559 case NODE_STRING:
560 case NODE_CTF_EXPRESSION:
561 case NODE_TYPEDEF:
562 case NODE_TYPEALIAS_TARGET:
563 case NODE_TYPEALIAS_ALIAS:
564 case NODE_TYPEALIAS:
565 case NODE_TYPE_SPECIFIER:
3e11b713 566 case NODE_TYPE_SPECIFIER_LIST:
02b234c4
MD		 567 case NODE_POINTER:
568 case NODE_TYPE_DECLARATOR:
569 case NODE_ENUMERATOR:
570 case NODE_ENUM:
571 case NODE_STRUCT_OR_VARIANT_DECLARATION:
6dc474b8 572 case NODE_UNARY_EXPRESSION:
02b234c4
MD		 573 return -EPERM;
574
575 case NODE_UNKNOWN:
576 default:
c55adfb9 577 printfn_fatal(node, "unknown node type %d", parent->type);
02b234c4
MD		 578 return -EINVAL;
579 }
580 return 0;
581}
582
583static int reparent_typealias(struct ctf_node *node, struct ctf_node *parent)
584{
585 switch (parent->type) {
586 case NODE_ROOT:
3122e6f0 587 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
02b234c4
MD		 588 break;
589 case NODE_EVENT:
3122e6f0 590 _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
02b234c4
MD		 591 break;
592 case NODE_STREAM:
3122e6f0 593 _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
02b234c4 594 break;
e2c76a4d 595 case NODE_ENV:
3122e6f0 596 _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
e2c76a4d 597 break;
02b234c4 598 case NODE_TRACE:
3122e6f0 599 _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
02b234c4 600 break;
73d15916 601 case NODE_CLOCK:
3122e6f0 602 _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
73d15916 603 break;
f133896d
MD		 604 case NODE_CALLSITE:
605 _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
606 break;
02b234c4 607 case NODE_VARIANT:
3122e6f0 608 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
02b234c4
MD		 609 break;
610 case NODE_STRUCT:
3122e6f0 611 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
02b234c4
MD		 612 break;
613
614 case NODE_FLOATING_POINT:
615 case NODE_INTEGER:
616 case NODE_STRING:
617 case NODE_CTF_EXPRESSION:
618 case NODE_TYPEDEF:
619 case NODE_TYPEALIAS_TARGET:
620 case NODE_TYPEALIAS_ALIAS:
621 case NODE_TYPEALIAS:
622 case NODE_TYPE_SPECIFIER:
3e11b713 623 case NODE_TYPE_SPECIFIER_LIST:
02b234c4
MD		 624 case NODE_POINTER:
625 case NODE_TYPE_DECLARATOR:
626 case NODE_ENUMERATOR:
627 case NODE_ENUM:
628 case NODE_STRUCT_OR_VARIANT_DECLARATION:
6dc474b8 629 case NODE_UNARY_EXPRESSION:
02b234c4
MD		 630 return -EPERM;
631
632 case NODE_UNKNOWN:
633 default:
c55adfb9 634 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
02b234c4
MD		 635 return -EINVAL;
636 }
637 return 0;
638}
639
6dc474b8
MD		 640static int reparent_type_specifier(struct ctf_node *node,
641 struct ctf_node *parent)
3e11b713
MD		 642{
643 switch (parent->type) {
644 case NODE_TYPE_SPECIFIER_LIST:
3122e6f0 645 _bt_list_splice_tail(&node->tmp_head, &parent->u.type_specifier_list.head);
3e11b713
MD		 646 break;
647
648 case NODE_TYPE_SPECIFIER:
649 case NODE_EVENT:
650 case NODE_STREAM:
e2c76a4d 651 case NODE_ENV:
3e11b713 652 case NODE_TRACE:
73d15916 653 case NODE_CLOCK:
f133896d 654 case NODE_CALLSITE:
3e11b713
MD		 655 case NODE_VARIANT:
656 case NODE_STRUCT:
657 case NODE_TYPEDEF:
658 case NODE_TYPEALIAS_TARGET:
659 case NODE_TYPEALIAS_ALIAS:
660 case NODE_TYPE_DECLARATOR:
661 case NODE_ENUM:
662 case NODE_STRUCT_OR_VARIANT_DECLARATION:
663 case NODE_TYPEALIAS:
664 case NODE_FLOATING_POINT:
665 case NODE_INTEGER:
666 case NODE_STRING:
667 case NODE_CTF_EXPRESSION:
668 case NODE_POINTER:
669 case NODE_ENUMERATOR:
670 case NODE_UNARY_EXPRESSION:
671 return -EPERM;
672
673 case NODE_UNKNOWN:
674 default:
c55adfb9 675 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
3e11b713
MD		 676 return -EINVAL;
677 }
678 return 0;
679}
680
681static int reparent_type_specifier_list(struct ctf_node *node,
682 struct ctf_node *parent)
02b234c4
MD		 683{
684 switch (parent->type) {
685 case NODE_ROOT:
3122e6f0 686 bt_list_add_tail(&node->siblings, &parent->u.root.declaration_list);
02b234c4
MD		 687 break;
688 case NODE_EVENT:
3122e6f0 689 bt_list_add_tail(&node->siblings, &parent->u.event.declaration_list);
02b234c4
MD		 690 break;
691 case NODE_STREAM:
3122e6f0 692 bt_list_add_tail(&node->siblings, &parent->u.stream.declaration_list);
02b234c4 693 break;
e2c76a4d 694 case NODE_ENV:
3122e6f0 695 bt_list_add_tail(&node->siblings, &parent->u.env.declaration_list);
e2c76a4d 696 break;
02b234c4 697 case NODE_TRACE:
3122e6f0 698 bt_list_add_tail(&node->siblings, &parent->u.trace.declaration_list);
02b234c4 699 break;
73d15916 700 case NODE_CLOCK:
3122e6f0 701 bt_list_add_tail(&node->siblings, &parent->u.clock.declaration_list);
73d15916 702 break;
f133896d
MD		 703 case NODE_CALLSITE:
704 bt_list_add_tail(&node->siblings, &parent->u.callsite.declaration_list);
705 break;
02b234c4 706 case NODE_VARIANT:
3122e6f0 707 bt_list_add_tail(&node->siblings, &parent->u.variant.declaration_list);
02b234c4
MD		 708 break;
709 case NODE_STRUCT:
3122e6f0 710 bt_list_add_tail(&node->siblings, &parent->u._struct.declaration_list);
02b234c4
MD		 711 break;
712 case NODE_TYPEDEF:
3e11b713 713 parent->u._typedef.type_specifier_list = node;
02b234c4
MD		 714 break;
715 case NODE_TYPEALIAS_TARGET:
3e11b713 716 parent->u.typealias_target.type_specifier_list = node;
02b234c4
MD		 717 break;
718 case NODE_TYPEALIAS_ALIAS:
3e11b713 719 parent->u.typealias_alias.type_specifier_list = node;
02b234c4 720 break;
02b234c4 721 case NODE_ENUM:
3e11b713 722 parent->u._enum.container_type = node;
02b234c4
MD		 723 break;
724 case NODE_STRUCT_OR_VARIANT_DECLARATION:
3e11b713 725 parent->u.struct_or_variant_declaration.type_specifier_list = node;
02b234c4 726 break;
98df1c9f 727 case NODE_TYPE_DECLARATOR:
3e11b713 728 case NODE_TYPE_SPECIFIER:
02b234c4
MD		 729 case NODE_TYPEALIAS:
730 case NODE_FLOATING_POINT:
731 case NODE_INTEGER:
732 case NODE_STRING:
733 case NODE_CTF_EXPRESSION:
02b234c4
MD		 734 case NODE_POINTER:
735 case NODE_ENUMERATOR:
6dc474b8 736 case NODE_UNARY_EXPRESSION:
02b234c4
MD		 737 return -EPERM;
738
739 case NODE_UNKNOWN:
740 default:
c55adfb9 741 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
02b234c4
MD		 742 return -EINVAL;
743 }
744 return 0;
745}
746
747static int reparent_type_declarator(struct ctf_node *node,
748 struct ctf_node *parent)
749{
750 switch (parent->type) {
751 case NODE_TYPE_DECLARATOR:
752 parent->u.type_declarator.type = TYPEDEC_NESTED;
753 parent->u.type_declarator.u.nested.type_declarator = node;
754 break;
755 case NODE_STRUCT_OR_VARIANT_DECLARATION:
3122e6f0 756 _bt_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.type_declarators);
02b234c4
MD		 757 break;
758 case NODE_TYPEDEF:
3122e6f0 759 _bt_list_splice_tail(&node->tmp_head, &parent->u._typedef.type_declarators);
02b234c4
MD		 760 break;
761 case NODE_TYPEALIAS_TARGET:
3122e6f0 762 _bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_target.type_declarators);
02b234c4
MD		 763 break;
764 case NODE_TYPEALIAS_ALIAS:
3122e6f0 765 _bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_alias.type_declarators);
02b234c4
MD		 766 break;
767
768 case NODE_ROOT:
769 case NODE_EVENT:
770 case NODE_STREAM:
e2c76a4d 771 case NODE_ENV:
02b234c4 772 case NODE_TRACE:
73d15916 773 case NODE_CLOCK:
f133896d 774 case NODE_CALLSITE:
02b234c4
MD		 775 case NODE_VARIANT:
776 case NODE_STRUCT:
777 case NODE_TYPEALIAS:
778 case NODE_ENUM:
779 case NODE_FLOATING_POINT:
780 case NODE_INTEGER:
781 case NODE_STRING:
782 case NODE_CTF_EXPRESSION:
783 case NODE_TYPE_SPECIFIER:
3e11b713 784 case NODE_TYPE_SPECIFIER_LIST:
02b234c4
MD		 785 case NODE_POINTER:
786 case NODE_ENUMERATOR:
6dc474b8 787 case NODE_UNARY_EXPRESSION:
02b234c4
MD		 788 return -EPERM;
789
790 case NODE_UNKNOWN:
791 default:
c55adfb9 792 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
02b234c4
MD		 793 return -EINVAL;
794 }
795 return 0;
796}
797
798/*
48a01768 799 * set_parent_node
02b234c4 800 *
48a01768
MD		 801 * Link node to parent. Returns 0 on success, -EPERM if it is not permitted to
802 * create the link declared by the input, -ENOENT if node or parent is NULL,
803 * -EINVAL if there is an internal structure problem.
02b234c4 804 */
48a01768 805static int set_parent_node(struct ctf_node *node,
02b234c4
MD		 806 struct ctf_node *parent)
807{
808 if (!node || !parent)
809 return -ENOENT;
810
6dc474b8 811 /* Note: Linking to parent will be done only by an external visitor */
02b234c4
MD		 812
813 switch (node->type) {
814 case NODE_ROOT:
c55adfb9 815 printfn_fatal(node, "trying to reparent root node");
02b234c4
MD		 816 return -EINVAL;
817
818 case NODE_EVENT:
48a01768 819 if (parent->type == NODE_ROOT) {
3122e6f0 820 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.event);
3e11b713 821 } else {
02b234c4 822 return -EPERM;
3e11b713 823 }
02b234c4
MD		 824 break;
825 case NODE_STREAM:
48a01768 826 if (parent->type == NODE_ROOT) {
3122e6f0 827 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.stream);
3e11b713 828 } else {
02b234c4 829 return -EPERM;
3e11b713 830 }
02b234c4 831 break;
e2c76a4d
MD		 832 case NODE_ENV:
833 if (parent->type == NODE_ROOT) {
3122e6f0 834 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.env);
e2c76a4d
MD		 835 } else {
836 return -EPERM;
837 }
838 break;
02b234c4 839 case NODE_TRACE:
48a01768 840 if (parent->type == NODE_ROOT) {
3122e6f0 841 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.trace);
3e11b713 842 } else {
02b234c4 843 return -EPERM;
3e11b713 844 }
02b234c4 845 break;
73d15916
MD		 846 case NODE_CLOCK:
847 if (parent->type == NODE_ROOT) {
3122e6f0 848 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.clock);
73d15916
MD		 849 } else {
850 return -EPERM;
851 }
852 break;
f133896d
MD		 853 case NODE_CALLSITE:
854 if (parent->type == NODE_ROOT) {
855 _bt_list_splice_tail(&node->tmp_head, &parent->u.root.callsite);
856 } else {
857 return -EPERM;
858 }
859 break;
02b234c4
MD		 860
861 case NODE_CTF_EXPRESSION:
862 return reparent_ctf_expression(node, parent);
6dc474b8
MD		 863 case NODE_UNARY_EXPRESSION:
864 if (parent->type == NODE_TYPE_DECLARATOR)
865 parent->u.type_declarator.bitfield_len = node;
866 else
867 return -EPERM;
868 break;
02b234c4
MD		 869
870 case NODE_TYPEDEF:
871 return reparent_typedef(node, parent);
872 case NODE_TYPEALIAS_TARGET:
873 if (parent->type == NODE_TYPEALIAS)
874 parent->u.typealias.target = node;
875 else
876 return -EINVAL;
877 case NODE_TYPEALIAS_ALIAS:
878 if (parent->type == NODE_TYPEALIAS)
879 parent->u.typealias.alias = node;
880 else
881 return -EINVAL;
882 case NODE_TYPEALIAS:
883 return reparent_typealias(node, parent);
884
02b234c4 885 case NODE_POINTER:
48a01768 886 if (parent->type == NODE_TYPE_DECLARATOR) {
3122e6f0 887 _bt_list_splice_tail(&node->tmp_head, &parent->u.type_declarator.pointers);
48a01768 888 } else
02b234c4
MD		 889 return -EPERM;
890 break;
891 case NODE_TYPE_DECLARATOR:
892 return reparent_type_declarator(node, parent);
893
3e11b713
MD		 894 case NODE_TYPE_SPECIFIER_LIST:
895 return reparent_type_specifier_list(node, parent);
896
6dc474b8 897 case NODE_TYPE_SPECIFIER:
3e11b713
MD		 898 return reparent_type_specifier(node, parent);
899
02b234c4 900 case NODE_FLOATING_POINT:
02b234c4 901 case NODE_INTEGER:
02b234c4 902 case NODE_STRING:
6dc474b8
MD		 903 case NODE_ENUM:
904 case NODE_VARIANT:
905 case NODE_STRUCT:
3e11b713 906 return -EINVAL; /* Dealt with internally within grammar */
6dc474b8 907
02b234c4 908 case NODE_ENUMERATOR:
48a01768 909 if (parent->type == NODE_ENUM) {
3122e6f0 910 _bt_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
3e11b713 911 } else {
02b234c4 912 return -EPERM;
3e11b713 913 }
02b234c4 914 break;
02b234c4
MD		 915 case NODE_STRUCT_OR_VARIANT_DECLARATION:
916 switch (parent->type) {
917 case NODE_STRUCT:
3122e6f0 918 _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
02b234c4
MD		 919 break;
920 case NODE_VARIANT:
3122e6f0 921 _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
02b234c4
MD		 922 break;
923 default:
924 return -EINVAL;
925 }
926 break;
02b234c4
MD		 927
928 case NODE_UNKNOWN:
929 default:
c55adfb9 930 printfn_fatal(node, "unknown node type '%d'", (int) parent->type);
02b234c4
MD		 931 return -EINVAL;
932 }
933 return 0;
934}
935
5d6c80a5 936BT_HIDDEN
34d3acc4 937void yyerror(struct ctf_scanner *scanner, const char *str)
8b9d5b5e 938{
c55adfb9
EB		 939 printfl_error(yyget_lineno(scanner->scanner),
940 "token \"%s\": %s\n",
740aad26 941 yyget_text(scanner->scanner), str);
8b9d5b5e
MD		 942}
943
5d6c80a5 944BT_HIDDEN
8b9d5b5e
MD		 945int yywrap(void)
946{
947 return 1;
948}
949
6dc474b8
MD		 950#define reparent_error(scanner, str) \
951do { \
c55adfb9 952 yyerror(scanner, YY_("reparent_error: " str)); \
6dc474b8
MD		 953 YYERROR; \
954} while (0)
955
34d3acc4 956static struct ctf_ast *ctf_ast_alloc(void)
8b9d5b5e 957{
34d3acc4
MD		 958 struct ctf_ast *ast;
959
960 ast = malloc(sizeof(*ast));
961 if (!ast)
962 return NULL;
963 memset(ast, 0, sizeof(*ast));
02b234c4 964 ast->root.type = NODE_ROOT;
3122e6f0
JD		 965 BT_INIT_LIST_HEAD(&ast->root.tmp_head);
966 BT_INIT_LIST_HEAD(&ast->root.u.root.declaration_list);
967 BT_INIT_LIST_HEAD(&ast->root.u.root.trace);
968 BT_INIT_LIST_HEAD(&ast->root.u.root.env);
969 BT_INIT_LIST_HEAD(&ast->root.u.root.stream);
970 BT_INIT_LIST_HEAD(&ast->root.u.root.event);
971 BT_INIT_LIST_HEAD(&ast->root.u.root.clock);
f133896d 972 BT_INIT_LIST_HEAD(&ast->root.u.root.callsite);
34d3acc4
MD		 973 return ast;
974}
975
976static void ctf_ast_free(struct ctf_ast *ast)
977{
15d4fe3c 978 free(ast);
34d3acc4
MD		 979}
980
981int ctf_scanner_append_ast(struct ctf_scanner *scanner)
982{
983 return yyparse(scanner);
984}
985
986struct ctf_scanner *ctf_scanner_alloc(FILE *input)
987{
988 struct ctf_scanner *scanner;
989 int ret;
990
a3983482
MD		 991 yydebug = babeltrace_debug;
992
34d3acc4
MD		 993 scanner = malloc(sizeof(*scanner));
994 if (!scanner)
995 return NULL;
996 memset(scanner, 0, sizeof(*scanner));
997
998 ret = yylex_init_extra(scanner, &scanner->scanner);
999 if (ret) {
c55adfb9 1000 printf_fatal("yylex_init error");
34d3acc4
MD		 1001 goto cleanup_scanner;
1002 }
65102a8c
MD		 1003 /* Start processing new stream */
1004 yyrestart(input, scanner->scanner);
34d3acc4
MD		 1005
1006 scanner->ast = ctf_ast_alloc();
1007 if (!scanner->ast)
1008 goto cleanup_lexer;
8aa95b17
MD		 1009 scanner->objstack = objstack_create();
1010 if (!scanner->objstack)
1011 goto cleanup_ast;
34d3acc4 1012 init_scope(&scanner->root_scope, NULL);
19d96da7 1013 scanner->cs = &scanner->root_scope;
34d3acc4 1014
65102a8c
MD		 1015 if (yydebug)
1016 fprintf(stdout, "Scanner input is a%s.\n",
1017 isatty(fileno(input)) ? "n interactive tty" :
1018 " noninteractive file");
1019
34d3acc4
MD		 1020 return scanner;
1021
8aa95b17
MD		 1022cleanup_ast:
1023 ctf_ast_free(scanner->ast);
34d3acc4
MD		 1024cleanup_lexer:
1025 ret = yylex_destroy(scanner->scanner);
1026 if (!ret)
c55adfb9 1027 printf_fatal("yylex_destroy error");
34d3acc4
MD		 1028cleanup_scanner:
1029 free(scanner);
1030 return NULL;
1031}
1032
1033void ctf_scanner_free(struct ctf_scanner *scanner)
1034{
1035 int ret;
1036
1037 finalize_scope(&scanner->root_scope);
8aa95b17 1038 objstack_destroy(scanner->objstack);
34d3acc4
MD		 1039 ctf_ast_free(scanner->ast);
1040 ret = yylex_destroy(scanner->scanner);
1041 if (ret)
c55adfb9 1042 printf_error("yylex_destroy error");
34d3acc4
MD		 1043 free(scanner);
1044}
8b9d5b5e
MD		 1045
1046%}
1047
34d3acc4
MD		 1048%define api.pure
1049 /* %locations */
8c834e5a 1050%error-verbose
34d3acc4
MD		 1051%parse-param {struct ctf_scanner *scanner}
1052%lex-param {struct ctf_scanner *scanner}
0fbb34a5
MD		 1053/*
1054 * Expect two shift-reduce conflicts. Caused by enum name-opt : type {}
1055 * vs struct { int :value; } (unnamed bit-field). The default is to
1056 * shift, so whenever we encounter an enumeration, we are doing the
1057 * proper thing (shift). It is illegal to declare an enumeration
1058 * "bit-field", so it is OK if this situation ends up in a parsing
1059 * error.
1060 */
1061%expect 2
8b9d5b5e 1062%start file
80b07bd7 1063%token INTEGER_LITERAL STRING_LITERAL CHARACTER_LITERAL LSBRAC RSBRAC LPAREN RPAREN LBRAC RBRAC RARROW STAR PLUS MINUS LT GT TYPEASSIGN COLON SEMICOLON DOTDOTDOT DOT EQUAL COMMA CONST CHAR DOUBLE ENUM ENV EVENT FLOATING_POINT FLOAT INTEGER INT LONG SHORT SIGNED STREAM STRING STRUCT TRACE CALLSITE CLOCK TYPEALIAS TYPEDEF UNSIGNED VARIANT VOID _BOOL _COMPLEX _IMAGINARY TOK_ALIGN
8aa95b17 1064%token <s> IDENTIFIER ID_TYPE
8b9d5b5e
MD		 1065%token ERROR
1066%union
1067{
1068 long long ll;
80b07bd7 1069 unsigned long long ull;
8b9d5b5e 1070 char c;
8aa95b17 1071 char *s;
8b9d5b5e
MD		 1072 struct ctf_node *n;
1073}
1074
8aa95b17 1075%type <s> STRING_LITERAL CHARACTER_LITERAL
d876a5ba 1076
8aa95b17 1077%type <s> keywords
6dc474b8 1078
80b07bd7 1079%type <ull> INTEGER_LITERAL
6dc474b8
MD		 1080%type <n> postfix_expression unary_expression unary_expression_or_range
1081
1082%type <n> declaration
02b234c4 1083%type <n> event_declaration
6dc474b8 1084%type <n> stream_declaration
e2c76a4d 1085%type <n> env_declaration
6dc474b8 1086%type <n> trace_declaration
73d15916 1087%type <n> clock_declaration
f133896d 1088%type <n> callsite_declaration
0fbb34a5 1089%type <n> integer_declaration_specifiers
6dc474b8 1090%type <n> declaration_specifiers
1ee8e81d 1091%type <n> alias_declaration_specifiers
6dc474b8
MD		 1092
1093%type <n> type_declarator_list
0fbb34a5 1094%type <n> integer_type_specifier
6dc474b8
MD		 1095%type <n> type_specifier
1096%type <n> struct_type_specifier
1097%type <n> variant_type_specifier
6dc474b8
MD		 1098%type <n> enum_type_specifier
1099%type <n> struct_or_variant_declaration_list
1100%type <n> struct_or_variant_declaration
6dc474b8
MD		 1101%type <n> struct_or_variant_declarator_list
1102%type <n> struct_or_variant_declarator
1103%type <n> enumerator_list
1104%type <n> enumerator
1105%type <n> abstract_declarator_list
1106%type <n> abstract_declarator
1107%type <n> direct_abstract_declarator
e0c14875
MD		 1108%type <n> alias_abstract_declarator_list
1109%type <n> alias_abstract_declarator
1110%type <n> direct_alias_abstract_declarator
6dc474b8
MD		 1111%type <n> declarator
1112%type <n> direct_declarator
1113%type <n> type_declarator
1114%type <n> direct_type_declarator
6dc474b8 1115%type <n> pointer
02b234c4
MD		 1116%type <n> ctf_assignment_expression_list
1117%type <n> ctf_assignment_expression
1118
8b9d5b5e
MD		 1119%%
1120
1121file:
1122 declaration
6dc474b8 1123 {
48a01768 1124 if (set_parent_node($1, &ctf_scanner_get_ast(scanner)->root))
6dc474b8
MD		 1125 reparent_error(scanner, "error reparenting to root");
1126 }
8b9d5b5e 1127 | file declaration
6dc474b8 1128 {
48a01768 1129 if (set_parent_node($2, &ctf_scanner_get_ast(scanner)->root))
6dc474b8
MD		 1130 reparent_error(scanner, "error reparenting to root");
1131 }
8b9d5b5e
MD		 1132 ;
1133
1134keywords:
1135 VOID
8aa95b17 1136 { $$ = yylval.s; }
8b9d5b5e 1137 | CHAR
8aa95b17 1138 { $$ = yylval.s; }
8b9d5b5e 1139 | SHORT
8aa95b17 1140 { $$ = yylval.s; }
8b9d5b5e 1141 | INT
8aa95b17 1142 { $$ = yylval.s; }
8b9d5b5e 1143 | LONG
8aa95b17 1144 { $$ = yylval.s; }
8b9d5b5e 1145 | FLOAT
8aa95b17 1146 { $$ = yylval.s; }
8b9d5b5e 1147 | DOUBLE
8aa95b17 1148 { $$ = yylval.s; }
8b9d5b5e 1149 | SIGNED
8aa95b17 1150 { $$ = yylval.s; }
8b9d5b5e 1151 | UNSIGNED
8aa95b17 1152 { $$ = yylval.s; }
8b9d5b5e 1153 | _BOOL
8aa95b17 1154 { $$ = yylval.s; }
8b9d5b5e 1155 | _COMPLEX
8aa95b17 1156 { $$ = yylval.s; }
3888a159 1157 | _IMAGINARY
8aa95b17 1158 { $$ = yylval.s; }
8b9d5b5e 1159 | FLOATING_POINT
8aa95b17 1160 { $$ = yylval.s; }
8b9d5b5e 1161 | INTEGER
8aa95b17 1162 { $$ = yylval.s; }
8b9d5b5e 1163 | STRING
8aa95b17 1164 { $$ = yylval.s; }
8b9d5b5e 1165 | ENUM
8aa95b17 1166 { $$ = yylval.s; }
8b9d5b5e 1167 | VARIANT
8aa95b17 1168 { $$ = yylval.s; }
8b9d5b5e 1169 | STRUCT
8aa95b17 1170 { $$ = yylval.s; }
8b9d5b5e 1171 | CONST
8aa95b17 1172 { $$ = yylval.s; }
8b9d5b5e 1173 | TYPEDEF
8aa95b17 1174 { $$ = yylval.s; }
8b9d5b5e 1175 | EVENT
8aa95b17 1176 { $$ = yylval.s; }
8b9d5b5e 1177 | STREAM
8aa95b17 1178 { $$ = yylval.s; }
d2ea163b 1179 | ENV
8aa95b17 1180 { $$ = yylval.s; }
8b9d5b5e 1181 | TRACE
8aa95b17 1182 { $$ = yylval.s; }
73d15916 1183 | CLOCK
8aa95b17 1184 { $$ = yylval.s; }
f133896d 1185 | CALLSITE
8aa95b17 1186 { $$ = yylval.s; }
b7e35bad 1187 | TOK_ALIGN
8aa95b17 1188 { $$ = yylval.s; }
8b9d5b5e
MD		 1189 ;
1190
8b9d5b5e
MD		 1191
1192/* 2: Phrase structure grammar */
1193
1194postfix_expression:
1195 IDENTIFIER
6dc474b8
MD		 1196 {
1197 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1198 $$->u.unary_expression.type = UNARY_STRING;
8aa95b17 1199 $$->u.unary_expression.u.string = yylval.s;
6dc474b8 1200 }
8b9d5b5e 1201 | ID_TYPE
6dc474b8
MD		 1202 {
1203 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1204 $$->u.unary_expression.type = UNARY_STRING;
8aa95b17 1205 $$->u.unary_expression.u.string = yylval.s;
6dc474b8 1206 }
8b9d5b5e 1207 | keywords
6dc474b8
MD		 1208 {
1209 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1210 $$->u.unary_expression.type = UNARY_STRING;
8aa95b17 1211 $$->u.unary_expression.u.string = yylval.s;
6dc474b8 1212 }
80b07bd7 1213 | INTEGER_LITERAL
6dc474b8
MD		 1214 {
1215 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1216 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
80b07bd7 1217 $$->u.unary_expression.u.unsigned_constant = $1;
6dc474b8 1218 }
d876a5ba 1219 | STRING_LITERAL
6dc474b8
MD		 1220 {
1221 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1222 $$->u.unary_expression.type = UNARY_STRING;
8aa95b17 1223 $$->u.unary_expression.u.string = $1;
6dc474b8 1224 }
d876a5ba 1225 | CHARACTER_LITERAL
6dc474b8
MD		 1226 {
1227 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1228 $$->u.unary_expression.type = UNARY_STRING;
8aa95b17 1229 $$->u.unary_expression.u.string = $1;
6dc474b8 1230 }
8b9d5b5e 1231 | LPAREN unary_expression RPAREN
6dc474b8 1232 {
104147cd 1233 $$ = $2;
6dc474b8 1234 }
8b9d5b5e 1235 | postfix_expression LSBRAC unary_expression RSBRAC
6dc474b8
MD		 1236 {
1237 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1238 $$->u.unary_expression.type = UNARY_SBRAC;
1239 $$->u.unary_expression.u.sbrac_exp = $3;
3122e6f0
JD		 1240 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1241 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8 1242 }
8b9d5b5e 1243 | postfix_expression DOT IDENTIFIER
6dc474b8
MD		 1244 {
1245 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1246 $$->u.unary_expression.type = UNARY_STRING;
8aa95b17 1247 $$->u.unary_expression.u.string = yylval.s;
6dc474b8 1248 $$->u.unary_expression.link = UNARY_DOTLINK;
3122e6f0
JD		 1249 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1250 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8 1251 }
8b9d5b5e 1252 | postfix_expression DOT ID_TYPE
6dc474b8
MD		 1253 {
1254 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1255 $$->u.unary_expression.type = UNARY_STRING;
8aa95b17 1256 $$->u.unary_expression.u.string = yylval.s;
6dc474b8 1257 $$->u.unary_expression.link = UNARY_DOTLINK;
3122e6f0
JD		 1258 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1259 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8 1260 }
8b9d5b5e 1261 | postfix_expression RARROW IDENTIFIER
6dc474b8
MD		 1262 {
1263 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1264 $$->u.unary_expression.type = UNARY_STRING;
8aa95b17 1265 $$->u.unary_expression.u.string = yylval.s;
6dc474b8 1266 $$->u.unary_expression.link = UNARY_ARROWLINK;
3122e6f0
JD		 1267 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1268 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8 1269 }
8b9d5b5e 1270 | postfix_expression RARROW ID_TYPE
6dc474b8
MD		 1271 {
1272 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1273 $$->u.unary_expression.type = UNARY_STRING;
8aa95b17 1274 $$->u.unary_expression.u.string = yylval.s;
6dc474b8 1275 $$->u.unary_expression.link = UNARY_ARROWLINK;
3122e6f0
JD		 1276 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1277 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8 1278 }
8b9d5b5e
MD		 1279 ;
1280
1281unary_expression:
1282 postfix_expression
6dc474b8 1283 { $$ = $1; }
8b9d5b5e 1284 | PLUS postfix_expression
f9c67088
EB		 1285 {
1286 $$ = $2;
1287 if ($$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
1288 && $$->u.unary_expression.type != UNARY_SIGNED_CONSTANT) {
1289 reparent_error(scanner, "expecting numeric constant");
1290 }
1291 }
8b9d5b5e 1292 | MINUS postfix_expression
6dc474b8
MD		 1293 {
1294 $$ = $2;
6dc474b8
MD		 1295 if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1296 $$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
1297 $$->u.unary_expression.u.signed_constant =
1298 -($$->u.unary_expression.u.unsigned_constant);
ca3de390 1299 } else if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
6dc474b8
MD		 1300 $$->u.unary_expression.u.signed_constant =
1301 -($$->u.unary_expression.u.signed_constant);
ca3de390
EB		 1302 } else {
1303 reparent_error(scanner, "expecting numeric constant");
6dc474b8
MD		 1304 }
1305 }
8b9d5b5e
MD		 1306 ;
1307
1308unary_expression_or_range:
1309 unary_expression DOTDOTDOT unary_expression
6dc474b8
MD		 1310 {
1311 $$ = $1;
3122e6f0 1312 _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
48a01768 1313 $3->u.unary_expression.link = UNARY_DOTDOTDOT;
6dc474b8 1314 }
8b9d5b5e 1315 | unary_expression
6dc474b8 1316 { $$ = $1; }
8b9d5b5e
MD		 1317 ;
1318
1319/* 2.2: Declarations */
1320
1321declaration:
1322 declaration_specifiers SEMICOLON
6dc474b8 1323 { $$ = $1; }
8b9d5b5e 1324 | event_declaration
6dc474b8 1325 { $$ = $1; }
8b9d5b5e 1326 | stream_declaration
6dc474b8 1327 { $$ = $1; }
e2c76a4d
MD		 1328 | env_declaration
1329 { $$ = $1; }
8b9d5b5e 1330 | trace_declaration
6dc474b8 1331 { $$ = $1; }
73d15916
MD		 1332 | clock_declaration
1333 { $$ = $1; }
f133896d
MD		 1334 | callsite_declaration
1335 { $$ = $1; }
8b9d5b5e 1336 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
6dc474b8 1337 {
3e11b713
MD		 1338 struct ctf_node *list;
1339
6dc474b8 1340 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 1341 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1342 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 1343 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1344 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1345 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 1346 }
8b9d5b5e 1347 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
6dc474b8 1348 {
3e11b713
MD		 1349 struct ctf_node *list;
1350
6dc474b8 1351 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 1352 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1353 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 1354 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1355 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 1356 }
8b9d5b5e 1357 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
6dc474b8 1358 {
3e11b713
MD		 1359 struct ctf_node *list;
1360
6dc474b8 1361 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 1362 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1363 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 1364 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1365 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 1366 }
a030d084 1367 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
6dc474b8 1368 {
3e11b713
MD		 1369 struct ctf_node *list;
1370
6dc474b8
MD		 1371 $$ = make_node(scanner, NODE_TYPEALIAS);
1372 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1373 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
3e11b713
MD		 1374
1375 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1376 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
3122e6f0
JD		 1377 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1378 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
3e11b713
MD		 1379
1380 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1381 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
3122e6f0
JD		 1382 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1383 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
6dc474b8 1384 }
8b9d5b5e
MD		 1385 ;
1386
1387event_declaration:
1388 event_declaration_begin event_declaration_end
48a01768
MD		 1389 {
1390 $$ = make_node(scanner, NODE_EVENT);
48a01768 1391 }
8b9d5b5e 1392 | event_declaration_begin ctf_assignment_expression_list event_declaration_end
02b234c4
MD		 1393 {
1394 $$ = make_node(scanner, NODE_EVENT);
48a01768 1395 if (set_parent_node($2, $$))
6dc474b8 1396 reparent_error(scanner, "event_declaration");
02b234c4 1397 }
8b9d5b5e
MD		 1398 ;
1399
1400event_declaration_begin:
1401 EVENT LBRAC
fce8006d 1402 { push_scope(scanner); }
8b9d5b5e
MD		 1403 ;
1404
1405event_declaration_end:
1406 RBRAC SEMICOLON
fce8006d 1407 { pop_scope(scanner); }
8b9d5b5e
MD		 1408 ;
1409
1410
1411stream_declaration:
1412 stream_declaration_begin stream_declaration_end
48a01768
MD		 1413 {
1414 $$ = make_node(scanner, NODE_STREAM);
48a01768 1415 }
8b9d5b5e 1416 | stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
6dc474b8
MD		 1417 {
1418 $$ = make_node(scanner, NODE_STREAM);
48a01768 1419 if (set_parent_node($2, $$))
6dc474b8
MD		 1420 reparent_error(scanner, "stream_declaration");
1421 }
8b9d5b5e
MD		 1422 ;
1423
1424stream_declaration_begin:
1425 STREAM LBRAC
fce8006d 1426 { push_scope(scanner); }
8b9d5b5e
MD		 1427 ;
1428
1429stream_declaration_end:
1430 RBRAC SEMICOLON
fce8006d 1431 { pop_scope(scanner); }
8b9d5b5e
MD		 1432 ;
1433
e2c76a4d
MD		 1434env_declaration:
1435 env_declaration_begin env_declaration_end
1436 {
1437 $$ = make_node(scanner, NODE_ENV);
1438 }
1439 | env_declaration_begin ctf_assignment_expression_list env_declaration_end
1440 {
1441 $$ = make_node(scanner, NODE_ENV);
1442 if (set_parent_node($2, $$))
1443 reparent_error(scanner, "env declaration");
1444 }
1445 ;
1446
1447env_declaration_begin:
1448 ENV LBRAC
1449 { push_scope(scanner); }
1450 ;
1451
1452env_declaration_end:
1453 RBRAC SEMICOLON
1454 { pop_scope(scanner); }
1455 ;
1456
8b9d5b5e
MD		 1457trace_declaration:
1458 trace_declaration_begin trace_declaration_end
48a01768
MD		 1459 {
1460 $$ = make_node(scanner, NODE_TRACE);
48a01768 1461 }
8b9d5b5e 1462 | trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
6dc474b8
MD		 1463 {
1464 $$ = make_node(scanner, NODE_TRACE);
48a01768 1465 if (set_parent_node($2, $$))
6dc474b8
MD		 1466 reparent_error(scanner, "trace_declaration");
1467 }
8b9d5b5e
MD		 1468 ;
1469
1470trace_declaration_begin:
1471 TRACE LBRAC
fce8006d 1472 { push_scope(scanner); }
8b9d5b5e
MD		 1473 ;
1474
1475trace_declaration_end:
1476 RBRAC SEMICOLON
fce8006d 1477 { pop_scope(scanner); }
8b9d5b5e
MD		 1478 ;
1479
73d15916
MD		 1480clock_declaration:
1481 CLOCK clock_declaration_begin clock_declaration_end
1482 {
1483 $$ = make_node(scanner, NODE_CLOCK);
1484 }
1485 | CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
1486 {
1487 $$ = make_node(scanner, NODE_CLOCK);
1488 if (set_parent_node($3, $$))
1489 reparent_error(scanner, "trace_declaration");
1490 }
1491 ;
1492
1493clock_declaration_begin:
1494 LBRAC
1495 { push_scope(scanner); }
1496 ;
1497
1498clock_declaration_end:
1499 RBRAC SEMICOLON
1500 { pop_scope(scanner); }
1501 ;
1502
f133896d
MD		 1503callsite_declaration:
1504 CALLSITE callsite_declaration_begin callsite_declaration_end
1505 {
1506 $$ = make_node(scanner, NODE_CALLSITE);
1507 }
1508 | CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
1509 {
1510 $$ = make_node(scanner, NODE_CALLSITE);
1511 if (set_parent_node($3, $$))
1512 reparent_error(scanner, "trace_declaration");
1513 }
1514 ;
1515
1516callsite_declaration_begin:
1517 LBRAC
1518 { push_scope(scanner); }
1519 ;
1520
1521callsite_declaration_end:
1522 RBRAC SEMICOLON
1523 { pop_scope(scanner); }
1524 ;
1525
0fbb34a5
MD		 1526integer_declaration_specifiers:
1527 CONST
1528 {
1529 struct ctf_node *node;
1530
1531 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1532 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1533 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 1534 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
0fbb34a5
MD		 1535 }
1536 | integer_type_specifier
1537 {
1538 struct ctf_node *node;
1539
1540 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1541 node = $1;
3122e6f0 1542 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
0fbb34a5
MD		 1543 }
1544 | integer_declaration_specifiers CONST
1545 {
1546 struct ctf_node *node;
1547
1548 $$ = $1;
1549 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1550 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 1551 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
0fbb34a5
MD		 1552 }
1553 | integer_declaration_specifiers integer_type_specifier
1554 {
1555 $$ = $1;
3122e6f0 1556 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
0fbb34a5
MD		 1557 }
1558 ;
1559
8b9d5b5e
MD		 1560declaration_specifiers:
1561 CONST
6dc474b8 1562 {
3e11b713
MD		 1563 struct ctf_node *node;
1564
1565 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1566 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1567 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 1568 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 1569 }
8b9d5b5e 1570 | type_specifier
3e11b713
MD		 1571 {
1572 struct ctf_node *node;
1573
1574 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1575 node = $1;
3122e6f0 1576 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
3e11b713 1577 }
8b9d5b5e 1578 | declaration_specifiers CONST
6dc474b8
MD		 1579 {
1580 struct ctf_node *node;
1581
48a01768 1582 $$ = $1;
6dc474b8
MD		 1583 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1584 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 1585 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 1586 }
8b9d5b5e 1587 | declaration_specifiers type_specifier
6dc474b8
MD		 1588 {
1589 $$ = $1;
3122e6f0 1590 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 1591 }
8b9d5b5e
MD		 1592 ;
1593
1594type_declarator_list:
1595 type_declarator
0009a725 1596 { $$ = $1; }
8b9d5b5e 1597 | type_declarator_list COMMA type_declarator
6dc474b8
MD		 1598 {
1599 $$ = $1;
3122e6f0 1600 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
6dc474b8 1601 }
8b9d5b5e
MD		 1602 ;
1603
0fbb34a5
MD		 1604integer_type_specifier:
1605 CHAR
1606 {
1607 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1608 $$->u.type_specifier.type = TYPESPEC_CHAR;
1609 }
1610 | SHORT
1611 {
1612 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1613 $$->u.type_specifier.type = TYPESPEC_SHORT;
1614 }
1615 | INT
1616 {
1617 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1618 $$->u.type_specifier.type = TYPESPEC_INT;
1619 }
1620 | LONG
1621 {
1622 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1623 $$->u.type_specifier.type = TYPESPEC_LONG;
1624 }
1625 | SIGNED
1626 {
1627 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1628 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1629 }
1630 | UNSIGNED
1631 {
1632 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1633 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1634 }
1635 | _BOOL
1636 {
1637 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1638 $$->u.type_specifier.type = TYPESPEC_BOOL;
1639 }
1640 | ID_TYPE
1641 {
1642 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1643 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
8aa95b17 1644 $$->u.type_specifier.id_type = yylval.s;
0fbb34a5
MD		 1645 }
1646 | INTEGER LBRAC RBRAC
1647 {
1648 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1649 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1650 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1651 }
1652 | INTEGER LBRAC ctf_assignment_expression_list RBRAC
1653 {
1654 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1655 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1656 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1657 if (set_parent_node($3, $$->u.type_specifier.node))
1658 reparent_error(scanner, "integer reparent error");
1659 }
1660 ;
1661
8b9d5b5e
MD		 1662type_specifier:
1663 VOID
6dc474b8
MD		 1664 {
1665 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1666 $$->u.type_specifier.type = TYPESPEC_VOID;
1667 }
8b9d5b5e 1668 | CHAR
6dc474b8
MD		 1669 {
1670 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1671 $$->u.type_specifier.type = TYPESPEC_CHAR;
1672 }
8b9d5b5e 1673 | SHORT
6dc474b8
MD		 1674 {
1675 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1676 $$->u.type_specifier.type = TYPESPEC_SHORT;
1677 }
8b9d5b5e 1678 | INT
6dc474b8
MD		 1679 {
1680 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1681 $$->u.type_specifier.type = TYPESPEC_INT;
1682 }
8b9d5b5e 1683 | LONG
6dc474b8
MD		 1684 {
1685 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1686 $$->u.type_specifier.type = TYPESPEC_LONG;
1687 }
8b9d5b5e 1688 | FLOAT
6dc474b8
MD		 1689 {
1690 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1691 $$->u.type_specifier.type = TYPESPEC_FLOAT;
1692 }
8b9d5b5e 1693 | DOUBLE
6dc474b8
MD		 1694 {
1695 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1696 $$->u.type_specifier.type = TYPESPEC_DOUBLE;
1697 }
8b9d5b5e 1698 | SIGNED
6dc474b8
MD		 1699 {
1700 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1701 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1702 }
8b9d5b5e 1703 | UNSIGNED
6dc474b8
MD		 1704 {
1705 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1706 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1707 }
8b9d5b5e 1708 | _BOOL
6dc474b8
MD		 1709 {
1710 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1711 $$->u.type_specifier.type = TYPESPEC_BOOL;
1712 }
8b9d5b5e 1713 | _COMPLEX
6dc474b8
MD		 1714 {
1715 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1716 $$->u.type_specifier.type = TYPESPEC_COMPLEX;
1717 }
3888a159
MD		 1718 | _IMAGINARY
1719 {
1720 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1721 $$->u.type_specifier.type = TYPESPEC_IMAGINARY;
1722 }
8b9d5b5e 1723 | ID_TYPE
6dc474b8
MD		 1724 {
1725 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1726 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
8aa95b17 1727 $$->u.type_specifier.id_type = yylval.s;
6dc474b8 1728 }
8b9d5b5e 1729 | FLOATING_POINT LBRAC RBRAC
6dc474b8 1730 {
3e11b713
MD		 1731 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1732 $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
1733 $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
6dc474b8 1734 }
8b9d5b5e 1735 | FLOATING_POINT LBRAC ctf_assignment_expression_list RBRAC
6dc474b8 1736 {
3e11b713
MD		 1737 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1738 $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
1739 $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1740 if (set_parent_node($3, $$->u.type_specifier.node))
6dc474b8
MD		 1741 reparent_error(scanner, "floating point reparent error");
1742 }
8b9d5b5e 1743 | INTEGER LBRAC RBRAC
6dc474b8 1744 {
3e11b713
MD		 1745 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1746 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1747 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
6dc474b8 1748 }
8b9d5b5e 1749 | INTEGER LBRAC ctf_assignment_expression_list RBRAC
6dc474b8 1750 {
3e11b713
MD		 1751 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1752 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1753 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1754 if (set_parent_node($3, $$->u.type_specifier.node))
6dc474b8
MD		 1755 reparent_error(scanner, "integer reparent error");
1756 }
b40c8090
MD		 1757 | STRING
1758 {
1759 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1760 $$->u.type_specifier.type = TYPESPEC_STRING;
1761 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1762 }
8b9d5b5e 1763 | STRING LBRAC RBRAC
6dc474b8 1764 {
3e11b713
MD		 1765 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1766 $$->u.type_specifier.type = TYPESPEC_STRING;
1767 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
6dc474b8 1768 }
8b9d5b5e 1769 | STRING LBRAC ctf_assignment_expression_list RBRAC
6dc474b8 1770 {
3e11b713
MD		 1771 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1772 $$->u.type_specifier.type = TYPESPEC_STRING;
1773 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1774 if (set_parent_node($3, $$->u.type_specifier.node))
6dc474b8
MD		 1775 reparent_error(scanner, "string reparent error");
1776 }
8b9d5b5e 1777 | ENUM enum_type_specifier
3e11b713
MD		 1778 {
1779 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1780 $$->u.type_specifier.type = TYPESPEC_ENUM;
1781 $$->u.type_specifier.node = $2;
1782 }
8b9d5b5e 1783 | VARIANT variant_type_specifier
3e11b713
MD		 1784 {
1785 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1786 $$->u.type_specifier.type = TYPESPEC_VARIANT;
1787 $$->u.type_specifier.node = $2;
3e11b713 1788 }
8b9d5b5e 1789 | STRUCT struct_type_specifier
3e11b713
MD		 1790 {
1791 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1792 $$->u.type_specifier.type = TYPESPEC_STRUCT;
1793 $$->u.type_specifier.node = $2;
3e11b713 1794 }
8b9d5b5e
MD		 1795 ;
1796
1797struct_type_specifier:
1798 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
6dc474b8
MD		 1799 {
1800 $$ = make_node(scanner, NODE_STRUCT);
1ee8e81d 1801 $$->u._struct.has_body = 1;
5039b4cc 1802 if ($2 && set_parent_node($2, $$))
6dc474b8
MD		 1803 reparent_error(scanner, "struct reparent error");
1804 }
8b9d5b5e 1805 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
6dc474b8
MD		 1806 {
1807 $$ = make_node(scanner, NODE_STRUCT);
1ee8e81d 1808 $$->u._struct.has_body = 1;
8aa95b17 1809 $$->u._struct.name = $1;
5039b4cc 1810 if ($3 && set_parent_node($3, $$))
6dc474b8
MD		 1811 reparent_error(scanner, "struct reparent error");
1812 }
8b9d5b5e 1813 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
6dc474b8
MD		 1814 {
1815 $$ = make_node(scanner, NODE_STRUCT);
1ee8e81d 1816 $$->u._struct.has_body = 1;
8aa95b17 1817 $$->u._struct.name = $1;
5039b4cc 1818 if ($3 && set_parent_node($3, $$))
6dc474b8
MD		 1819 reparent_error(scanner, "struct reparent error");
1820 }
8b9d5b5e 1821 | IDENTIFIER
6dc474b8
MD		 1822 {
1823 $$ = make_node(scanner, NODE_STRUCT);
1ee8e81d 1824 $$->u._struct.has_body = 0;
8aa95b17 1825 $$->u._struct.name = $1;
6dc474b8 1826 }
8b9d5b5e 1827 | ID_TYPE
6dc474b8
MD		 1828 {
1829 $$ = make_node(scanner, NODE_STRUCT);
1ee8e81d 1830 $$->u._struct.has_body = 0;
8aa95b17 1831 $$->u._struct.name = $1;
6dc474b8 1832 }
b7e35bad
MD		 1833 | struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1834 {
1835 $$ = make_node(scanner, NODE_STRUCT);
1836 $$->u._struct.has_body = 1;
3122e6f0 1837 bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
b7e35bad
MD		 1838 if ($2 && set_parent_node($2, $$))
1839 reparent_error(scanner, "struct reparent error");
1840 }
1841 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1842 {
1843 $$ = make_node(scanner, NODE_STRUCT);
1844 $$->u._struct.has_body = 1;
8aa95b17 1845 $$->u._struct.name = $1;
3122e6f0 1846 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
b7e35bad
MD		 1847 if ($3 && set_parent_node($3, $$))
1848 reparent_error(scanner, "struct reparent error");
1849 }
1850 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1851 {
1852 $$ = make_node(scanner, NODE_STRUCT);
1853 $$->u._struct.has_body = 1;
8aa95b17 1854 $$->u._struct.name = $1;
3122e6f0 1855 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
b7e35bad
MD		 1856 if ($3 && set_parent_node($3, $$))
1857 reparent_error(scanner, "struct reparent error");
1858 }
8b9d5b5e
MD		 1859 ;
1860
1861struct_declaration_begin:
1862 LBRAC
fce8006d 1863 { push_scope(scanner); }
8b9d5b5e
MD		 1864 ;
1865
1866struct_declaration_end:
1867 RBRAC
fce8006d 1868 { pop_scope(scanner); }
8b9d5b5e
MD		 1869 ;
1870
1871variant_type_specifier:
1872 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1873 {
1874 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1875 $$->u.variant.has_body = 1;
5039b4cc 1876 if ($2 && set_parent_node($2, $$))
6dc474b8
MD		 1877 reparent_error(scanner, "variant reparent error");
1878 }
8b9d5b5e 1879 | LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1880 {
1881 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1882 $$->u.variant.has_body = 1;
8aa95b17 1883 $$->u.variant.choice = $2;
5039b4cc 1884 if ($5 && set_parent_node($5, $$))
6dc474b8
MD		 1885 reparent_error(scanner, "variant reparent error");
1886 }
8b9d5b5e 1887 | LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1888 {
1889 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1890 $$->u.variant.has_body = 1;
8aa95b17 1891 $$->u.variant.choice = $2;
5039b4cc 1892 if ($5 && set_parent_node($5, $$))
6dc474b8
MD		 1893 reparent_error(scanner, "variant reparent error");
1894 }
8b9d5b5e 1895 | IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1896 {
1897 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1898 $$->u.variant.has_body = 1;
8aa95b17 1899 $$->u.variant.name = $1;
5039b4cc 1900 if ($3 && set_parent_node($3, $$))
6dc474b8
MD		 1901 reparent_error(scanner, "variant reparent error");
1902 }
8b9d5b5e 1903 | IDENTIFIER LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1904 {
1905 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1906 $$->u.variant.has_body = 1;
8aa95b17
MD		 1907 $$->u.variant.name = $1;
1908 $$->u.variant.choice = $3;
5039b4cc 1909 if ($6 && set_parent_node($6, $$))
6dc474b8
MD		 1910 reparent_error(scanner, "variant reparent error");
1911 }
8b9d5b5e 1912 | IDENTIFIER LT IDENTIFIER GT
6dc474b8
MD		 1913 {
1914 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1915 $$->u.variant.has_body = 0;
8aa95b17
MD		 1916 $$->u.variant.name = $1;
1917 $$->u.variant.choice = $3;
6dc474b8 1918 }
8b9d5b5e 1919 | IDENTIFIER LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1920 {
1921 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1922 $$->u.variant.has_body = 1;
8aa95b17
MD		 1923 $$->u.variant.name = $1;
1924 $$->u.variant.choice = $3;
5039b4cc 1925 if ($6 && set_parent_node($6, $$))
6dc474b8
MD		 1926 reparent_error(scanner, "variant reparent error");
1927 }
8b9d5b5e 1928 | IDENTIFIER LT ID_TYPE GT
6dc474b8
MD		 1929 {
1930 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1931 $$->u.variant.has_body = 0;
8aa95b17
MD		 1932 $$->u.variant.name = $1;
1933 $$->u.variant.choice = $3;
6dc474b8 1934 }
8b9d5b5e 1935 | ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1936 {
1937 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1938 $$->u.variant.has_body = 1;
8aa95b17 1939 $$->u.variant.name = $1;
5039b4cc 1940 if ($3 && set_parent_node($3, $$))
6dc474b8
MD		 1941 reparent_error(scanner, "variant reparent error");
1942 }
8b9d5b5e 1943 | ID_TYPE LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1944 {
1945 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1946 $$->u.variant.has_body = 1;
8aa95b17
MD		 1947 $$->u.variant.name = $1;
1948 $$->u.variant.choice = $3;
5039b4cc 1949 if ($6 && set_parent_node($6, $$))
6dc474b8
MD		 1950 reparent_error(scanner, "variant reparent error");
1951 }
8b9d5b5e 1952 | ID_TYPE LT IDENTIFIER GT
6dc474b8
MD		 1953 {
1954 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1955 $$->u.variant.has_body = 0;
8aa95b17
MD		 1956 $$->u.variant.name = $1;
1957 $$->u.variant.choice = $3;
6dc474b8 1958 }
8b9d5b5e 1959 | ID_TYPE LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1960 {
1961 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1962 $$->u.variant.has_body = 1;
8aa95b17
MD		 1963 $$->u.variant.name = $1;
1964 $$->u.variant.choice = $3;
5039b4cc 1965 if ($6 && set_parent_node($6, $$))
6dc474b8
MD		 1966 reparent_error(scanner, "variant reparent error");
1967 }
8b9d5b5e 1968 | ID_TYPE LT ID_TYPE GT
6dc474b8
MD		 1969 {
1970 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1971 $$->u.variant.has_body = 0;
8aa95b17
MD		 1972 $$->u.variant.name = $1;
1973 $$->u.variant.choice = $3;
6dc474b8 1974 }
8b9d5b5e
MD		 1975 ;
1976
1977variant_declaration_begin:
1978 LBRAC
fce8006d 1979 { push_scope(scanner); }
8b9d5b5e
MD		 1980 ;
1981
1982variant_declaration_end:
1983 RBRAC
fce8006d 1984 { pop_scope(scanner); }
8b9d5b5e
MD		 1985 ;
1986
8b9d5b5e
MD		 1987enum_type_specifier:
1988 LBRAC enumerator_list RBRAC
6dc474b8
MD		 1989 {
1990 $$ = make_node(scanner, NODE_ENUM);
add40b62 1991 $$->u._enum.has_body = 1;
3122e6f0 1992 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 1993 }
0fbb34a5 1994 | COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
6dc474b8
MD		 1995 {
1996 $$ = make_node(scanner, NODE_ENUM);
add40b62 1997 $$->u._enum.has_body = 1;
3e11b713 1998 ($$)->u._enum.container_type = $2;
3122e6f0 1999 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2000 }
8b9d5b5e 2001 | IDENTIFIER LBRAC enumerator_list RBRAC
6dc474b8
MD		 2002 {
2003 $$ = make_node(scanner, NODE_ENUM);
add40b62 2004 $$->u._enum.has_body = 1;
8aa95b17 2005 $$->u._enum.enum_id = $1;
3122e6f0 2006 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2007 }
0fbb34a5 2008 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
6dc474b8
MD		 2009 {
2010 $$ = make_node(scanner, NODE_ENUM);
add40b62 2011 $$->u._enum.has_body = 1;
8aa95b17 2012 $$->u._enum.enum_id = $1;
3e11b713 2013 ($$)->u._enum.container_type = $3;
3122e6f0 2014 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2015 }
8b9d5b5e 2016 | ID_TYPE LBRAC enumerator_list RBRAC
6dc474b8
MD		 2017 {
2018 $$ = make_node(scanner, NODE_ENUM);
add40b62 2019 $$->u._enum.has_body = 1;
8aa95b17 2020 $$->u._enum.enum_id = $1;
3122e6f0 2021 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2022 }
0fbb34a5 2023 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
6dc474b8
MD		 2024 {
2025 $$ = make_node(scanner, NODE_ENUM);
add40b62 2026 $$->u._enum.has_body = 1;
8aa95b17 2027 $$->u._enum.enum_id = $1;
3e11b713 2028 ($$)->u._enum.container_type = $3;
3122e6f0 2029 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2030 }
8b9d5b5e 2031 | LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 2032 {
2033 $$ = make_node(scanner, NODE_ENUM);
add40b62 2034 $$->u._enum.has_body = 1;
3122e6f0 2035 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2036 }
0fbb34a5 2037 | COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 2038 {
2039 $$ = make_node(scanner, NODE_ENUM);
add40b62 2040 $$->u._enum.has_body = 1;
3e11b713 2041 ($$)->u._enum.container_type = $2;
3122e6f0 2042 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2043 }
8b9d5b5e 2044 | IDENTIFIER LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 2045 {
2046 $$ = make_node(scanner, NODE_ENUM);
add40b62 2047 $$->u._enum.has_body = 1;
8aa95b17 2048 $$->u._enum.enum_id = $1;
3122e6f0 2049 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2050 }
0fbb34a5 2051 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 2052 {
2053 $$ = make_node(scanner, NODE_ENUM);
add40b62 2054 $$->u._enum.has_body = 1;
8aa95b17 2055 $$->u._enum.enum_id = $1;
3e11b713 2056 ($$)->u._enum.container_type = $3;
3122e6f0 2057 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2058 }
8b9d5b5e 2059 | IDENTIFIER
6dc474b8
MD		 2060 {
2061 $$ = make_node(scanner, NODE_ENUM);
add40b62 2062 $$->u._enum.has_body = 0;
8aa95b17 2063 $$->u._enum.enum_id = $1;
6dc474b8 2064 }
8b9d5b5e 2065 | ID_TYPE LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 2066 {
2067 $$ = make_node(scanner, NODE_ENUM);
add40b62 2068 $$->u._enum.has_body = 1;
8aa95b17 2069 $$->u._enum.enum_id = $1;
3122e6f0 2070 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2071 }
0fbb34a5 2072 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 2073 {
2074 $$ = make_node(scanner, NODE_ENUM);
add40b62 2075 $$->u._enum.has_body = 1;
8aa95b17 2076 $$->u._enum.enum_id = $1;
3e11b713 2077 ($$)->u._enum.container_type = $3;
3122e6f0 2078 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2079 }
8b9d5b5e 2080 | ID_TYPE
6dc474b8
MD		 2081 {
2082 $$ = make_node(scanner, NODE_ENUM);
add40b62 2083 $$->u._enum.has_body = 0;
8aa95b17 2084 $$->u._enum.enum_id = $1;
6dc474b8 2085 }
8b9d5b5e
MD		 2086 ;
2087
2088struct_or_variant_declaration_list:
2089 /* empty */
6dc474b8 2090 { $$ = NULL; }
8b9d5b5e 2091 | struct_or_variant_declaration_list struct_or_variant_declaration
6dc474b8
MD		 2092 {
2093 if ($1) {
2094 $$ = $1;
3122e6f0 2095 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
6dc474b8
MD		 2096 } else {
2097 $$ = $2;
3122e6f0 2098 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8
MD		 2099 }
2100 }
8b9d5b5e
MD		 2101 ;
2102
2103struct_or_variant_declaration:
1ee8e81d 2104 declaration_specifiers struct_or_variant_declarator_list SEMICOLON
6dc474b8 2105 {
3e11b713
MD		 2106 struct ctf_node *list;
2107
2108 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
3122e6f0 2109 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
6dc474b8 2110 $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
3e11b713 2111 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
3122e6f0 2112 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
6dc474b8 2113 }
1ee8e81d 2114 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
6dc474b8 2115 {
3e11b713
MD		 2116 struct ctf_node *list;
2117
6dc474b8 2118 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 2119 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2120 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 2121 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2122 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2123 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2124 }
1ee8e81d 2125 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
6dc474b8 2126 {
3e11b713
MD		 2127 struct ctf_node *list;
2128
6dc474b8 2129 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 2130 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2131 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 2132 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2133 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2134 }
1ee8e81d 2135 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
6dc474b8 2136 {
3e11b713
MD		 2137 struct ctf_node *list;
2138
2139 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
3122e6f0 2140 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
6dc474b8 2141 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713 2142 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
3122e6f0 2143 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2144 }
a030d084 2145 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
6dc474b8 2146 {
3e11b713
MD		 2147 struct ctf_node *list;
2148
6dc474b8
MD		 2149 $$ = make_node(scanner, NODE_TYPEALIAS);
2150 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2151 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
3e11b713
MD		 2152
2153 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2154 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
3122e6f0
JD		 2155 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2156 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
3e11b713
MD		 2157
2158 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2159 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
3122e6f0
JD		 2160 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2161 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
6dc474b8 2162 }
8b9d5b5e
MD		 2163 ;
2164
1ee8e81d 2165alias_declaration_specifiers:
8b9d5b5e 2166 CONST
6dc474b8 2167 {
3e11b713
MD		 2168 struct ctf_node *node;
2169
2170 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2171 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2172 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 2173 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 2174 }
8b9d5b5e 2175 | type_specifier
3e11b713
MD		 2176 {
2177 struct ctf_node *node;
2178
2179 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2180 node = $1;
3122e6f0 2181 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
3e11b713 2182 }
1ee8e81d
MD		 2183 | IDENTIFIER
2184 {
3e11b713
MD		 2185 struct ctf_node *node;
2186
1ee8e81d 2187 add_type(scanner, $1);
3e11b713
MD		 2188 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2189 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2190 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
8aa95b17 2191 node->u.type_specifier.id_type = yylval.s;
3122e6f0 2192 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1ee8e81d
MD		 2193 }
2194 | alias_declaration_specifiers CONST
6dc474b8
MD		 2195 {
2196 struct ctf_node *node;
2197
2198 $$ = $1;
2199 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2200 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 2201 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 2202 }
1ee8e81d 2203 | alias_declaration_specifiers type_specifier
6dc474b8
MD		 2204 {
2205 $$ = $1;
3122e6f0 2206 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 2207 }
1ee8e81d
MD		 2208 | alias_declaration_specifiers IDENTIFIER
2209 {
2210 struct ctf_node *node;
2211
2212 add_type(scanner, $2);
2213 $$ = $1;
2214 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2215 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
8aa95b17 2216 node->u.type_specifier.id_type = yylval.s;
3122e6f0 2217 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1ee8e81d 2218 }
8b9d5b5e
MD		 2219 ;
2220
2221struct_or_variant_declarator_list:
2222 struct_or_variant_declarator
0009a725 2223 { $$ = $1; }
8b9d5b5e 2224 | struct_or_variant_declarator_list COMMA struct_or_variant_declarator
6dc474b8
MD		 2225 {
2226 $$ = $1;
3122e6f0 2227 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
6dc474b8 2228 }
8b9d5b5e
MD		 2229 ;
2230
2231struct_or_variant_declarator:
2232 declarator
6dc474b8 2233 { $$ = $1; }
8b9d5b5e 2234 | COLON unary_expression
6dc474b8 2235 { $$ = $2; }
8b9d5b5e 2236 | declarator COLON unary_expression
6dc474b8
MD		 2237 {
2238 $$ = $1;
48a01768 2239 if (set_parent_node($3, $1))
6dc474b8
MD		 2240 reparent_error(scanner, "struct_or_variant_declarator");
2241 }
8b9d5b5e
MD		 2242 ;
2243
2244enumerator_list:
2245 enumerator
0009a725 2246 { $$ = $1; }
8b9d5b5e 2247 | enumerator_list COMMA enumerator
6dc474b8
MD		 2248 {
2249 $$ = $1;
3122e6f0 2250 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
6dc474b8 2251 }
8b9d5b5e
MD		 2252 ;
2253
2254enumerator:
2255 IDENTIFIER
6dc474b8
MD		 2256 {
2257 $$ = make_node(scanner, NODE_ENUMERATOR);
8aa95b17 2258 $$->u.enumerator.id = $1;
6dc474b8 2259 }
8b9d5b5e 2260 | ID_TYPE
6dc474b8
MD		 2261 {
2262 $$ = make_node(scanner, NODE_ENUMERATOR);
8aa95b17 2263 $$->u.enumerator.id = $1;
6dc474b8 2264 }
8b9d5b5e 2265 | keywords
6dc474b8
MD		 2266 {
2267 $$ = make_node(scanner, NODE_ENUMERATOR);
8aa95b17 2268 $$->u.enumerator.id = $1;
6dc474b8 2269 }
d876a5ba 2270 | STRING_LITERAL
6dc474b8
MD		 2271 {
2272 $$ = make_node(scanner, NODE_ENUMERATOR);
8aa95b17 2273 $$->u.enumerator.id = $1;
6dc474b8 2274 }
8b9d5b5e 2275 | IDENTIFIER EQUAL unary_expression_or_range
6dc474b8
MD		 2276 {
2277 $$ = make_node(scanner, NODE_ENUMERATOR);
8aa95b17 2278 $$->u.enumerator.id = $1;
3122e6f0 2279 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
6dc474b8 2280 }
8b9d5b5e 2281 | ID_TYPE EQUAL unary_expression_or_range
6dc474b8
MD		 2282 {
2283 $$ = make_node(scanner, NODE_ENUMERATOR);
8aa95b17 2284 $$->u.enumerator.id = $1;
3122e6f0 2285 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
6dc474b8 2286 }
8b9d5b5e 2287 | keywords EQUAL unary_expression_or_range
6dc474b8
MD		 2288 {
2289 $$ = make_node(scanner, NODE_ENUMERATOR);
8aa95b17 2290 $$->u.enumerator.id = $1;
3122e6f0 2291 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
6dc474b8 2292 }
d876a5ba 2293 | STRING_LITERAL EQUAL unary_expression_or_range
6dc474b8
MD		 2294 {
2295 $$ = make_node(scanner, NODE_ENUMERATOR);
8aa95b17 2296 $$->u.enumerator.id = $1;
d876a5ba 2297 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
6dc474b8 2298 }
8b9d5b5e
MD		 2299 ;
2300
2301abstract_declarator_list:
2302 abstract_declarator
0009a725 2303 { $$ = $1; }
8b9d5b5e 2304 | abstract_declarator_list COMMA abstract_declarator
6dc474b8
MD		 2305 {
2306 $$ = $1;
3122e6f0 2307 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
6dc474b8 2308 }
8b9d5b5e
MD		 2309 ;
2310
2311abstract_declarator:
2312 direct_abstract_declarator
6dc474b8 2313 { $$ = $1; }
8b9d5b5e 2314 | pointer direct_abstract_declarator
6dc474b8
MD		 2315 {
2316 $$ = $2;
3122e6f0 2317 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
6dc474b8 2318 }
8b9d5b5e
MD		 2319 ;
2320
2321direct_abstract_declarator:
2322 /* empty */
6dc474b8
MD		 2323 {
2324 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2325 $$->u.type_declarator.type = TYPEDEC_ID;
2326 /* id is NULL */
2327 }
8b9d5b5e 2328 | IDENTIFIER
6dc474b8
MD		 2329 {
2330 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2331 $$->u.type_declarator.type = TYPEDEC_ID;
8aa95b17 2332 $$->u.type_declarator.u.id = $1;
6dc474b8 2333 }
8b9d5b5e 2334 | LPAREN abstract_declarator RPAREN
6dc474b8
MD		 2335 {
2336 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2337 $$->u.type_declarator.type = TYPEDEC_NESTED;
2338 $$->u.type_declarator.u.nested.type_declarator = $2;
2339 }
98df1c9f 2340 | direct_abstract_declarator LSBRAC unary_expression RSBRAC
6dc474b8
MD		 2341 {
2342 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2343 $$->u.type_declarator.type = TYPEDEC_NESTED;
2344 $$->u.type_declarator.u.nested.type_declarator = $1;
3122e6f0
JD		 2345 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2346 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
6dc474b8 2347 }
8b9d5b5e 2348 | direct_abstract_declarator LSBRAC RSBRAC
6dc474b8
MD		 2349 {
2350 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2351 $$->u.type_declarator.type = TYPEDEC_NESTED;
2352 $$->u.type_declarator.u.nested.type_declarator = $1;
2353 $$->u.type_declarator.u.nested.abstract_array = 1;
2354 }
8b9d5b5e
MD		 2355 ;
2356
e0c14875
MD		 2357alias_abstract_declarator_list:
2358 alias_abstract_declarator
6dc474b8 2359 { $$ = $1; }
e0c14875
MD		 2360 | alias_abstract_declarator_list COMMA alias_abstract_declarator
2361 {
2362 $$ = $1;
3122e6f0 2363 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
e0c14875
MD		 2364 }
2365 ;
2366
2367alias_abstract_declarator:
2368 direct_alias_abstract_declarator
2369 { $$ = $1; }
2370 | pointer direct_alias_abstract_declarator
6dc474b8
MD		 2371 {
2372 $$ = $2;
3122e6f0 2373 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
6dc474b8 2374 }
8b9d5b5e
MD		 2375 ;
2376
e0c14875
MD		 2377direct_alias_abstract_declarator:
2378 /* empty */
6dc474b8
MD		 2379 {
2380 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
e0c14875
MD		 2381 $$->u.type_declarator.type = TYPEDEC_ID;
2382 /* id is NULL */
6dc474b8 2383 }
e0c14875 2384 | LPAREN alias_abstract_declarator RPAREN
6dc474b8
MD		 2385 {
2386 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2387 $$->u.type_declarator.type = TYPEDEC_NESTED;
2388 $$->u.type_declarator.u.nested.type_declarator = $2;
2389 }
98df1c9f 2390 | direct_alias_abstract_declarator LSBRAC unary_expression RSBRAC
6dc474b8
MD		 2391 {
2392 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2393 $$->u.type_declarator.type = TYPEDEC_NESTED;
2394 $$->u.type_declarator.u.nested.type_declarator = $1;
3122e6f0
JD		 2395 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2396 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
6dc474b8 2397 }
e0c14875
MD		 2398 | direct_alias_abstract_declarator LSBRAC RSBRAC
2399 {
2400 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2401 $$->u.type_declarator.type = TYPEDEC_NESTED;
2402 $$->u.type_declarator.u.nested.type_declarator = $1;
2403 $$->u.type_declarator.u.nested.abstract_array = 1;
2404 }
8b9d5b5e
MD		 2405 ;
2406
e0c14875
MD		 2407declarator:
2408 direct_declarator
6dc474b8 2409 { $$ = $1; }
e0c14875 2410 | pointer direct_declarator
6dc474b8
MD		 2411 {
2412 $$ = $2;
3122e6f0 2413 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
6dc474b8 2414 }
8b9d5b5e
MD		 2415 ;
2416
e0c14875 2417direct_declarator:
8b9d5b5e 2418 IDENTIFIER
6dc474b8 2419 {
6dc474b8
MD		 2420 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2421 $$->u.type_declarator.type = TYPEDEC_ID;
8aa95b17 2422 $$->u.type_declarator.u.id = $1;
6dc474b8 2423 }
e0c14875 2424 | LPAREN declarator RPAREN
6dc474b8
MD		 2425 {
2426 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2427 $$->u.type_declarator.type = TYPEDEC_NESTED;
2428 $$->u.type_declarator.u.nested.type_declarator = $2;
2429 }
98df1c9f 2430 | direct_declarator LSBRAC unary_expression RSBRAC
6dc474b8
MD		 2431 {
2432 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2433 $$->u.type_declarator.type = TYPEDEC_NESTED;
2434 $$->u.type_declarator.u.nested.type_declarator = $1;
3122e6f0
JD		 2435 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2436 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
6dc474b8 2437 }
8b9d5b5e
MD		 2438 ;
2439
e0c14875
MD		 2440type_declarator:
2441 direct_type_declarator
6dc474b8 2442 { $$ = $1; }
e0c14875 2443 | pointer direct_type_declarator
6dc474b8
MD		 2444 {
2445 $$ = $2;
3122e6f0 2446 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
6dc474b8 2447 }
8b9d5b5e
MD		 2448 ;
2449
e0c14875
MD		 2450direct_type_declarator:
2451 IDENTIFIER
6dc474b8
MD		 2452 {
2453 add_type(scanner, $1);
2454 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2455 $$->u.type_declarator.type = TYPEDEC_ID;
8aa95b17 2456 $$->u.type_declarator.u.id = $1;
6dc474b8 2457 }
e0c14875 2458 | LPAREN type_declarator RPAREN
6dc474b8
MD		 2459 {
2460 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2461 $$->u.type_declarator.type = TYPEDEC_NESTED;
2462 $$->u.type_declarator.u.nested.type_declarator = $2;
2463 }
98df1c9f 2464 | direct_type_declarator LSBRAC unary_expression RSBRAC
6dc474b8
MD		 2465 {
2466 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2467 $$->u.type_declarator.type = TYPEDEC_NESTED;
2468 $$->u.type_declarator.u.nested.type_declarator = $1;
3122e6f0
JD		 2469 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2470 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
6dc474b8 2471 }
8b9d5b5e
MD		 2472 ;
2473
2474pointer:
2475 STAR
48a01768
MD		 2476 {
2477 $$ = make_node(scanner, NODE_POINTER);
48a01768 2478 }
8b9d5b5e 2479 | STAR pointer
6dc474b8
MD		 2480 {
2481 $$ = make_node(scanner, NODE_POINTER);
3122e6f0 2482 bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
6dc474b8 2483 }
8b9d5b5e 2484 | STAR type_qualifier_list pointer
6dc474b8
MD		 2485 {
2486 $$ = make_node(scanner, NODE_POINTER);
2487 $$->u.pointer.const_qualifier = 1;
3122e6f0 2488 bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
6dc474b8 2489 }
8b9d5b5e
MD		 2490 ;
2491
2492type_qualifier_list:
6dc474b8 2493 /* pointer assumes only const type qualifier */
8b9d5b5e
MD		 2494 CONST
2495 | type_qualifier_list CONST
2496 ;
2497
2498/* 2.3: CTF-specific declarations */
2499
2500ctf_assignment_expression_list:
2501 ctf_assignment_expression SEMICOLON
0009a725 2502 { $$ = $1; }
8b9d5b5e 2503 | ctf_assignment_expression_list ctf_assignment_expression SEMICOLON
6dc474b8
MD		 2504 {
2505 $$ = $1;
3122e6f0 2506 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
6dc474b8 2507 }
8b9d5b5e
MD		 2508 ;
2509
2510ctf_assignment_expression:
2511 unary_expression EQUAL unary_expression
02b234c4 2512 {
6dc474b8
MD		 2513 /*
2514 * Because we have left and right, cannot use
48a01768 2515 * set_parent_node.
6dc474b8 2516 */
02b234c4 2517 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
3122e6f0 2518 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
6dc474b8
MD		 2519 if ($1->u.unary_expression.type != UNARY_STRING)
2520 reparent_error(scanner, "ctf_assignment_expression left expects string");
3122e6f0 2521 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
02b234c4 2522 }
427c09b7 2523 | unary_expression TYPEASSIGN declaration_specifiers /* Only allow struct */
6dc474b8
MD		 2524 {
2525 /*
2526 * Because we have left and right, cannot use
48a01768 2527 * set_parent_node.
6dc474b8
MD		 2528 */
2529 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
3122e6f0 2530 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
6dc474b8
MD		 2531 if ($1->u.unary_expression.type != UNARY_STRING)
2532 reparent_error(scanner, "ctf_assignment_expression left expects string");
3122e6f0 2533 bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
6dc474b8 2534 }
8b9d5b5e 2535 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list
6dc474b8 2536 {
3e11b713
MD		 2537 struct ctf_node *list;
2538
2539 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
3122e6f0
JD		 2540 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2541 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
6dc474b8 2542 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713 2543 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
3122e6f0 2544 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2545 }
8b9d5b5e 2546 | TYPEDEF declaration_specifiers type_declarator_list
6dc474b8 2547 {
3e11b713
MD		 2548 struct ctf_node *list;
2549
6dc474b8 2550 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 2551 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2552 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 2553 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2554 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2555 }
8b9d5b5e 2556 | declaration_specifiers TYPEDEF type_declarator_list
6dc474b8 2557 {
3e11b713
MD		 2558 struct ctf_node *list;
2559
2560 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
3122e6f0 2561 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
6dc474b8 2562 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713 2563 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
3122e6f0 2564 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2565 }
a030d084 2566 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
6dc474b8 2567 {
3e11b713
MD		 2568 struct ctf_node *list;
2569
6dc474b8
MD		 2570 $$ = make_node(scanner, NODE_TYPEALIAS);
2571 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2572 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
3e11b713
MD		 2573
2574 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2575 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
3122e6f0
JD		 2576 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2577 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
3e11b713
MD		 2578
2579 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2580 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
3122e6f0
JD		 2581 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2582 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
6dc474b8 2583 }
8b9d5b5e 2584 ;
BabelTrace - Trace Format Babel Tower
This page took 0.166025 seconds and 4 git commands to generate.