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