projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Python bindings: return char arrays as strings in value()
[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
cf7be03d 61int yyparse(struct ctf_scanner *scanner, yyscan_t yyscanner);
5d6c80a5 62BT_HIDDEN
cf7be03d 63int yylex(union YYSTYPE *yyval, yyscan_t yyscanner);
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
cf7be03d 69void yyrestart(FILE * in_str, yyscan_t yyscanner);
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
cf7be03d 937void yyerror(struct ctf_scanner *scanner, yyscan_t yyscanner, 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 { \
cf7be03d 952 yyerror(scanner, scanner->scanner, YY_("reparent_error: " str)); \
6dc474b8
MD		 953 YYERROR; \
954} while (0)
955
d088404e 956static struct ctf_ast *ctf_ast_alloc(struct ctf_scanner *scanner)
8b9d5b5e 957{
34d3acc4
MD		 958 struct ctf_ast *ast;
959
d088404e 960 ast = objstack_alloc(scanner->objstack, sizeof(*ast));
34d3acc4
MD		 961 if (!ast)
962 return NULL;
02b234c4 963 ast->root.type = NODE_ROOT;
3122e6f0
JD		 964 BT_INIT_LIST_HEAD(&ast->root.tmp_head);
965 BT_INIT_LIST_HEAD(&ast->root.u.root.declaration_list);
966 BT_INIT_LIST_HEAD(&ast->root.u.root.trace);
967 BT_INIT_LIST_HEAD(&ast->root.u.root.env);
968 BT_INIT_LIST_HEAD(&ast->root.u.root.stream);
969 BT_INIT_LIST_HEAD(&ast->root.u.root.event);
970 BT_INIT_LIST_HEAD(&ast->root.u.root.clock);
f133896d 971 BT_INIT_LIST_HEAD(&ast->root.u.root.callsite);
34d3acc4
MD		 972 return ast;
973}
974
34d3acc4
MD		 975int ctf_scanner_append_ast(struct ctf_scanner *scanner)
976{
cf7be03d 977 return yyparse(scanner, scanner->scanner);
34d3acc4
MD		 978}
979
980struct ctf_scanner *ctf_scanner_alloc(FILE *input)
981{
982 struct ctf_scanner *scanner;
983 int ret;
984
a3983482
MD		 985 yydebug = babeltrace_debug;
986
34d3acc4
MD		 987 scanner = malloc(sizeof(*scanner));
988 if (!scanner)
989 return NULL;
990 memset(scanner, 0, sizeof(*scanner));
991
992 ret = yylex_init_extra(scanner, &scanner->scanner);
993 if (ret) {
c55adfb9 994 printf_fatal("yylex_init error");
34d3acc4
MD		 995 goto cleanup_scanner;
996 }
65102a8c
MD		 997 /* Start processing new stream */
998 yyrestart(input, scanner->scanner);
34d3acc4 999
8aa95b17
MD		 1000 scanner->objstack = objstack_create();
1001 if (!scanner->objstack)
d088404e
MD		 1002 goto cleanup_lexer;
1003 scanner->ast = ctf_ast_alloc(scanner);
1004 if (!scanner->ast)
1005 goto cleanup_objstack;
34d3acc4 1006 init_scope(&scanner->root_scope, NULL);
19d96da7 1007 scanner->cs = &scanner->root_scope;
34d3acc4 1008
65102a8c
MD		 1009 if (yydebug)
1010 fprintf(stdout, "Scanner input is a%s.\n",
1011 isatty(fileno(input)) ? "n interactive tty" :
1012 " noninteractive file");
1013
34d3acc4
MD		 1014 return scanner;
1015
d088404e
MD		 1016cleanup_objstack:
1017 objstack_destroy(scanner->objstack);
34d3acc4
MD		 1018cleanup_lexer:
1019 ret = yylex_destroy(scanner->scanner);
1020 if (!ret)
c55adfb9 1021 printf_fatal("yylex_destroy error");
34d3acc4
MD		 1022cleanup_scanner:
1023 free(scanner);
1024 return NULL;
1025}
1026
1027void ctf_scanner_free(struct ctf_scanner *scanner)
1028{
1029 int ret;
1030
1031 finalize_scope(&scanner->root_scope);
8aa95b17 1032 objstack_destroy(scanner->objstack);
34d3acc4
MD		 1033 ret = yylex_destroy(scanner->scanner);
1034 if (ret)
c55adfb9 1035 printf_error("yylex_destroy error");
34d3acc4
MD		 1036 free(scanner);
1037}
8b9d5b5e
MD		 1038
1039%}
1040
34d3acc4
MD		 1041%define api.pure
1042 /* %locations */
8c834e5a 1043%error-verbose
34d3acc4 1044%parse-param {struct ctf_scanner *scanner}
cf7be03d
MD		 1045%parse-param {yyscan_t yyscanner}
1046%lex-param {yyscan_t yyscanner}
0fbb34a5
MD		 1047/*
1048 * Expect two shift-reduce conflicts. Caused by enum name-opt : type {}
1049 * vs struct { int :value; } (unnamed bit-field). The default is to
1050 * shift, so whenever we encounter an enumeration, we are doing the
1051 * proper thing (shift). It is illegal to declare an enumeration
1052 * "bit-field", so it is OK if this situation ends up in a parsing
1053 * error.
1054 */
1055%expect 2
8b9d5b5e 1056%start file
80b07bd7 1057%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 1058%token <s> IDENTIFIER ID_TYPE
8b9d5b5e
MD		 1059%token ERROR
1060%union
1061{
1062 long long ll;
80b07bd7 1063 unsigned long long ull;
8b9d5b5e 1064 char c;
8aa95b17 1065 char *s;
8b9d5b5e
MD		 1066 struct ctf_node *n;
1067}
1068
8aa95b17 1069%type <s> STRING_LITERAL CHARACTER_LITERAL
d876a5ba 1070
8aa95b17 1071%type <s> keywords
6dc474b8 1072
80b07bd7 1073%type <ull> INTEGER_LITERAL
6dc474b8
MD		 1074%type <n> postfix_expression unary_expression unary_expression_or_range
1075
1076%type <n> declaration
02b234c4 1077%type <n> event_declaration
6dc474b8 1078%type <n> stream_declaration
e2c76a4d 1079%type <n> env_declaration
6dc474b8 1080%type <n> trace_declaration
73d15916 1081%type <n> clock_declaration
f133896d 1082%type <n> callsite_declaration
0fbb34a5 1083%type <n> integer_declaration_specifiers
6dc474b8 1084%type <n> declaration_specifiers
1ee8e81d 1085%type <n> alias_declaration_specifiers
6dc474b8
MD		 1086
1087%type <n> type_declarator_list
0fbb34a5 1088%type <n> integer_type_specifier
6dc474b8
MD		 1089%type <n> type_specifier
1090%type <n> struct_type_specifier
1091%type <n> variant_type_specifier
6dc474b8
MD		 1092%type <n> enum_type_specifier
1093%type <n> struct_or_variant_declaration_list
1094%type <n> struct_or_variant_declaration
6dc474b8
MD		 1095%type <n> struct_or_variant_declarator_list
1096%type <n> struct_or_variant_declarator
1097%type <n> enumerator_list
1098%type <n> enumerator
1099%type <n> abstract_declarator_list
1100%type <n> abstract_declarator
1101%type <n> direct_abstract_declarator
e0c14875
MD		 1102%type <n> alias_abstract_declarator_list
1103%type <n> alias_abstract_declarator
1104%type <n> direct_alias_abstract_declarator
6dc474b8
MD		 1105%type <n> declarator
1106%type <n> direct_declarator
1107%type <n> type_declarator
1108%type <n> direct_type_declarator
6dc474b8 1109%type <n> pointer
02b234c4
MD		 1110%type <n> ctf_assignment_expression_list
1111%type <n> ctf_assignment_expression
1112
8b9d5b5e
MD		 1113%%
1114
1115file:
1116 declaration
6dc474b8 1117 {
48a01768 1118 if (set_parent_node($1, &ctf_scanner_get_ast(scanner)->root))
6dc474b8
MD		 1119 reparent_error(scanner, "error reparenting to root");
1120 }
8b9d5b5e 1121 | file declaration
6dc474b8 1122 {
48a01768 1123 if (set_parent_node($2, &ctf_scanner_get_ast(scanner)->root))
6dc474b8
MD		 1124 reparent_error(scanner, "error reparenting to root");
1125 }
8b9d5b5e
MD		 1126 ;
1127
1128keywords:
1129 VOID
8aa95b17 1130 { $$ = yylval.s; }
8b9d5b5e 1131 | CHAR
8aa95b17 1132 { $$ = yylval.s; }
8b9d5b5e 1133 | SHORT
8aa95b17 1134 { $$ = yylval.s; }
8b9d5b5e 1135 | INT
8aa95b17 1136 { $$ = yylval.s; }
8b9d5b5e 1137 | LONG
8aa95b17 1138 { $$ = yylval.s; }
8b9d5b5e 1139 | FLOAT
8aa95b17 1140 { $$ = yylval.s; }
8b9d5b5e 1141 | DOUBLE
8aa95b17 1142 { $$ = yylval.s; }
8b9d5b5e 1143 | SIGNED
8aa95b17 1144 { $$ = yylval.s; }
8b9d5b5e 1145 | UNSIGNED
8aa95b17 1146 { $$ = yylval.s; }
8b9d5b5e 1147 | _BOOL
8aa95b17 1148 { $$ = yylval.s; }
8b9d5b5e 1149 | _COMPLEX
8aa95b17 1150 { $$ = yylval.s; }
3888a159 1151 | _IMAGINARY
8aa95b17 1152 { $$ = yylval.s; }
8b9d5b5e 1153 | FLOATING_POINT
8aa95b17 1154 { $$ = yylval.s; }
8b9d5b5e 1155 | INTEGER
8aa95b17 1156 { $$ = yylval.s; }
8b9d5b5e 1157 | STRING
8aa95b17 1158 { $$ = yylval.s; }
8b9d5b5e 1159 | ENUM
8aa95b17 1160 { $$ = yylval.s; }
8b9d5b5e 1161 | VARIANT
8aa95b17 1162 { $$ = yylval.s; }
8b9d5b5e 1163 | STRUCT
8aa95b17 1164 { $$ = yylval.s; }
8b9d5b5e 1165 | CONST
8aa95b17 1166 { $$ = yylval.s; }
8b9d5b5e 1167 | TYPEDEF
8aa95b17 1168 { $$ = yylval.s; }
8b9d5b5e 1169 | EVENT
8aa95b17 1170 { $$ = yylval.s; }
8b9d5b5e 1171 | STREAM
8aa95b17 1172 { $$ = yylval.s; }
d2ea163b 1173 | ENV
8aa95b17 1174 { $$ = yylval.s; }
8b9d5b5e 1175 | TRACE
8aa95b17 1176 { $$ = yylval.s; }
73d15916 1177 | CLOCK
8aa95b17 1178 { $$ = yylval.s; }
f133896d 1179 | CALLSITE
8aa95b17 1180 { $$ = yylval.s; }
b7e35bad 1181 | TOK_ALIGN
8aa95b17 1182 { $$ = yylval.s; }
8b9d5b5e
MD		 1183 ;
1184
8b9d5b5e
MD		 1185
1186/* 2: Phrase structure grammar */
1187
1188postfix_expression:
1189 IDENTIFIER
6dc474b8
MD		 1190 {
1191 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1192 $$->u.unary_expression.type = UNARY_STRING;
8aa95b17 1193 $$->u.unary_expression.u.string = yylval.s;
6dc474b8 1194 }
8b9d5b5e 1195 | ID_TYPE
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 | keywords
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 }
80b07bd7 1207 | INTEGER_LITERAL
6dc474b8
MD		 1208 {
1209 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1210 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
80b07bd7 1211 $$->u.unary_expression.u.unsigned_constant = $1;
6dc474b8 1212 }
d876a5ba 1213 | STRING_LITERAL
6dc474b8
MD		 1214 {
1215 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1216 $$->u.unary_expression.type = UNARY_STRING;
8aa95b17 1217 $$->u.unary_expression.u.string = $1;
6dc474b8 1218 }
d876a5ba 1219 | CHARACTER_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 }
8b9d5b5e 1225 | LPAREN unary_expression RPAREN
6dc474b8 1226 {
104147cd 1227 $$ = $2;
6dc474b8 1228 }
8b9d5b5e 1229 | postfix_expression LSBRAC unary_expression RSBRAC
6dc474b8
MD		 1230 {
1231 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1232 $$->u.unary_expression.type = UNARY_SBRAC;
1233 $$->u.unary_expression.u.sbrac_exp = $3;
3122e6f0
JD		 1234 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1235 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8 1236 }
8b9d5b5e 1237 | postfix_expression DOT IDENTIFIER
6dc474b8
MD		 1238 {
1239 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1240 $$->u.unary_expression.type = UNARY_STRING;
8aa95b17 1241 $$->u.unary_expression.u.string = yylval.s;
6dc474b8 1242 $$->u.unary_expression.link = UNARY_DOTLINK;
3122e6f0
JD		 1243 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1244 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8 1245 }
8b9d5b5e 1246 | postfix_expression DOT ID_TYPE
6dc474b8
MD		 1247 {
1248 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1249 $$->u.unary_expression.type = UNARY_STRING;
8aa95b17 1250 $$->u.unary_expression.u.string = yylval.s;
6dc474b8 1251 $$->u.unary_expression.link = UNARY_DOTLINK;
3122e6f0
JD		 1252 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1253 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8 1254 }
8b9d5b5e 1255 | postfix_expression RARROW IDENTIFIER
6dc474b8
MD		 1256 {
1257 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1258 $$->u.unary_expression.type = UNARY_STRING;
8aa95b17 1259 $$->u.unary_expression.u.string = yylval.s;
6dc474b8 1260 $$->u.unary_expression.link = UNARY_ARROWLINK;
3122e6f0
JD		 1261 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1262 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8 1263 }
8b9d5b5e 1264 | postfix_expression RARROW ID_TYPE
6dc474b8
MD		 1265 {
1266 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1267 $$->u.unary_expression.type = UNARY_STRING;
8aa95b17 1268 $$->u.unary_expression.u.string = yylval.s;
6dc474b8 1269 $$->u.unary_expression.link = UNARY_ARROWLINK;
3122e6f0
JD		 1270 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1271 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8 1272 }
8b9d5b5e
MD		 1273 ;
1274
1275unary_expression:
1276 postfix_expression
6dc474b8 1277 { $$ = $1; }
8b9d5b5e 1278 | PLUS postfix_expression
f9c67088
EB		 1279 {
1280 $$ = $2;
1281 if ($$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
1282 && $$->u.unary_expression.type != UNARY_SIGNED_CONSTANT) {
1283 reparent_error(scanner, "expecting numeric constant");
1284 }
1285 }
8b9d5b5e 1286 | MINUS postfix_expression
6dc474b8
MD		 1287 {
1288 $$ = $2;
6dc474b8
MD		 1289 if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1290 $$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
1291 $$->u.unary_expression.u.signed_constant =
1292 -($$->u.unary_expression.u.unsigned_constant);
ca3de390 1293 } else if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
6dc474b8
MD		 1294 $$->u.unary_expression.u.signed_constant =
1295 -($$->u.unary_expression.u.signed_constant);
ca3de390
EB		 1296 } else {
1297 reparent_error(scanner, "expecting numeric constant");
6dc474b8
MD		 1298 }
1299 }
8b9d5b5e
MD		 1300 ;
1301
1302unary_expression_or_range:
1303 unary_expression DOTDOTDOT unary_expression
6dc474b8
MD		 1304 {
1305 $$ = $1;
3122e6f0 1306 _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
48a01768 1307 $3->u.unary_expression.link = UNARY_DOTDOTDOT;
6dc474b8 1308 }
8b9d5b5e 1309 | unary_expression
6dc474b8 1310 { $$ = $1; }
8b9d5b5e
MD		 1311 ;
1312
1313/* 2.2: Declarations */
1314
1315declaration:
1316 declaration_specifiers SEMICOLON
6dc474b8 1317 { $$ = $1; }
8b9d5b5e 1318 | event_declaration
6dc474b8 1319 { $$ = $1; }
8b9d5b5e 1320 | stream_declaration
6dc474b8 1321 { $$ = $1; }
e2c76a4d
MD		 1322 | env_declaration
1323 { $$ = $1; }
8b9d5b5e 1324 | trace_declaration
6dc474b8 1325 { $$ = $1; }
73d15916
MD		 1326 | clock_declaration
1327 { $$ = $1; }
f133896d
MD		 1328 | callsite_declaration
1329 { $$ = $1; }
8b9d5b5e 1330 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
6dc474b8 1331 {
3e11b713
MD		 1332 struct ctf_node *list;
1333
6dc474b8 1334 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 1335 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1336 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 1337 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1338 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1339 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 1340 }
8b9d5b5e 1341 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
6dc474b8 1342 {
3e11b713
MD		 1343 struct ctf_node *list;
1344
6dc474b8 1345 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 1346 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1347 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 1348 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1349 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 1350 }
8b9d5b5e 1351 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
6dc474b8 1352 {
3e11b713
MD		 1353 struct ctf_node *list;
1354
6dc474b8 1355 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 1356 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1357 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 1358 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1359 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 1360 }
a030d084 1361 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
6dc474b8 1362 {
3e11b713
MD		 1363 struct ctf_node *list;
1364
6dc474b8
MD		 1365 $$ = make_node(scanner, NODE_TYPEALIAS);
1366 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1367 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
3e11b713
MD		 1368
1369 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1370 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
3122e6f0
JD		 1371 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1372 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
3e11b713
MD		 1373
1374 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1375 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
3122e6f0
JD		 1376 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1377 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
6dc474b8 1378 }
8b9d5b5e
MD		 1379 ;
1380
1381event_declaration:
1382 event_declaration_begin event_declaration_end
48a01768
MD		 1383 {
1384 $$ = make_node(scanner, NODE_EVENT);
48a01768 1385 }
8b9d5b5e 1386 | event_declaration_begin ctf_assignment_expression_list event_declaration_end
02b234c4
MD		 1387 {
1388 $$ = make_node(scanner, NODE_EVENT);
48a01768 1389 if (set_parent_node($2, $$))
6dc474b8 1390 reparent_error(scanner, "event_declaration");
02b234c4 1391 }
8b9d5b5e
MD		 1392 ;
1393
1394event_declaration_begin:
1395 EVENT LBRAC
fce8006d 1396 { push_scope(scanner); }
8b9d5b5e
MD		 1397 ;
1398
1399event_declaration_end:
1400 RBRAC SEMICOLON
fce8006d 1401 { pop_scope(scanner); }
8b9d5b5e
MD		 1402 ;
1403
1404
1405stream_declaration:
1406 stream_declaration_begin stream_declaration_end
48a01768
MD		 1407 {
1408 $$ = make_node(scanner, NODE_STREAM);
48a01768 1409 }
8b9d5b5e 1410 | stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
6dc474b8
MD		 1411 {
1412 $$ = make_node(scanner, NODE_STREAM);
48a01768 1413 if (set_parent_node($2, $$))
6dc474b8
MD		 1414 reparent_error(scanner, "stream_declaration");
1415 }
8b9d5b5e
MD		 1416 ;
1417
1418stream_declaration_begin:
1419 STREAM LBRAC
fce8006d 1420 { push_scope(scanner); }
8b9d5b5e
MD		 1421 ;
1422
1423stream_declaration_end:
1424 RBRAC SEMICOLON
fce8006d 1425 { pop_scope(scanner); }
8b9d5b5e
MD		 1426 ;
1427
e2c76a4d
MD		 1428env_declaration:
1429 env_declaration_begin env_declaration_end
1430 {
1431 $$ = make_node(scanner, NODE_ENV);
1432 }
1433 | env_declaration_begin ctf_assignment_expression_list env_declaration_end
1434 {
1435 $$ = make_node(scanner, NODE_ENV);
1436 if (set_parent_node($2, $$))
1437 reparent_error(scanner, "env declaration");
1438 }
1439 ;
1440
1441env_declaration_begin:
1442 ENV LBRAC
1443 { push_scope(scanner); }
1444 ;
1445
1446env_declaration_end:
1447 RBRAC SEMICOLON
1448 { pop_scope(scanner); }
1449 ;
1450
8b9d5b5e
MD		 1451trace_declaration:
1452 trace_declaration_begin trace_declaration_end
48a01768
MD		 1453 {
1454 $$ = make_node(scanner, NODE_TRACE);
48a01768 1455 }
8b9d5b5e 1456 | trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
6dc474b8
MD		 1457 {
1458 $$ = make_node(scanner, NODE_TRACE);
48a01768 1459 if (set_parent_node($2, $$))
6dc474b8
MD		 1460 reparent_error(scanner, "trace_declaration");
1461 }
8b9d5b5e
MD		 1462 ;
1463
1464trace_declaration_begin:
1465 TRACE LBRAC
fce8006d 1466 { push_scope(scanner); }
8b9d5b5e
MD		 1467 ;
1468
1469trace_declaration_end:
1470 RBRAC SEMICOLON
fce8006d 1471 { pop_scope(scanner); }
8b9d5b5e
MD		 1472 ;
1473
73d15916
MD		 1474clock_declaration:
1475 CLOCK clock_declaration_begin clock_declaration_end
1476 {
1477 $$ = make_node(scanner, NODE_CLOCK);
1478 }
1479 | CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
1480 {
1481 $$ = make_node(scanner, NODE_CLOCK);
1482 if (set_parent_node($3, $$))
1483 reparent_error(scanner, "trace_declaration");
1484 }
1485 ;
1486
1487clock_declaration_begin:
1488 LBRAC
1489 { push_scope(scanner); }
1490 ;
1491
1492clock_declaration_end:
1493 RBRAC SEMICOLON
1494 { pop_scope(scanner); }
1495 ;
1496
f133896d
MD		 1497callsite_declaration:
1498 CALLSITE callsite_declaration_begin callsite_declaration_end
1499 {
1500 $$ = make_node(scanner, NODE_CALLSITE);
1501 }
1502 | CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
1503 {
1504 $$ = make_node(scanner, NODE_CALLSITE);
1505 if (set_parent_node($3, $$))
1506 reparent_error(scanner, "trace_declaration");
1507 }
1508 ;
1509
1510callsite_declaration_begin:
1511 LBRAC
1512 { push_scope(scanner); }
1513 ;
1514
1515callsite_declaration_end:
1516 RBRAC SEMICOLON
1517 { pop_scope(scanner); }
1518 ;
1519
0fbb34a5
MD		 1520integer_declaration_specifiers:
1521 CONST
1522 {
1523 struct ctf_node *node;
1524
1525 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1526 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1527 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 1528 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
0fbb34a5
MD		 1529 }
1530 | integer_type_specifier
1531 {
1532 struct ctf_node *node;
1533
1534 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1535 node = $1;
3122e6f0 1536 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
0fbb34a5
MD		 1537 }
1538 | integer_declaration_specifiers CONST
1539 {
1540 struct ctf_node *node;
1541
1542 $$ = $1;
1543 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1544 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 1545 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
0fbb34a5
MD		 1546 }
1547 | integer_declaration_specifiers integer_type_specifier
1548 {
1549 $$ = $1;
3122e6f0 1550 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
0fbb34a5
MD		 1551 }
1552 ;
1553
8b9d5b5e
MD		 1554declaration_specifiers:
1555 CONST
6dc474b8 1556 {
3e11b713
MD		 1557 struct ctf_node *node;
1558
1559 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1560 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1561 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 1562 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 1563 }
8b9d5b5e 1564 | type_specifier
3e11b713
MD		 1565 {
1566 struct ctf_node *node;
1567
1568 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1569 node = $1;
3122e6f0 1570 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
3e11b713 1571 }
8b9d5b5e 1572 | declaration_specifiers CONST
6dc474b8
MD		 1573 {
1574 struct ctf_node *node;
1575
48a01768 1576 $$ = $1;
6dc474b8
MD		 1577 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1578 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 1579 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 1580 }
8b9d5b5e 1581 | declaration_specifiers type_specifier
6dc474b8
MD		 1582 {
1583 $$ = $1;
3122e6f0 1584 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 1585 }
8b9d5b5e
MD		 1586 ;
1587
1588type_declarator_list:
1589 type_declarator
0009a725 1590 { $$ = $1; }
8b9d5b5e 1591 | type_declarator_list COMMA type_declarator
6dc474b8
MD		 1592 {
1593 $$ = $1;
3122e6f0 1594 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
6dc474b8 1595 }
8b9d5b5e
MD		 1596 ;
1597
0fbb34a5
MD		 1598integer_type_specifier:
1599 CHAR
1600 {
1601 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1602 $$->u.type_specifier.type = TYPESPEC_CHAR;
1603 }
1604 | SHORT
1605 {
1606 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1607 $$->u.type_specifier.type = TYPESPEC_SHORT;
1608 }
1609 | INT
1610 {
1611 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1612 $$->u.type_specifier.type = TYPESPEC_INT;
1613 }
1614 | LONG
1615 {
1616 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1617 $$->u.type_specifier.type = TYPESPEC_LONG;
1618 }
1619 | SIGNED
1620 {
1621 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1622 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1623 }
1624 | UNSIGNED
1625 {
1626 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1627 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1628 }
1629 | _BOOL
1630 {
1631 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1632 $$->u.type_specifier.type = TYPESPEC_BOOL;
1633 }
1634 | ID_TYPE
1635 {
1636 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1637 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
8aa95b17 1638 $$->u.type_specifier.id_type = yylval.s;
0fbb34a5
MD		 1639 }
1640 | INTEGER LBRAC RBRAC
1641 {
1642 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1643 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1644 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1645 }
1646 | INTEGER LBRAC ctf_assignment_expression_list 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 if (set_parent_node($3, $$->u.type_specifier.node))
1652 reparent_error(scanner, "integer reparent error");
1653 }
1654 ;
1655
8b9d5b5e
MD		 1656type_specifier:
1657 VOID
6dc474b8
MD		 1658 {
1659 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1660 $$->u.type_specifier.type = TYPESPEC_VOID;
1661 }
8b9d5b5e 1662 | CHAR
6dc474b8
MD		 1663 {
1664 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1665 $$->u.type_specifier.type = TYPESPEC_CHAR;
1666 }
8b9d5b5e 1667 | SHORT
6dc474b8
MD		 1668 {
1669 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1670 $$->u.type_specifier.type = TYPESPEC_SHORT;
1671 }
8b9d5b5e 1672 | INT
6dc474b8
MD		 1673 {
1674 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1675 $$->u.type_specifier.type = TYPESPEC_INT;
1676 }
8b9d5b5e 1677 | LONG
6dc474b8
MD		 1678 {
1679 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1680 $$->u.type_specifier.type = TYPESPEC_LONG;
1681 }
8b9d5b5e 1682 | FLOAT
6dc474b8
MD		 1683 {
1684 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1685 $$->u.type_specifier.type = TYPESPEC_FLOAT;
1686 }
8b9d5b5e 1687 | DOUBLE
6dc474b8
MD		 1688 {
1689 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1690 $$->u.type_specifier.type = TYPESPEC_DOUBLE;
1691 }
8b9d5b5e 1692 | SIGNED
6dc474b8
MD		 1693 {
1694 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1695 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1696 }
8b9d5b5e 1697 | UNSIGNED
6dc474b8
MD		 1698 {
1699 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1700 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1701 }
8b9d5b5e 1702 | _BOOL
6dc474b8
MD		 1703 {
1704 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1705 $$->u.type_specifier.type = TYPESPEC_BOOL;
1706 }
8b9d5b5e 1707 | _COMPLEX
6dc474b8
MD		 1708 {
1709 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1710 $$->u.type_specifier.type = TYPESPEC_COMPLEX;
1711 }
3888a159
MD		 1712 | _IMAGINARY
1713 {
1714 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1715 $$->u.type_specifier.type = TYPESPEC_IMAGINARY;
1716 }
8b9d5b5e 1717 | ID_TYPE
6dc474b8
MD		 1718 {
1719 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1720 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
8aa95b17 1721 $$->u.type_specifier.id_type = yylval.s;
6dc474b8 1722 }
8b9d5b5e 1723 | FLOATING_POINT LBRAC RBRAC
6dc474b8 1724 {
3e11b713
MD		 1725 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1726 $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
1727 $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
6dc474b8 1728 }
8b9d5b5e 1729 | FLOATING_POINT LBRAC ctf_assignment_expression_list 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);
1734 if (set_parent_node($3, $$->u.type_specifier.node))
6dc474b8
MD		 1735 reparent_error(scanner, "floating point reparent error");
1736 }
8b9d5b5e 1737 | INTEGER LBRAC RBRAC
6dc474b8 1738 {
3e11b713
MD		 1739 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1740 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1741 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
6dc474b8 1742 }
8b9d5b5e 1743 | INTEGER LBRAC ctf_assignment_expression_list 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);
1748 if (set_parent_node($3, $$->u.type_specifier.node))
6dc474b8
MD		 1749 reparent_error(scanner, "integer reparent error");
1750 }
b40c8090
MD		 1751 | STRING
1752 {
1753 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1754 $$->u.type_specifier.type = TYPESPEC_STRING;
1755 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1756 }
8b9d5b5e 1757 | STRING LBRAC RBRAC
6dc474b8 1758 {
3e11b713
MD		 1759 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1760 $$->u.type_specifier.type = TYPESPEC_STRING;
1761 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
6dc474b8 1762 }
8b9d5b5e 1763 | STRING LBRAC ctf_assignment_expression_list 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);
1768 if (set_parent_node($3, $$->u.type_specifier.node))
6dc474b8
MD		 1769 reparent_error(scanner, "string reparent error");
1770 }
8b9d5b5e 1771 | ENUM enum_type_specifier
3e11b713
MD		 1772 {
1773 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1774 $$->u.type_specifier.type = TYPESPEC_ENUM;
1775 $$->u.type_specifier.node = $2;
1776 }
8b9d5b5e 1777 | VARIANT variant_type_specifier
3e11b713
MD		 1778 {
1779 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1780 $$->u.type_specifier.type = TYPESPEC_VARIANT;
1781 $$->u.type_specifier.node = $2;
3e11b713 1782 }
8b9d5b5e 1783 | STRUCT struct_type_specifier
3e11b713
MD		 1784 {
1785 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1786 $$->u.type_specifier.type = TYPESPEC_STRUCT;
1787 $$->u.type_specifier.node = $2;
3e11b713 1788 }
8b9d5b5e
MD		 1789 ;
1790
1791struct_type_specifier:
1792 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
6dc474b8
MD		 1793 {
1794 $$ = make_node(scanner, NODE_STRUCT);
1ee8e81d 1795 $$->u._struct.has_body = 1;
5039b4cc 1796 if ($2 && set_parent_node($2, $$))
6dc474b8
MD		 1797 reparent_error(scanner, "struct reparent error");
1798 }
8b9d5b5e 1799 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
6dc474b8
MD		 1800 {
1801 $$ = make_node(scanner, NODE_STRUCT);
1ee8e81d 1802 $$->u._struct.has_body = 1;
8aa95b17 1803 $$->u._struct.name = $1;
5039b4cc 1804 if ($3 && set_parent_node($3, $$))
6dc474b8
MD		 1805 reparent_error(scanner, "struct reparent error");
1806 }
8b9d5b5e 1807 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
6dc474b8
MD		 1808 {
1809 $$ = make_node(scanner, NODE_STRUCT);
1ee8e81d 1810 $$->u._struct.has_body = 1;
8aa95b17 1811 $$->u._struct.name = $1;
5039b4cc 1812 if ($3 && set_parent_node($3, $$))
6dc474b8
MD		 1813 reparent_error(scanner, "struct reparent error");
1814 }
8b9d5b5e 1815 | IDENTIFIER
6dc474b8
MD		 1816 {
1817 $$ = make_node(scanner, NODE_STRUCT);
1ee8e81d 1818 $$->u._struct.has_body = 0;
8aa95b17 1819 $$->u._struct.name = $1;
6dc474b8 1820 }
8b9d5b5e 1821 | ID_TYPE
6dc474b8
MD		 1822 {
1823 $$ = make_node(scanner, NODE_STRUCT);
1ee8e81d 1824 $$->u._struct.has_body = 0;
8aa95b17 1825 $$->u._struct.name = $1;
6dc474b8 1826 }
b7e35bad
MD		 1827 | struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1828 {
1829 $$ = make_node(scanner, NODE_STRUCT);
1830 $$->u._struct.has_body = 1;
3122e6f0 1831 bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
b7e35bad
MD		 1832 if ($2 && set_parent_node($2, $$))
1833 reparent_error(scanner, "struct reparent error");
1834 }
1835 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1836 {
1837 $$ = make_node(scanner, NODE_STRUCT);
1838 $$->u._struct.has_body = 1;
8aa95b17 1839 $$->u._struct.name = $1;
3122e6f0 1840 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
b7e35bad
MD		 1841 if ($3 && set_parent_node($3, $$))
1842 reparent_error(scanner, "struct reparent error");
1843 }
1844 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1845 {
1846 $$ = make_node(scanner, NODE_STRUCT);
1847 $$->u._struct.has_body = 1;
8aa95b17 1848 $$->u._struct.name = $1;
3122e6f0 1849 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
b7e35bad
MD		 1850 if ($3 && set_parent_node($3, $$))
1851 reparent_error(scanner, "struct reparent error");
1852 }
8b9d5b5e
MD		 1853 ;
1854
1855struct_declaration_begin:
1856 LBRAC
fce8006d 1857 { push_scope(scanner); }
8b9d5b5e
MD		 1858 ;
1859
1860struct_declaration_end:
1861 RBRAC
fce8006d 1862 { pop_scope(scanner); }
8b9d5b5e
MD		 1863 ;
1864
1865variant_type_specifier:
1866 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1867 {
1868 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1869 $$->u.variant.has_body = 1;
5039b4cc 1870 if ($2 && set_parent_node($2, $$))
6dc474b8
MD		 1871 reparent_error(scanner, "variant reparent error");
1872 }
8b9d5b5e 1873 | LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1874 {
1875 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1876 $$->u.variant.has_body = 1;
8aa95b17 1877 $$->u.variant.choice = $2;
5039b4cc 1878 if ($5 && set_parent_node($5, $$))
6dc474b8
MD		 1879 reparent_error(scanner, "variant reparent error");
1880 }
8b9d5b5e 1881 | LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1882 {
1883 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1884 $$->u.variant.has_body = 1;
8aa95b17 1885 $$->u.variant.choice = $2;
5039b4cc 1886 if ($5 && set_parent_node($5, $$))
6dc474b8
MD		 1887 reparent_error(scanner, "variant reparent error");
1888 }
8b9d5b5e 1889 | IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1890 {
1891 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1892 $$->u.variant.has_body = 1;
8aa95b17 1893 $$->u.variant.name = $1;
5039b4cc 1894 if ($3 && set_parent_node($3, $$))
6dc474b8
MD		 1895 reparent_error(scanner, "variant reparent error");
1896 }
8b9d5b5e 1897 | IDENTIFIER LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1898 {
1899 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1900 $$->u.variant.has_body = 1;
8aa95b17
MD		 1901 $$->u.variant.name = $1;
1902 $$->u.variant.choice = $3;
5039b4cc 1903 if ($6 && set_parent_node($6, $$))
6dc474b8
MD		 1904 reparent_error(scanner, "variant reparent error");
1905 }
8b9d5b5e 1906 | IDENTIFIER LT IDENTIFIER GT
6dc474b8
MD		 1907 {
1908 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1909 $$->u.variant.has_body = 0;
8aa95b17
MD		 1910 $$->u.variant.name = $1;
1911 $$->u.variant.choice = $3;
6dc474b8 1912 }
8b9d5b5e 1913 | IDENTIFIER LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1914 {
1915 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1916 $$->u.variant.has_body = 1;
8aa95b17
MD		 1917 $$->u.variant.name = $1;
1918 $$->u.variant.choice = $3;
5039b4cc 1919 if ($6 && set_parent_node($6, $$))
6dc474b8
MD		 1920 reparent_error(scanner, "variant reparent error");
1921 }
8b9d5b5e 1922 | IDENTIFIER LT ID_TYPE GT
6dc474b8
MD		 1923 {
1924 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1925 $$->u.variant.has_body = 0;
8aa95b17
MD		 1926 $$->u.variant.name = $1;
1927 $$->u.variant.choice = $3;
6dc474b8 1928 }
8b9d5b5e 1929 | ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1930 {
1931 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1932 $$->u.variant.has_body = 1;
8aa95b17 1933 $$->u.variant.name = $1;
5039b4cc 1934 if ($3 && set_parent_node($3, $$))
6dc474b8
MD		 1935 reparent_error(scanner, "variant reparent error");
1936 }
8b9d5b5e 1937 | ID_TYPE LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1938 {
1939 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1940 $$->u.variant.has_body = 1;
8aa95b17
MD		 1941 $$->u.variant.name = $1;
1942 $$->u.variant.choice = $3;
5039b4cc 1943 if ($6 && set_parent_node($6, $$))
6dc474b8
MD		 1944 reparent_error(scanner, "variant reparent error");
1945 }
8b9d5b5e 1946 | ID_TYPE LT IDENTIFIER GT
6dc474b8
MD		 1947 {
1948 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1949 $$->u.variant.has_body = 0;
8aa95b17
MD		 1950 $$->u.variant.name = $1;
1951 $$->u.variant.choice = $3;
6dc474b8 1952 }
8b9d5b5e 1953 | ID_TYPE LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1954 {
1955 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1956 $$->u.variant.has_body = 1;
8aa95b17
MD		 1957 $$->u.variant.name = $1;
1958 $$->u.variant.choice = $3;
5039b4cc 1959 if ($6 && set_parent_node($6, $$))
6dc474b8
MD		 1960 reparent_error(scanner, "variant reparent error");
1961 }
8b9d5b5e 1962 | ID_TYPE LT ID_TYPE GT
6dc474b8
MD		 1963 {
1964 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1965 $$->u.variant.has_body = 0;
8aa95b17
MD		 1966 $$->u.variant.name = $1;
1967 $$->u.variant.choice = $3;
6dc474b8 1968 }
8b9d5b5e
MD		 1969 ;
1970
1971variant_declaration_begin:
1972 LBRAC
fce8006d 1973 { push_scope(scanner); }
8b9d5b5e
MD		 1974 ;
1975
1976variant_declaration_end:
1977 RBRAC
fce8006d 1978 { pop_scope(scanner); }
8b9d5b5e
MD		 1979 ;
1980
8b9d5b5e
MD		 1981enum_type_specifier:
1982 LBRAC enumerator_list RBRAC
6dc474b8
MD		 1983 {
1984 $$ = make_node(scanner, NODE_ENUM);
add40b62 1985 $$->u._enum.has_body = 1;
3122e6f0 1986 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 1987 }
0fbb34a5 1988 | COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
6dc474b8
MD		 1989 {
1990 $$ = make_node(scanner, NODE_ENUM);
add40b62 1991 $$->u._enum.has_body = 1;
3e11b713 1992 ($$)->u._enum.container_type = $2;
3122e6f0 1993 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 1994 }
8b9d5b5e 1995 | IDENTIFIER LBRAC enumerator_list RBRAC
6dc474b8
MD		 1996 {
1997 $$ = make_node(scanner, NODE_ENUM);
add40b62 1998 $$->u._enum.has_body = 1;
8aa95b17 1999 $$->u._enum.enum_id = $1;
3122e6f0 2000 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2001 }
0fbb34a5 2002 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
6dc474b8
MD		 2003 {
2004 $$ = make_node(scanner, NODE_ENUM);
add40b62 2005 $$->u._enum.has_body = 1;
8aa95b17 2006 $$->u._enum.enum_id = $1;
3e11b713 2007 ($$)->u._enum.container_type = $3;
3122e6f0 2008 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2009 }
8b9d5b5e 2010 | ID_TYPE LBRAC enumerator_list RBRAC
6dc474b8
MD		 2011 {
2012 $$ = make_node(scanner, NODE_ENUM);
add40b62 2013 $$->u._enum.has_body = 1;
8aa95b17 2014 $$->u._enum.enum_id = $1;
3122e6f0 2015 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2016 }
0fbb34a5 2017 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
6dc474b8
MD		 2018 {
2019 $$ = make_node(scanner, NODE_ENUM);
add40b62 2020 $$->u._enum.has_body = 1;
8aa95b17 2021 $$->u._enum.enum_id = $1;
3e11b713 2022 ($$)->u._enum.container_type = $3;
3122e6f0 2023 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2024 }
8b9d5b5e 2025 | LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 2026 {
2027 $$ = make_node(scanner, NODE_ENUM);
add40b62 2028 $$->u._enum.has_body = 1;
3122e6f0 2029 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2030 }
0fbb34a5 2031 | COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 2032 {
2033 $$ = make_node(scanner, NODE_ENUM);
add40b62 2034 $$->u._enum.has_body = 1;
3e11b713 2035 ($$)->u._enum.container_type = $2;
3122e6f0 2036 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2037 }
8b9d5b5e 2038 | IDENTIFIER LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 2039 {
2040 $$ = make_node(scanner, NODE_ENUM);
add40b62 2041 $$->u._enum.has_body = 1;
8aa95b17 2042 $$->u._enum.enum_id = $1;
3122e6f0 2043 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2044 }
0fbb34a5 2045 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 2046 {
2047 $$ = make_node(scanner, NODE_ENUM);
add40b62 2048 $$->u._enum.has_body = 1;
8aa95b17 2049 $$->u._enum.enum_id = $1;
3e11b713 2050 ($$)->u._enum.container_type = $3;
3122e6f0 2051 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2052 }
8b9d5b5e 2053 | IDENTIFIER
6dc474b8
MD		 2054 {
2055 $$ = make_node(scanner, NODE_ENUM);
add40b62 2056 $$->u._enum.has_body = 0;
8aa95b17 2057 $$->u._enum.enum_id = $1;
6dc474b8 2058 }
8b9d5b5e 2059 | ID_TYPE LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 2060 {
2061 $$ = make_node(scanner, NODE_ENUM);
add40b62 2062 $$->u._enum.has_body = 1;
8aa95b17 2063 $$->u._enum.enum_id = $1;
3122e6f0 2064 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2065 }
0fbb34a5 2066 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 2067 {
2068 $$ = make_node(scanner, NODE_ENUM);
add40b62 2069 $$->u._enum.has_body = 1;
8aa95b17 2070 $$->u._enum.enum_id = $1;
3e11b713 2071 ($$)->u._enum.container_type = $3;
3122e6f0 2072 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2073 }
8b9d5b5e 2074 | ID_TYPE
6dc474b8
MD		 2075 {
2076 $$ = make_node(scanner, NODE_ENUM);
add40b62 2077 $$->u._enum.has_body = 0;
8aa95b17 2078 $$->u._enum.enum_id = $1;
6dc474b8 2079 }
8b9d5b5e
MD		 2080 ;
2081
2082struct_or_variant_declaration_list:
2083 /* empty */
6dc474b8 2084 { $$ = NULL; }
8b9d5b5e 2085 | struct_or_variant_declaration_list struct_or_variant_declaration
6dc474b8
MD		 2086 {
2087 if ($1) {
2088 $$ = $1;
3122e6f0 2089 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
6dc474b8
MD		 2090 } else {
2091 $$ = $2;
3122e6f0 2092 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8
MD		 2093 }
2094 }
8b9d5b5e
MD		 2095 ;
2096
2097struct_or_variant_declaration:
1ee8e81d 2098 declaration_specifiers struct_or_variant_declarator_list SEMICOLON
6dc474b8 2099 {
3e11b713
MD		 2100 struct ctf_node *list;
2101
2102 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
3122e6f0 2103 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
6dc474b8 2104 $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
3e11b713 2105 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
3122e6f0 2106 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
6dc474b8 2107 }
1ee8e81d 2108 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
6dc474b8 2109 {
3e11b713
MD		 2110 struct ctf_node *list;
2111
6dc474b8 2112 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 2113 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2114 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 2115 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2116 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2117 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2118 }
1ee8e81d 2119 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
6dc474b8 2120 {
3e11b713
MD		 2121 struct ctf_node *list;
2122
6dc474b8 2123 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 2124 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2125 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 2126 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2127 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2128 }
1ee8e81d 2129 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
6dc474b8 2130 {
3e11b713
MD		 2131 struct ctf_node *list;
2132
2133 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
3122e6f0 2134 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
6dc474b8 2135 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713 2136 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
3122e6f0 2137 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2138 }
a030d084 2139 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
6dc474b8 2140 {
3e11b713
MD		 2141 struct ctf_node *list;
2142
6dc474b8
MD		 2143 $$ = make_node(scanner, NODE_TYPEALIAS);
2144 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2145 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
3e11b713
MD		 2146
2147 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2148 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
3122e6f0
JD		 2149 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2150 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
3e11b713
MD		 2151
2152 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2153 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
3122e6f0
JD		 2154 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2155 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
6dc474b8 2156 }
8b9d5b5e
MD		 2157 ;
2158
1ee8e81d 2159alias_declaration_specifiers:
8b9d5b5e 2160 CONST
6dc474b8 2161 {
3e11b713
MD		 2162 struct ctf_node *node;
2163
2164 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2165 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2166 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 2167 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 2168 }
8b9d5b5e 2169 | type_specifier
3e11b713
MD		 2170 {
2171 struct ctf_node *node;
2172
2173 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2174 node = $1;
3122e6f0 2175 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
3e11b713 2176 }
1ee8e81d
MD		 2177 | IDENTIFIER
2178 {
3e11b713
MD		 2179 struct ctf_node *node;
2180
1ee8e81d 2181 add_type(scanner, $1);
3e11b713
MD		 2182 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2183 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2184 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
8aa95b17 2185 node->u.type_specifier.id_type = yylval.s;
3122e6f0 2186 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1ee8e81d
MD		 2187 }
2188 | alias_declaration_specifiers CONST
6dc474b8
MD		 2189 {
2190 struct ctf_node *node;
2191
2192 $$ = $1;
2193 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2194 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 2195 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 2196 }
1ee8e81d 2197 | alias_declaration_specifiers type_specifier
6dc474b8
MD		 2198 {
2199 $$ = $1;
3122e6f0 2200 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 2201 }
1ee8e81d
MD		 2202 | alias_declaration_specifiers IDENTIFIER
2203 {
2204 struct ctf_node *node;
2205
2206 add_type(scanner, $2);
2207 $$ = $1;
2208 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2209 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
8aa95b17 2210 node->u.type_specifier.id_type = yylval.s;
3122e6f0 2211 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1ee8e81d 2212 }
8b9d5b5e
MD		 2213 ;
2214
2215struct_or_variant_declarator_list:
2216 struct_or_variant_declarator
0009a725 2217 { $$ = $1; }
8b9d5b5e 2218 | struct_or_variant_declarator_list COMMA struct_or_variant_declarator
6dc474b8
MD		 2219 {
2220 $$ = $1;
3122e6f0 2221 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
6dc474b8 2222 }
8b9d5b5e
MD		 2223 ;
2224
2225struct_or_variant_declarator:
2226 declarator
6dc474b8 2227 { $$ = $1; }
8b9d5b5e 2228 | COLON unary_expression
6dc474b8 2229 { $$ = $2; }
8b9d5b5e 2230 | declarator COLON unary_expression
6dc474b8
MD		 2231 {
2232 $$ = $1;
48a01768 2233 if (set_parent_node($3, $1))
6dc474b8
MD		 2234 reparent_error(scanner, "struct_or_variant_declarator");
2235 }
8b9d5b5e
MD		 2236 ;
2237
2238enumerator_list:
2239 enumerator
0009a725 2240 { $$ = $1; }
8b9d5b5e 2241 | enumerator_list COMMA enumerator
6dc474b8
MD		 2242 {
2243 $$ = $1;
3122e6f0 2244 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
6dc474b8 2245 }
8b9d5b5e
MD		 2246 ;
2247
2248enumerator:
2249 IDENTIFIER
6dc474b8
MD		 2250 {
2251 $$ = make_node(scanner, NODE_ENUMERATOR);
8aa95b17 2252 $$->u.enumerator.id = $1;
6dc474b8 2253 }
8b9d5b5e 2254 | ID_TYPE
6dc474b8
MD		 2255 {
2256 $$ = make_node(scanner, NODE_ENUMERATOR);
8aa95b17 2257 $$->u.enumerator.id = $1;
6dc474b8 2258 }
8b9d5b5e 2259 | keywords
6dc474b8
MD		 2260 {
2261 $$ = make_node(scanner, NODE_ENUMERATOR);
8aa95b17 2262 $$->u.enumerator.id = $1;
6dc474b8 2263 }
d876a5ba 2264 | STRING_LITERAL
6dc474b8
MD		 2265 {
2266 $$ = make_node(scanner, NODE_ENUMERATOR);
8aa95b17 2267 $$->u.enumerator.id = $1;
6dc474b8 2268 }
8b9d5b5e 2269 | IDENTIFIER EQUAL unary_expression_or_range
6dc474b8
MD		 2270 {
2271 $$ = make_node(scanner, NODE_ENUMERATOR);
8aa95b17 2272 $$->u.enumerator.id = $1;
3122e6f0 2273 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
6dc474b8 2274 }
8b9d5b5e 2275 | ID_TYPE 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 | keywords 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 }
d876a5ba 2287 | STRING_LITERAL EQUAL unary_expression_or_range
6dc474b8
MD		 2288 {
2289 $$ = make_node(scanner, NODE_ENUMERATOR);
8aa95b17 2290 $$->u.enumerator.id = $1;
d876a5ba 2291 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
6dc474b8 2292 }
8b9d5b5e
MD		 2293 ;
2294
2295abstract_declarator_list:
2296 abstract_declarator
0009a725 2297 { $$ = $1; }
8b9d5b5e 2298 | abstract_declarator_list COMMA abstract_declarator
6dc474b8
MD		 2299 {
2300 $$ = $1;
3122e6f0 2301 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
6dc474b8 2302 }
8b9d5b5e
MD		 2303 ;
2304
2305abstract_declarator:
2306 direct_abstract_declarator
6dc474b8 2307 { $$ = $1; }
8b9d5b5e 2308 | pointer direct_abstract_declarator
6dc474b8
MD		 2309 {
2310 $$ = $2;
3122e6f0 2311 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
6dc474b8 2312 }
8b9d5b5e
MD		 2313 ;
2314
2315direct_abstract_declarator:
2316 /* empty */
6dc474b8
MD		 2317 {
2318 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2319 $$->u.type_declarator.type = TYPEDEC_ID;
2320 /* id is NULL */
2321 }
8b9d5b5e 2322 | IDENTIFIER
6dc474b8
MD		 2323 {
2324 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2325 $$->u.type_declarator.type = TYPEDEC_ID;
8aa95b17 2326 $$->u.type_declarator.u.id = $1;
6dc474b8 2327 }
8b9d5b5e 2328 | LPAREN abstract_declarator RPAREN
6dc474b8
MD		 2329 {
2330 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2331 $$->u.type_declarator.type = TYPEDEC_NESTED;
2332 $$->u.type_declarator.u.nested.type_declarator = $2;
2333 }
98df1c9f 2334 | direct_abstract_declarator LSBRAC unary_expression RSBRAC
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 = $1;
3122e6f0
JD		 2339 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2340 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
6dc474b8 2341 }
8b9d5b5e 2342 | direct_abstract_declarator LSBRAC RSBRAC
6dc474b8
MD		 2343 {
2344 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2345 $$->u.type_declarator.type = TYPEDEC_NESTED;
2346 $$->u.type_declarator.u.nested.type_declarator = $1;
2347 $$->u.type_declarator.u.nested.abstract_array = 1;
2348 }
8b9d5b5e
MD		 2349 ;
2350
e0c14875
MD		 2351alias_abstract_declarator_list:
2352 alias_abstract_declarator
6dc474b8 2353 { $$ = $1; }
e0c14875
MD		 2354 | alias_abstract_declarator_list COMMA alias_abstract_declarator
2355 {
2356 $$ = $1;
3122e6f0 2357 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
e0c14875
MD		 2358 }
2359 ;
2360
2361alias_abstract_declarator:
2362 direct_alias_abstract_declarator
2363 { $$ = $1; }
2364 | pointer direct_alias_abstract_declarator
6dc474b8
MD		 2365 {
2366 $$ = $2;
3122e6f0 2367 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
6dc474b8 2368 }
8b9d5b5e
MD		 2369 ;
2370
e0c14875
MD		 2371direct_alias_abstract_declarator:
2372 /* empty */
6dc474b8
MD		 2373 {
2374 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
e0c14875
MD		 2375 $$->u.type_declarator.type = TYPEDEC_ID;
2376 /* id is NULL */
6dc474b8 2377 }
e0c14875 2378 | LPAREN alias_abstract_declarator RPAREN
6dc474b8
MD		 2379 {
2380 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2381 $$->u.type_declarator.type = TYPEDEC_NESTED;
2382 $$->u.type_declarator.u.nested.type_declarator = $2;
2383 }
98df1c9f 2384 | direct_alias_abstract_declarator LSBRAC unary_expression RSBRAC
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 = $1;
3122e6f0
JD		 2389 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2390 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
6dc474b8 2391 }
e0c14875
MD		 2392 | direct_alias_abstract_declarator LSBRAC RSBRAC
2393 {
2394 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2395 $$->u.type_declarator.type = TYPEDEC_NESTED;
2396 $$->u.type_declarator.u.nested.type_declarator = $1;
2397 $$->u.type_declarator.u.nested.abstract_array = 1;
2398 }
8b9d5b5e
MD		 2399 ;
2400
e0c14875
MD		 2401declarator:
2402 direct_declarator
6dc474b8 2403 { $$ = $1; }
e0c14875 2404 | pointer direct_declarator
6dc474b8
MD		 2405 {
2406 $$ = $2;
3122e6f0 2407 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
6dc474b8 2408 }
8b9d5b5e
MD		 2409 ;
2410
e0c14875 2411direct_declarator:
8b9d5b5e 2412 IDENTIFIER
6dc474b8 2413 {
6dc474b8
MD		 2414 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2415 $$->u.type_declarator.type = TYPEDEC_ID;
8aa95b17 2416 $$->u.type_declarator.u.id = $1;
6dc474b8 2417 }
e0c14875 2418 | LPAREN declarator RPAREN
6dc474b8
MD		 2419 {
2420 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2421 $$->u.type_declarator.type = TYPEDEC_NESTED;
2422 $$->u.type_declarator.u.nested.type_declarator = $2;
2423 }
98df1c9f 2424 | direct_declarator LSBRAC unary_expression RSBRAC
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 = $1;
3122e6f0
JD		 2429 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2430 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
6dc474b8 2431 }
8b9d5b5e
MD		 2432 ;
2433
e0c14875
MD		 2434type_declarator:
2435 direct_type_declarator
6dc474b8 2436 { $$ = $1; }
e0c14875 2437 | pointer direct_type_declarator
6dc474b8
MD		 2438 {
2439 $$ = $2;
3122e6f0 2440 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
6dc474b8 2441 }
8b9d5b5e
MD		 2442 ;
2443
e0c14875
MD		 2444direct_type_declarator:
2445 IDENTIFIER
6dc474b8
MD		 2446 {
2447 add_type(scanner, $1);
2448 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2449 $$->u.type_declarator.type = TYPEDEC_ID;
8aa95b17 2450 $$->u.type_declarator.u.id = $1;
6dc474b8 2451 }
e0c14875 2452 | LPAREN type_declarator RPAREN
6dc474b8
MD		 2453 {
2454 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2455 $$->u.type_declarator.type = TYPEDEC_NESTED;
2456 $$->u.type_declarator.u.nested.type_declarator = $2;
2457 }
98df1c9f 2458 | direct_type_declarator LSBRAC unary_expression RSBRAC
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 = $1;
3122e6f0
JD		 2463 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2464 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
6dc474b8 2465 }
8b9d5b5e
MD		 2466 ;
2467
2468pointer:
2469 STAR
48a01768
MD		 2470 {
2471 $$ = make_node(scanner, NODE_POINTER);
48a01768 2472 }
8b9d5b5e 2473 | STAR pointer
6dc474b8
MD		 2474 {
2475 $$ = make_node(scanner, NODE_POINTER);
3122e6f0 2476 bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
6dc474b8 2477 }
8b9d5b5e 2478 | STAR type_qualifier_list pointer
6dc474b8
MD		 2479 {
2480 $$ = make_node(scanner, NODE_POINTER);
2481 $$->u.pointer.const_qualifier = 1;
3122e6f0 2482 bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
6dc474b8 2483 }
8b9d5b5e
MD		 2484 ;
2485
2486type_qualifier_list:
6dc474b8 2487 /* pointer assumes only const type qualifier */
8b9d5b5e
MD		 2488 CONST
2489 | type_qualifier_list CONST
2490 ;
2491
2492/* 2.3: CTF-specific declarations */
2493
2494ctf_assignment_expression_list:
2495 ctf_assignment_expression SEMICOLON
0009a725 2496 { $$ = $1; }
8b9d5b5e 2497 | ctf_assignment_expression_list ctf_assignment_expression SEMICOLON
6dc474b8
MD		 2498 {
2499 $$ = $1;
3122e6f0 2500 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
6dc474b8 2501 }
8b9d5b5e
MD		 2502 ;
2503
2504ctf_assignment_expression:
2505 unary_expression EQUAL unary_expression
02b234c4 2506 {
6dc474b8
MD		 2507 /*
2508 * Because we have left and right, cannot use
48a01768 2509 * set_parent_node.
6dc474b8 2510 */
02b234c4 2511 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
3122e6f0 2512 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
6dc474b8
MD		 2513 if ($1->u.unary_expression.type != UNARY_STRING)
2514 reparent_error(scanner, "ctf_assignment_expression left expects string");
3122e6f0 2515 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
02b234c4 2516 }
427c09b7 2517 | unary_expression TYPEASSIGN declaration_specifiers /* Only allow struct */
6dc474b8
MD		 2518 {
2519 /*
2520 * Because we have left and right, cannot use
48a01768 2521 * set_parent_node.
6dc474b8
MD		 2522 */
2523 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
3122e6f0 2524 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
6dc474b8
MD		 2525 if ($1->u.unary_expression.type != UNARY_STRING)
2526 reparent_error(scanner, "ctf_assignment_expression left expects string");
3122e6f0 2527 bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
6dc474b8 2528 }
8b9d5b5e 2529 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list
6dc474b8 2530 {
3e11b713
MD		 2531 struct ctf_node *list;
2532
2533 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
3122e6f0
JD		 2534 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2535 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
6dc474b8 2536 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713 2537 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
3122e6f0 2538 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2539 }
8b9d5b5e 2540 | TYPEDEF declaration_specifiers type_declarator_list
6dc474b8 2541 {
3e11b713
MD		 2542 struct ctf_node *list;
2543
6dc474b8 2544 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 2545 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2546 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 2547 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2548 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2549 }
8b9d5b5e 2550 | declaration_specifiers TYPEDEF type_declarator_list
6dc474b8 2551 {
3e11b713
MD		 2552 struct ctf_node *list;
2553
2554 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
3122e6f0 2555 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
6dc474b8 2556 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713 2557 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
3122e6f0 2558 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2559 }
a030d084 2560 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
6dc474b8 2561 {
3e11b713
MD		 2562 struct ctf_node *list;
2563
6dc474b8
MD		 2564 $$ = make_node(scanner, NODE_TYPEALIAS);
2565 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2566 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
3e11b713
MD		 2567
2568 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2569 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
3122e6f0
JD		 2570 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2571 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
3e11b713
MD		 2572
2573 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2574 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
3122e6f0
JD		 2575 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2576 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
6dc474b8 2577 }
8b9d5b5e 2578 ;
BabelTrace - Trace Format Babel Tower
This page took 0.167237 seconds and 4 git commands to generate.