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