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