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