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