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