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