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