projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Adding a test which do a sequence of seek BEGIN, LAST, BEGIN, LAST
[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);
15d4fe3c 863 free(ast);
34d3acc4
MD		 864}
865
866int ctf_scanner_append_ast(struct ctf_scanner *scanner)
867{
868 return yyparse(scanner);
869}
870
871struct ctf_scanner *ctf_scanner_alloc(FILE *input)
872{
873 struct ctf_scanner *scanner;
874 int ret;
875
a3983482
MD		 876 yydebug = babeltrace_debug;
877
34d3acc4
MD		 878 scanner = malloc(sizeof(*scanner));
879 if (!scanner)
880 return NULL;
881 memset(scanner, 0, sizeof(*scanner));
882
883 ret = yylex_init_extra(scanner, &scanner->scanner);
884 if (ret) {
885 fprintf(stderr, "yylex_init error\n");
886 goto cleanup_scanner;
887 }
65102a8c
MD		 888 /* Start processing new stream */
889 yyrestart(input, scanner->scanner);
34d3acc4
MD		 890
891 scanner->ast = ctf_ast_alloc();
892 if (!scanner->ast)
893 goto cleanup_lexer;
894 init_scope(&scanner->root_scope, NULL);
19d96da7 895 scanner->cs = &scanner->root_scope;
3122e6f0 896 BT_INIT_LIST_HEAD(&scanner->allocated_strings);
34d3acc4 897
65102a8c
MD		 898 if (yydebug)
899 fprintf(stdout, "Scanner input is a%s.\n",
900 isatty(fileno(input)) ? "n interactive tty" :
901 " noninteractive file");
902
34d3acc4
MD		 903 return scanner;
904
905cleanup_lexer:
906 ret = yylex_destroy(scanner->scanner);
907 if (!ret)
908 fprintf(stderr, "yylex_destroy error\n");
909cleanup_scanner:
910 free(scanner);
911 return NULL;
912}
913
914void ctf_scanner_free(struct ctf_scanner *scanner)
915{
916 int ret;
917
918 finalize_scope(&scanner->root_scope);
919 free_strings(&scanner->allocated_strings);
920 ctf_ast_free(scanner->ast);
921 ret = yylex_destroy(scanner->scanner);
922 if (ret)
923 fprintf(stderr, "yylex_destroy error\n");
924 free(scanner);
925}
8b9d5b5e
MD		 926
927%}
928
34d3acc4
MD		 929%define api.pure
930 /* %locations */
931%parse-param {struct ctf_scanner *scanner}
932%lex-param {struct ctf_scanner *scanner}
0fbb34a5
MD		 933/*
934 * Expect two shift-reduce conflicts. Caused by enum name-opt : type {}
935 * vs struct { int :value; } (unnamed bit-field). The default is to
936 * shift, so whenever we encounter an enumeration, we are doing the
937 * proper thing (shift). It is illegal to declare an enumeration
938 * "bit-field", so it is OK if this situation ends up in a parsing
939 * error.
940 */
941%expect 2
8b9d5b5e 942%start file
f133896d 943%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		 944%token <gs> IDENTIFIER ID_TYPE
945%token ERROR
946%union
947{
948 long long ll;
949 char c;
950 struct gc_string *gs;
951 struct ctf_node *n;
952}
953
6dc474b8
MD		 954%type <gs> keywords
955%type <gs> s_char s_char_sequence c_char c_char_sequence
956
957%type <n> postfix_expression unary_expression unary_expression_or_range
958
959%type <n> declaration
02b234c4 960%type <n> event_declaration
6dc474b8 961%type <n> stream_declaration
e2c76a4d 962%type <n> env_declaration
6dc474b8 963%type <n> trace_declaration
73d15916 964%type <n> clock_declaration
f133896d 965%type <n> callsite_declaration
0fbb34a5 966%type <n> integer_declaration_specifiers
6dc474b8 967%type <n> declaration_specifiers
1ee8e81d 968%type <n> alias_declaration_specifiers
6dc474b8
MD		 969
970%type <n> type_declarator_list
0fbb34a5 971%type <n> integer_type_specifier
6dc474b8
MD		 972%type <n> type_specifier
973%type <n> struct_type_specifier
974%type <n> variant_type_specifier
6dc474b8
MD		 975%type <n> enum_type_specifier
976%type <n> struct_or_variant_declaration_list
977%type <n> struct_or_variant_declaration
6dc474b8
MD		 978%type <n> struct_or_variant_declarator_list
979%type <n> struct_or_variant_declarator
980%type <n> enumerator_list
981%type <n> enumerator
982%type <n> abstract_declarator_list
983%type <n> abstract_declarator
984%type <n> direct_abstract_declarator
e0c14875
MD		 985%type <n> alias_abstract_declarator_list
986%type <n> alias_abstract_declarator
987%type <n> direct_alias_abstract_declarator
6dc474b8
MD		 988%type <n> declarator
989%type <n> direct_declarator
990%type <n> type_declarator
991%type <n> direct_type_declarator
6dc474b8 992%type <n> pointer
02b234c4
MD		 993%type <n> ctf_assignment_expression_list
994%type <n> ctf_assignment_expression
995
8b9d5b5e
MD		 996%%
997
998file:
999 declaration
6dc474b8 1000 {
48a01768 1001 if (set_parent_node($1, &ctf_scanner_get_ast(scanner)->root))
6dc474b8
MD		 1002 reparent_error(scanner, "error reparenting to root");
1003 }
8b9d5b5e 1004 | file declaration
6dc474b8 1005 {
48a01768 1006 if (set_parent_node($2, &ctf_scanner_get_ast(scanner)->root))
6dc474b8
MD		 1007 reparent_error(scanner, "error reparenting to root");
1008 }
8b9d5b5e
MD		 1009 ;
1010
1011keywords:
1012 VOID
6dc474b8 1013 { $$ = yylval.gs; }
8b9d5b5e 1014 | CHAR
6dc474b8 1015 { $$ = yylval.gs; }
8b9d5b5e 1016 | SHORT
6dc474b8 1017 { $$ = yylval.gs; }
8b9d5b5e 1018 | INT
6dc474b8 1019 { $$ = yylval.gs; }
8b9d5b5e 1020 | LONG
6dc474b8 1021 { $$ = yylval.gs; }
8b9d5b5e 1022 | FLOAT
6dc474b8 1023 { $$ = yylval.gs; }
8b9d5b5e 1024 | DOUBLE
6dc474b8 1025 { $$ = yylval.gs; }
8b9d5b5e 1026 | SIGNED
6dc474b8 1027 { $$ = yylval.gs; }
8b9d5b5e 1028 | UNSIGNED
6dc474b8 1029 { $$ = yylval.gs; }
8b9d5b5e 1030 | _BOOL
6dc474b8 1031 { $$ = yylval.gs; }
8b9d5b5e 1032 | _COMPLEX
6dc474b8 1033 { $$ = yylval.gs; }
3888a159
MD		 1034 | _IMAGINARY
1035 { $$ = yylval.gs; }
8b9d5b5e 1036 | FLOATING_POINT
6dc474b8 1037 { $$ = yylval.gs; }
8b9d5b5e 1038 | INTEGER
6dc474b8 1039 { $$ = yylval.gs; }
8b9d5b5e 1040 | STRING
6dc474b8 1041 { $$ = yylval.gs; }
8b9d5b5e 1042 | ENUM
6dc474b8 1043 { $$ = yylval.gs; }
8b9d5b5e 1044 | VARIANT
6dc474b8 1045 { $$ = yylval.gs; }
8b9d5b5e 1046 | STRUCT
6dc474b8 1047 { $$ = yylval.gs; }
8b9d5b5e 1048 | CONST
6dc474b8 1049 { $$ = yylval.gs; }
8b9d5b5e 1050 | TYPEDEF
6dc474b8 1051 { $$ = yylval.gs; }
8b9d5b5e 1052 | EVENT
6dc474b8 1053 { $$ = yylval.gs; }
8b9d5b5e 1054 | STREAM
6dc474b8 1055 { $$ = yylval.gs; }
d2ea163b
MD		 1056 | ENV
1057 { $$ = yylval.gs; }
8b9d5b5e 1058 | TRACE
6dc474b8 1059 { $$ = yylval.gs; }
73d15916
MD		 1060 | CLOCK
1061 { $$ = yylval.gs; }
f133896d
MD		 1062 | CALLSITE
1063 { $$ = yylval.gs; }
b7e35bad
MD		 1064 | TOK_ALIGN
1065 { $$ = yylval.gs; }
8b9d5b5e
MD		 1066 ;
1067
1068/* 1.5 Constants */
1069
1070c_char_sequence:
1071 c_char
6dc474b8 1072 { $$ = $1; }
8b9d5b5e 1073 | c_char_sequence c_char
6dc474b8 1074 { $$ = gc_string_append(scanner, $1, $2); }
8b9d5b5e
MD		 1075 ;
1076
1077c_char:
1078 CHAR_STRING_TOKEN
6dc474b8 1079 { $$ = yylval.gs; }
8b9d5b5e 1080 | ESCSEQ
6dc474b8
MD		 1081 {
1082 reparent_error(scanner, "escape sequences not supported yet");
1083 }
8b9d5b5e
MD		 1084 ;
1085
1086/* 1.6 String literals */
1087
1088s_char_sequence:
1089 s_char
6dc474b8 1090 { $$ = $1; }
8b9d5b5e 1091 | s_char_sequence s_char
6dc474b8 1092 { $$ = gc_string_append(scanner, $1, $2); }
8b9d5b5e
MD		 1093 ;
1094
1095s_char:
1096 CHAR_STRING_TOKEN
6dc474b8 1097 { $$ = yylval.gs; }
8b9d5b5e 1098 | ESCSEQ
6dc474b8
MD		 1099 {
1100 reparent_error(scanner, "escape sequences not supported yet");
1101 }
8b9d5b5e
MD		 1102 ;
1103
1104/* 2: Phrase structure grammar */
1105
1106postfix_expression:
1107 IDENTIFIER
6dc474b8
MD		 1108 {
1109 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1110 $$->u.unary_expression.type = UNARY_STRING;
1111 $$->u.unary_expression.u.string = yylval.gs->s;
1112 }
8b9d5b5e 1113 | ID_TYPE
6dc474b8
MD		 1114 {
1115 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1116 $$->u.unary_expression.type = UNARY_STRING;
1117 $$->u.unary_expression.u.string = yylval.gs->s;
1118 }
8b9d5b5e 1119 | keywords
6dc474b8
MD		 1120 {
1121 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1122 $$->u.unary_expression.type = UNARY_STRING;
1123 $$->u.unary_expression.u.string = yylval.gs->s;
1124 }
8b9d5b5e 1125 | DECIMAL_CONSTANT
6dc474b8
MD		 1126 {
1127 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1128 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
380d60b1 1129 sscanf(yylval.gs->s, "%" PRIu64,
6dc474b8
MD		 1130 &$$->u.unary_expression.u.unsigned_constant);
1131 }
8b9d5b5e 1132 | OCTAL_CONSTANT
6dc474b8
MD		 1133 {
1134 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1135 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
380d60b1 1136 sscanf(yylval.gs->s, "0%" PRIo64,
6dc474b8
MD		 1137 &$$->u.unary_expression.u.unsigned_constant);
1138 }
8b9d5b5e 1139 | HEXADECIMAL_CONSTANT
6dc474b8
MD		 1140 {
1141 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1142 $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
380d60b1 1143 sscanf(yylval.gs->s, "0x%" PRIx64,
6dc474b8
MD		 1144 &$$->u.unary_expression.u.unsigned_constant);
1145 }
8b9d5b5e 1146 | STRING_LITERAL_START DQUOTE
6dc474b8
MD		 1147 {
1148 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1149 $$->u.unary_expression.type = UNARY_STRING;
1150 $$->u.unary_expression.u.string = "";
1151 }
8b9d5b5e 1152 | STRING_LITERAL_START s_char_sequence DQUOTE
6dc474b8
MD		 1153 {
1154 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1155 $$->u.unary_expression.type = UNARY_STRING;
1156 $$->u.unary_expression.u.string = $2->s;
1157 }
8b9d5b5e 1158 | CHARACTER_CONSTANT_START c_char_sequence SQUOTE
6dc474b8
MD		 1159 {
1160 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1161 $$->u.unary_expression.type = UNARY_STRING;
1162 $$->u.unary_expression.u.string = $2->s;
1163 }
8b9d5b5e 1164 | LPAREN unary_expression RPAREN
6dc474b8 1165 {
48a01768
MD		 1166 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1167 $$->u.unary_expression.type = UNARY_NESTED;
1168 $$->u.unary_expression.u.nested_exp = $2;
6dc474b8 1169 }
8b9d5b5e 1170 | postfix_expression LSBRAC unary_expression RSBRAC
6dc474b8
MD		 1171 {
1172 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1173 $$->u.unary_expression.type = UNARY_SBRAC;
1174 $$->u.unary_expression.u.sbrac_exp = $3;
3122e6f0
JD		 1175 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1176 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8 1177 }
8b9d5b5e 1178 | postfix_expression DOT IDENTIFIER
6dc474b8
MD		 1179 {
1180 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1181 $$->u.unary_expression.type = UNARY_STRING;
1182 $$->u.unary_expression.u.string = yylval.gs->s;
1183 $$->u.unary_expression.link = UNARY_DOTLINK;
3122e6f0
JD		 1184 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1185 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8 1186 }
8b9d5b5e 1187 | postfix_expression DOT ID_TYPE
6dc474b8
MD		 1188 {
1189 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1190 $$->u.unary_expression.type = UNARY_STRING;
1191 $$->u.unary_expression.u.string = yylval.gs->s;
1192 $$->u.unary_expression.link = UNARY_DOTLINK;
3122e6f0
JD		 1193 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1194 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8 1195 }
8b9d5b5e 1196 | postfix_expression RARROW IDENTIFIER
6dc474b8
MD		 1197 {
1198 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1199 $$->u.unary_expression.type = UNARY_STRING;
1200 $$->u.unary_expression.u.string = yylval.gs->s;
1201 $$->u.unary_expression.link = UNARY_ARROWLINK;
3122e6f0
JD		 1202 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1203 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8 1204 }
8b9d5b5e 1205 | postfix_expression RARROW ID_TYPE
6dc474b8
MD		 1206 {
1207 $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1208 $$->u.unary_expression.type = UNARY_STRING;
1209 $$->u.unary_expression.u.string = yylval.gs->s;
1210 $$->u.unary_expression.link = UNARY_ARROWLINK;
3122e6f0
JD		 1211 bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1212 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8 1213 }
8b9d5b5e
MD		 1214 ;
1215
1216unary_expression:
1217 postfix_expression
6dc474b8 1218 { $$ = $1; }
8b9d5b5e 1219 | PLUS postfix_expression
6dc474b8 1220 { $$ = $2; }
8b9d5b5e 1221 | MINUS postfix_expression
6dc474b8
MD		 1222 {
1223 $$ = $2;
1224 if ($$->u.unary_expression.type != UNARY_SIGNED_CONSTANT
1225 && $$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT)
1226 reparent_error(scanner, "expecting numeric constant");
1227
1228 if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1229 $$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
1230 $$->u.unary_expression.u.signed_constant =
1231 -($$->u.unary_expression.u.unsigned_constant);
1232 } else {
1233 $$->u.unary_expression.u.signed_constant =
1234 -($$->u.unary_expression.u.signed_constant);
1235 }
1236 }
8b9d5b5e
MD		 1237 ;
1238
1239unary_expression_or_range:
1240 unary_expression DOTDOTDOT unary_expression
6dc474b8
MD		 1241 {
1242 $$ = $1;
3122e6f0 1243 _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
48a01768 1244 $3->u.unary_expression.link = UNARY_DOTDOTDOT;
6dc474b8 1245 }
8b9d5b5e 1246 | unary_expression
6dc474b8 1247 { $$ = $1; }
8b9d5b5e
MD		 1248 ;
1249
1250/* 2.2: Declarations */
1251
1252declaration:
1253 declaration_specifiers SEMICOLON
6dc474b8 1254 { $$ = $1; }
8b9d5b5e 1255 | event_declaration
6dc474b8 1256 { $$ = $1; }
8b9d5b5e 1257 | stream_declaration
6dc474b8 1258 { $$ = $1; }
e2c76a4d
MD		 1259 | env_declaration
1260 { $$ = $1; }
8b9d5b5e 1261 | trace_declaration
6dc474b8 1262 { $$ = $1; }
73d15916
MD		 1263 | clock_declaration
1264 { $$ = $1; }
f133896d
MD		 1265 | callsite_declaration
1266 { $$ = $1; }
8b9d5b5e 1267 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
6dc474b8 1268 {
3e11b713
MD		 1269 struct ctf_node *list;
1270
6dc474b8 1271 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 1272 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1273 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 1274 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1275 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1276 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 1277 }
8b9d5b5e 1278 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
6dc474b8 1279 {
3e11b713
MD		 1280 struct ctf_node *list;
1281
6dc474b8 1282 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 1283 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1284 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 1285 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1286 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 1287 }
8b9d5b5e 1288 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
6dc474b8 1289 {
3e11b713
MD		 1290 struct ctf_node *list;
1291
6dc474b8 1292 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 1293 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1294 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 1295 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1296 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 1297 }
a030d084 1298 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
6dc474b8 1299 {
3e11b713
MD		 1300 struct ctf_node *list;
1301
6dc474b8
MD		 1302 $$ = make_node(scanner, NODE_TYPEALIAS);
1303 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1304 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
3e11b713
MD		 1305
1306 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1307 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
3122e6f0
JD		 1308 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1309 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
3e11b713
MD		 1310
1311 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1312 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
3122e6f0
JD		 1313 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
1314 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
6dc474b8 1315 }
8b9d5b5e
MD		 1316 ;
1317
1318event_declaration:
1319 event_declaration_begin event_declaration_end
48a01768
MD		 1320 {
1321 $$ = make_node(scanner, NODE_EVENT);
48a01768 1322 }
8b9d5b5e 1323 | event_declaration_begin ctf_assignment_expression_list event_declaration_end
02b234c4
MD		 1324 {
1325 $$ = make_node(scanner, NODE_EVENT);
48a01768 1326 if (set_parent_node($2, $$))
6dc474b8 1327 reparent_error(scanner, "event_declaration");
02b234c4 1328 }
8b9d5b5e
MD		 1329 ;
1330
1331event_declaration_begin:
1332 EVENT LBRAC
fce8006d 1333 { push_scope(scanner); }
8b9d5b5e
MD		 1334 ;
1335
1336event_declaration_end:
1337 RBRAC SEMICOLON
fce8006d 1338 { pop_scope(scanner); }
8b9d5b5e
MD		 1339 ;
1340
1341
1342stream_declaration:
1343 stream_declaration_begin stream_declaration_end
48a01768
MD		 1344 {
1345 $$ = make_node(scanner, NODE_STREAM);
48a01768 1346 }
8b9d5b5e 1347 | stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
6dc474b8
MD		 1348 {
1349 $$ = make_node(scanner, NODE_STREAM);
48a01768 1350 if (set_parent_node($2, $$))
6dc474b8
MD		 1351 reparent_error(scanner, "stream_declaration");
1352 }
8b9d5b5e
MD		 1353 ;
1354
1355stream_declaration_begin:
1356 STREAM LBRAC
fce8006d 1357 { push_scope(scanner); }
8b9d5b5e
MD		 1358 ;
1359
1360stream_declaration_end:
1361 RBRAC SEMICOLON
fce8006d 1362 { pop_scope(scanner); }
8b9d5b5e
MD		 1363 ;
1364
e2c76a4d
MD		 1365env_declaration:
1366 env_declaration_begin env_declaration_end
1367 {
1368 $$ = make_node(scanner, NODE_ENV);
1369 }
1370 | env_declaration_begin ctf_assignment_expression_list env_declaration_end
1371 {
1372 $$ = make_node(scanner, NODE_ENV);
1373 if (set_parent_node($2, $$))
1374 reparent_error(scanner, "env declaration");
1375 }
1376 ;
1377
1378env_declaration_begin:
1379 ENV LBRAC
1380 { push_scope(scanner); }
1381 ;
1382
1383env_declaration_end:
1384 RBRAC SEMICOLON
1385 { pop_scope(scanner); }
1386 ;
1387
8b9d5b5e
MD		 1388trace_declaration:
1389 trace_declaration_begin trace_declaration_end
48a01768
MD		 1390 {
1391 $$ = make_node(scanner, NODE_TRACE);
48a01768 1392 }
8b9d5b5e 1393 | trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
6dc474b8
MD		 1394 {
1395 $$ = make_node(scanner, NODE_TRACE);
48a01768 1396 if (set_parent_node($2, $$))
6dc474b8
MD		 1397 reparent_error(scanner, "trace_declaration");
1398 }
8b9d5b5e
MD		 1399 ;
1400
1401trace_declaration_begin:
1402 TRACE LBRAC
fce8006d 1403 { push_scope(scanner); }
8b9d5b5e
MD		 1404 ;
1405
1406trace_declaration_end:
1407 RBRAC SEMICOLON
fce8006d 1408 { pop_scope(scanner); }
8b9d5b5e
MD		 1409 ;
1410
73d15916
MD		 1411clock_declaration:
1412 CLOCK clock_declaration_begin clock_declaration_end
1413 {
1414 $$ = make_node(scanner, NODE_CLOCK);
1415 }
1416 | CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
1417 {
1418 $$ = make_node(scanner, NODE_CLOCK);
1419 if (set_parent_node($3, $$))
1420 reparent_error(scanner, "trace_declaration");
1421 }
1422 ;
1423
1424clock_declaration_begin:
1425 LBRAC
1426 { push_scope(scanner); }
1427 ;
1428
1429clock_declaration_end:
1430 RBRAC SEMICOLON
1431 { pop_scope(scanner); }
1432 ;
1433
f133896d
MD		 1434callsite_declaration:
1435 CALLSITE callsite_declaration_begin callsite_declaration_end
1436 {
1437 $$ = make_node(scanner, NODE_CALLSITE);
1438 }
1439 | CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
1440 {
1441 $$ = make_node(scanner, NODE_CALLSITE);
1442 if (set_parent_node($3, $$))
1443 reparent_error(scanner, "trace_declaration");
1444 }
1445 ;
1446
1447callsite_declaration_begin:
1448 LBRAC
1449 { push_scope(scanner); }
1450 ;
1451
1452callsite_declaration_end:
1453 RBRAC SEMICOLON
1454 { pop_scope(scanner); }
1455 ;
1456
0fbb34a5
MD		 1457integer_declaration_specifiers:
1458 CONST
1459 {
1460 struct ctf_node *node;
1461
1462 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1463 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1464 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 1465 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
0fbb34a5
MD		 1466 }
1467 | integer_type_specifier
1468 {
1469 struct ctf_node *node;
1470
1471 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1472 node = $1;
3122e6f0 1473 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
0fbb34a5
MD		 1474 }
1475 | integer_declaration_specifiers CONST
1476 {
1477 struct ctf_node *node;
1478
1479 $$ = $1;
1480 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1481 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 1482 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
0fbb34a5
MD		 1483 }
1484 | integer_declaration_specifiers integer_type_specifier
1485 {
1486 $$ = $1;
3122e6f0 1487 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
0fbb34a5
MD		 1488 }
1489 ;
1490
8b9d5b5e
MD		 1491declaration_specifiers:
1492 CONST
6dc474b8 1493 {
3e11b713
MD		 1494 struct ctf_node *node;
1495
1496 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1497 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1498 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 1499 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 1500 }
8b9d5b5e 1501 | type_specifier
3e11b713
MD		 1502 {
1503 struct ctf_node *node;
1504
1505 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1506 node = $1;
3122e6f0 1507 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
3e11b713 1508 }
8b9d5b5e 1509 | declaration_specifiers CONST
6dc474b8
MD		 1510 {
1511 struct ctf_node *node;
1512
48a01768 1513 $$ = $1;
6dc474b8
MD		 1514 node = make_node(scanner, NODE_TYPE_SPECIFIER);
1515 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 1516 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 1517 }
8b9d5b5e 1518 | declaration_specifiers type_specifier
6dc474b8
MD		 1519 {
1520 $$ = $1;
3122e6f0 1521 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 1522 }
8b9d5b5e
MD		 1523 ;
1524
1525type_declarator_list:
1526 type_declarator
0009a725 1527 { $$ = $1; }
8b9d5b5e 1528 | type_declarator_list COMMA type_declarator
6dc474b8
MD		 1529 {
1530 $$ = $1;
3122e6f0 1531 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
6dc474b8 1532 }
8b9d5b5e
MD		 1533 ;
1534
0fbb34a5
MD		 1535integer_type_specifier:
1536 CHAR
1537 {
1538 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1539 $$->u.type_specifier.type = TYPESPEC_CHAR;
1540 }
1541 | SHORT
1542 {
1543 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1544 $$->u.type_specifier.type = TYPESPEC_SHORT;
1545 }
1546 | INT
1547 {
1548 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1549 $$->u.type_specifier.type = TYPESPEC_INT;
1550 }
1551 | LONG
1552 {
1553 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1554 $$->u.type_specifier.type = TYPESPEC_LONG;
1555 }
1556 | SIGNED
1557 {
1558 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1559 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1560 }
1561 | UNSIGNED
1562 {
1563 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1564 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1565 }
1566 | _BOOL
1567 {
1568 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1569 $$->u.type_specifier.type = TYPESPEC_BOOL;
1570 }
1571 | ID_TYPE
1572 {
1573 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1574 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
1575 $$->u.type_specifier.id_type = yylval.gs->s;
1576 }
1577 | INTEGER LBRAC RBRAC
1578 {
1579 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1580 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1581 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1582 }
1583 | INTEGER LBRAC ctf_assignment_expression_list RBRAC
1584 {
1585 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1586 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1587 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1588 if (set_parent_node($3, $$->u.type_specifier.node))
1589 reparent_error(scanner, "integer reparent error");
1590 }
1591 ;
1592
8b9d5b5e
MD		 1593type_specifier:
1594 VOID
6dc474b8
MD		 1595 {
1596 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1597 $$->u.type_specifier.type = TYPESPEC_VOID;
1598 }
8b9d5b5e 1599 | CHAR
6dc474b8
MD		 1600 {
1601 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1602 $$->u.type_specifier.type = TYPESPEC_CHAR;
1603 }
8b9d5b5e 1604 | SHORT
6dc474b8
MD		 1605 {
1606 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1607 $$->u.type_specifier.type = TYPESPEC_SHORT;
1608 }
8b9d5b5e 1609 | INT
6dc474b8
MD		 1610 {
1611 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1612 $$->u.type_specifier.type = TYPESPEC_INT;
1613 }
8b9d5b5e 1614 | LONG
6dc474b8
MD		 1615 {
1616 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1617 $$->u.type_specifier.type = TYPESPEC_LONG;
1618 }
8b9d5b5e 1619 | FLOAT
6dc474b8
MD		 1620 {
1621 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1622 $$->u.type_specifier.type = TYPESPEC_FLOAT;
1623 }
8b9d5b5e 1624 | DOUBLE
6dc474b8
MD		 1625 {
1626 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1627 $$->u.type_specifier.type = TYPESPEC_DOUBLE;
1628 }
8b9d5b5e 1629 | SIGNED
6dc474b8
MD		 1630 {
1631 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1632 $$->u.type_specifier.type = TYPESPEC_SIGNED;
1633 }
8b9d5b5e 1634 | UNSIGNED
6dc474b8
MD		 1635 {
1636 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1637 $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
1638 }
8b9d5b5e 1639 | _BOOL
6dc474b8
MD		 1640 {
1641 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1642 $$->u.type_specifier.type = TYPESPEC_BOOL;
1643 }
8b9d5b5e 1644 | _COMPLEX
6dc474b8
MD		 1645 {
1646 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1647 $$->u.type_specifier.type = TYPESPEC_COMPLEX;
1648 }
3888a159
MD		 1649 | _IMAGINARY
1650 {
1651 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1652 $$->u.type_specifier.type = TYPESPEC_IMAGINARY;
1653 }
8b9d5b5e 1654 | ID_TYPE
6dc474b8
MD		 1655 {
1656 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1657 $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
1658 $$->u.type_specifier.id_type = yylval.gs->s;
1659 }
8b9d5b5e 1660 | FLOATING_POINT LBRAC RBRAC
6dc474b8 1661 {
3e11b713
MD		 1662 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1663 $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
1664 $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
6dc474b8 1665 }
8b9d5b5e 1666 | FLOATING_POINT LBRAC ctf_assignment_expression_list RBRAC
6dc474b8 1667 {
3e11b713
MD		 1668 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1669 $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
1670 $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1671 if (set_parent_node($3, $$->u.type_specifier.node))
6dc474b8
MD		 1672 reparent_error(scanner, "floating point reparent error");
1673 }
8b9d5b5e 1674 | INTEGER LBRAC RBRAC
6dc474b8 1675 {
3e11b713
MD		 1676 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1677 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1678 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
6dc474b8 1679 }
8b9d5b5e 1680 | INTEGER LBRAC ctf_assignment_expression_list RBRAC
6dc474b8 1681 {
3e11b713
MD		 1682 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1683 $$->u.type_specifier.type = TYPESPEC_INTEGER;
1684 $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
1685 if (set_parent_node($3, $$->u.type_specifier.node))
6dc474b8
MD		 1686 reparent_error(scanner, "integer reparent error");
1687 }
b40c8090
MD		 1688 | STRING
1689 {
1690 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1691 $$->u.type_specifier.type = TYPESPEC_STRING;
1692 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1693 }
8b9d5b5e 1694 | STRING LBRAC RBRAC
6dc474b8 1695 {
3e11b713
MD		 1696 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1697 $$->u.type_specifier.type = TYPESPEC_STRING;
1698 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
6dc474b8 1699 }
8b9d5b5e 1700 | STRING LBRAC ctf_assignment_expression_list RBRAC
6dc474b8 1701 {
3e11b713
MD		 1702 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1703 $$->u.type_specifier.type = TYPESPEC_STRING;
1704 $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
1705 if (set_parent_node($3, $$->u.type_specifier.node))
6dc474b8
MD		 1706 reparent_error(scanner, "string reparent error");
1707 }
8b9d5b5e 1708 | ENUM enum_type_specifier
3e11b713
MD		 1709 {
1710 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1711 $$->u.type_specifier.type = TYPESPEC_ENUM;
1712 $$->u.type_specifier.node = $2;
1713 }
8b9d5b5e 1714 | VARIANT variant_type_specifier
3e11b713
MD		 1715 {
1716 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1717 $$->u.type_specifier.type = TYPESPEC_VARIANT;
1718 $$->u.type_specifier.node = $2;
3e11b713 1719 }
8b9d5b5e 1720 | STRUCT struct_type_specifier
3e11b713
MD		 1721 {
1722 $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1723 $$->u.type_specifier.type = TYPESPEC_STRUCT;
1724 $$->u.type_specifier.node = $2;
3e11b713 1725 }
8b9d5b5e
MD		 1726 ;
1727
1728struct_type_specifier:
1729 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
6dc474b8
MD		 1730 {
1731 $$ = make_node(scanner, NODE_STRUCT);
1ee8e81d 1732 $$->u._struct.has_body = 1;
5039b4cc 1733 if ($2 && set_parent_node($2, $$))
6dc474b8
MD		 1734 reparent_error(scanner, "struct reparent error");
1735 }
8b9d5b5e 1736 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
6dc474b8
MD		 1737 {
1738 $$ = make_node(scanner, NODE_STRUCT);
1ee8e81d 1739 $$->u._struct.has_body = 1;
6dc474b8 1740 $$->u._struct.name = $1->s;
5039b4cc 1741 if ($3 && set_parent_node($3, $$))
6dc474b8
MD		 1742 reparent_error(scanner, "struct reparent error");
1743 }
8b9d5b5e 1744 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
6dc474b8
MD		 1745 {
1746 $$ = make_node(scanner, NODE_STRUCT);
1ee8e81d 1747 $$->u._struct.has_body = 1;
6dc474b8 1748 $$->u._struct.name = $1->s;
5039b4cc 1749 if ($3 && set_parent_node($3, $$))
6dc474b8
MD		 1750 reparent_error(scanner, "struct reparent error");
1751 }
8b9d5b5e 1752 | IDENTIFIER
6dc474b8
MD		 1753 {
1754 $$ = make_node(scanner, NODE_STRUCT);
1ee8e81d 1755 $$->u._struct.has_body = 0;
6dc474b8
MD		 1756 $$->u._struct.name = $1->s;
1757 }
8b9d5b5e 1758 | ID_TYPE
6dc474b8
MD		 1759 {
1760 $$ = make_node(scanner, NODE_STRUCT);
1ee8e81d 1761 $$->u._struct.has_body = 0;
6dc474b8
MD		 1762 $$->u._struct.name = $1->s;
1763 }
b7e35bad
MD		 1764 | struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1765 {
1766 $$ = make_node(scanner, NODE_STRUCT);
1767 $$->u._struct.has_body = 1;
3122e6f0 1768 bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
b7e35bad
MD		 1769 if ($2 && set_parent_node($2, $$))
1770 reparent_error(scanner, "struct reparent error");
1771 }
1772 | IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1773 {
1774 $$ = make_node(scanner, NODE_STRUCT);
1775 $$->u._struct.has_body = 1;
1776 $$->u._struct.name = $1->s;
3122e6f0 1777 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
b7e35bad
MD		 1778 if ($3 && set_parent_node($3, $$))
1779 reparent_error(scanner, "struct reparent error");
1780 }
1781 | ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
1782 {
1783 $$ = make_node(scanner, NODE_STRUCT);
1784 $$->u._struct.has_body = 1;
1785 $$->u._struct.name = $1->s;
3122e6f0 1786 bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
b7e35bad
MD		 1787 if ($3 && set_parent_node($3, $$))
1788 reparent_error(scanner, "struct reparent error");
1789 }
8b9d5b5e
MD		 1790 ;
1791
1792struct_declaration_begin:
1793 LBRAC
fce8006d 1794 { push_scope(scanner); }
8b9d5b5e
MD		 1795 ;
1796
1797struct_declaration_end:
1798 RBRAC
fce8006d 1799 { pop_scope(scanner); }
8b9d5b5e
MD		 1800 ;
1801
1802variant_type_specifier:
1803 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1804 {
1805 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1806 $$->u.variant.has_body = 1;
5039b4cc 1807 if ($2 && set_parent_node($2, $$))
6dc474b8
MD		 1808 reparent_error(scanner, "variant reparent error");
1809 }
8b9d5b5e 1810 | LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1811 {
1812 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1813 $$->u.variant.has_body = 1;
6dc474b8 1814 $$->u.variant.choice = $2->s;
5039b4cc 1815 if ($5 && set_parent_node($5, $$))
6dc474b8
MD		 1816 reparent_error(scanner, "variant reparent error");
1817 }
8b9d5b5e 1818 | LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1819 {
1820 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1821 $$->u.variant.has_body = 1;
6dc474b8 1822 $$->u.variant.choice = $2->s;
5039b4cc 1823 if ($5 && set_parent_node($5, $$))
6dc474b8
MD		 1824 reparent_error(scanner, "variant reparent error");
1825 }
8b9d5b5e 1826 | IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1827 {
1828 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1829 $$->u.variant.has_body = 1;
6dc474b8 1830 $$->u.variant.name = $1->s;
5039b4cc 1831 if ($3 && set_parent_node($3, $$))
6dc474b8
MD		 1832 reparent_error(scanner, "variant reparent error");
1833 }
8b9d5b5e 1834 | IDENTIFIER LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1835 {
1836 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1837 $$->u.variant.has_body = 1;
6dc474b8
MD		 1838 $$->u.variant.name = $1->s;
1839 $$->u.variant.choice = $3->s;
5039b4cc 1840 if ($6 && set_parent_node($6, $$))
6dc474b8
MD		 1841 reparent_error(scanner, "variant reparent error");
1842 }
8b9d5b5e 1843 | IDENTIFIER LT IDENTIFIER GT
6dc474b8
MD		 1844 {
1845 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1846 $$->u.variant.has_body = 0;
6dc474b8
MD		 1847 $$->u.variant.name = $1->s;
1848 $$->u.variant.choice = $3->s;
1849 }
8b9d5b5e 1850 | IDENTIFIER LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1851 {
1852 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1853 $$->u.variant.has_body = 1;
6dc474b8
MD		 1854 $$->u.variant.name = $1->s;
1855 $$->u.variant.choice = $3->s;
5039b4cc 1856 if ($6 && set_parent_node($6, $$))
6dc474b8
MD		 1857 reparent_error(scanner, "variant reparent error");
1858 }
8b9d5b5e 1859 | IDENTIFIER LT ID_TYPE GT
6dc474b8
MD		 1860 {
1861 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1862 $$->u.variant.has_body = 0;
6dc474b8
MD		 1863 $$->u.variant.name = $1->s;
1864 $$->u.variant.choice = $3->s;
1865 }
8b9d5b5e 1866 | ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1867 {
1868 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1869 $$->u.variant.has_body = 1;
6dc474b8 1870 $$->u.variant.name = $1->s;
5039b4cc 1871 if ($3 && set_parent_node($3, $$))
6dc474b8
MD		 1872 reparent_error(scanner, "variant reparent error");
1873 }
8b9d5b5e 1874 | ID_TYPE LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1875 {
1876 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1877 $$->u.variant.has_body = 1;
6dc474b8
MD		 1878 $$->u.variant.name = $1->s;
1879 $$->u.variant.choice = $3->s;
5039b4cc 1880 if ($6 && set_parent_node($6, $$))
6dc474b8
MD		 1881 reparent_error(scanner, "variant reparent error");
1882 }
8b9d5b5e 1883 | ID_TYPE LT IDENTIFIER GT
6dc474b8
MD		 1884 {
1885 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1886 $$->u.variant.has_body = 0;
6dc474b8
MD		 1887 $$->u.variant.name = $1->s;
1888 $$->u.variant.choice = $3->s;
1889 }
8b9d5b5e 1890 | ID_TYPE LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
6dc474b8
MD		 1891 {
1892 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1893 $$->u.variant.has_body = 1;
6dc474b8
MD		 1894 $$->u.variant.name = $1->s;
1895 $$->u.variant.choice = $3->s;
5039b4cc 1896 if ($6 && set_parent_node($6, $$))
6dc474b8
MD		 1897 reparent_error(scanner, "variant reparent error");
1898 }
8b9d5b5e 1899 | ID_TYPE LT ID_TYPE GT
6dc474b8
MD		 1900 {
1901 $$ = make_node(scanner, NODE_VARIANT);
1ee8e81d 1902 $$->u.variant.has_body = 0;
6dc474b8
MD		 1903 $$->u.variant.name = $1->s;
1904 $$->u.variant.choice = $3->s;
1905 }
8b9d5b5e
MD		 1906 ;
1907
1908variant_declaration_begin:
1909 LBRAC
fce8006d 1910 { push_scope(scanner); }
8b9d5b5e
MD		 1911 ;
1912
1913variant_declaration_end:
1914 RBRAC
fce8006d 1915 { pop_scope(scanner); }
8b9d5b5e
MD		 1916 ;
1917
8b9d5b5e
MD		 1918enum_type_specifier:
1919 LBRAC enumerator_list RBRAC
6dc474b8
MD		 1920 {
1921 $$ = make_node(scanner, NODE_ENUM);
add40b62 1922 $$->u._enum.has_body = 1;
3122e6f0 1923 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 1924 }
0fbb34a5 1925 | COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
6dc474b8
MD		 1926 {
1927 $$ = make_node(scanner, NODE_ENUM);
add40b62 1928 $$->u._enum.has_body = 1;
3e11b713 1929 ($$)->u._enum.container_type = $2;
3122e6f0 1930 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 1931 }
8b9d5b5e 1932 | IDENTIFIER LBRAC enumerator_list RBRAC
6dc474b8
MD		 1933 {
1934 $$ = make_node(scanner, NODE_ENUM);
add40b62 1935 $$->u._enum.has_body = 1;
6dc474b8 1936 $$->u._enum.enum_id = $1->s;
3122e6f0 1937 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 1938 }
0fbb34a5 1939 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
6dc474b8
MD		 1940 {
1941 $$ = make_node(scanner, NODE_ENUM);
add40b62 1942 $$->u._enum.has_body = 1;
6dc474b8 1943 $$->u._enum.enum_id = $1->s;
3e11b713 1944 ($$)->u._enum.container_type = $3;
3122e6f0 1945 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 1946 }
8b9d5b5e 1947 | ID_TYPE LBRAC enumerator_list RBRAC
6dc474b8
MD		 1948 {
1949 $$ = make_node(scanner, NODE_ENUM);
add40b62 1950 $$->u._enum.has_body = 1;
6dc474b8 1951 $$->u._enum.enum_id = $1->s;
3122e6f0 1952 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 1953 }
0fbb34a5 1954 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
6dc474b8
MD		 1955 {
1956 $$ = make_node(scanner, NODE_ENUM);
add40b62 1957 $$->u._enum.has_body = 1;
6dc474b8 1958 $$->u._enum.enum_id = $1->s;
3e11b713 1959 ($$)->u._enum.container_type = $3;
3122e6f0 1960 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 1961 }
8b9d5b5e 1962 | LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 1963 {
1964 $$ = make_node(scanner, NODE_ENUM);
add40b62 1965 $$->u._enum.has_body = 1;
3122e6f0 1966 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 1967 }
0fbb34a5 1968 | COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 1969 {
1970 $$ = make_node(scanner, NODE_ENUM);
add40b62 1971 $$->u._enum.has_body = 1;
3e11b713 1972 ($$)->u._enum.container_type = $2;
3122e6f0 1973 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 1974 }
8b9d5b5e 1975 | IDENTIFIER LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 1976 {
1977 $$ = make_node(scanner, NODE_ENUM);
add40b62 1978 $$->u._enum.has_body = 1;
6dc474b8 1979 $$->u._enum.enum_id = $1->s;
3122e6f0 1980 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 1981 }
0fbb34a5 1982 | IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 1983 {
1984 $$ = make_node(scanner, NODE_ENUM);
add40b62 1985 $$->u._enum.has_body = 1;
6dc474b8 1986 $$->u._enum.enum_id = $1->s;
3e11b713 1987 ($$)->u._enum.container_type = $3;
3122e6f0 1988 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 1989 }
8b9d5b5e 1990 | IDENTIFIER
6dc474b8
MD		 1991 {
1992 $$ = make_node(scanner, NODE_ENUM);
add40b62 1993 $$->u._enum.has_body = 0;
6dc474b8
MD		 1994 $$->u._enum.enum_id = $1->s;
1995 }
8b9d5b5e 1996 | ID_TYPE LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 1997 {
1998 $$ = make_node(scanner, NODE_ENUM);
add40b62 1999 $$->u._enum.has_body = 1;
6dc474b8 2000 $$->u._enum.enum_id = $1->s;
3122e6f0 2001 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2002 }
0fbb34a5 2003 | ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
6dc474b8
MD		 2004 {
2005 $$ = make_node(scanner, NODE_ENUM);
add40b62 2006 $$->u._enum.has_body = 1;
6dc474b8 2007 $$->u._enum.enum_id = $1->s;
3e11b713 2008 ($$)->u._enum.container_type = $3;
3122e6f0 2009 _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
6dc474b8 2010 }
8b9d5b5e 2011 | ID_TYPE
6dc474b8
MD		 2012 {
2013 $$ = make_node(scanner, NODE_ENUM);
add40b62 2014 $$->u._enum.has_body = 0;
6dc474b8
MD		 2015 $$->u._enum.enum_id = $1->s;
2016 }
8b9d5b5e
MD		 2017 ;
2018
2019struct_or_variant_declaration_list:
2020 /* empty */
6dc474b8 2021 { $$ = NULL; }
8b9d5b5e 2022 | struct_or_variant_declaration_list struct_or_variant_declaration
6dc474b8
MD		 2023 {
2024 if ($1) {
2025 $$ = $1;
3122e6f0 2026 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
6dc474b8
MD		 2027 } else {
2028 $$ = $2;
3122e6f0 2029 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
6dc474b8
MD		 2030 }
2031 }
8b9d5b5e
MD		 2032 ;
2033
2034struct_or_variant_declaration:
1ee8e81d 2035 declaration_specifiers struct_or_variant_declarator_list SEMICOLON
6dc474b8 2036 {
3e11b713
MD		 2037 struct ctf_node *list;
2038
2039 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
3122e6f0 2040 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
6dc474b8 2041 $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
3e11b713 2042 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
3122e6f0 2043 _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
6dc474b8 2044 }
1ee8e81d 2045 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
6dc474b8 2046 {
3e11b713
MD		 2047 struct ctf_node *list;
2048
6dc474b8 2049 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 2050 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2051 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 2052 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2053 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2054 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2055 }
1ee8e81d 2056 | TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
6dc474b8 2057 {
3e11b713
MD		 2058 struct ctf_node *list;
2059
6dc474b8 2060 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 2061 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2062 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 2063 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2064 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2065 }
1ee8e81d 2066 | declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
6dc474b8 2067 {
3e11b713
MD		 2068 struct ctf_node *list;
2069
2070 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
3122e6f0 2071 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
6dc474b8 2072 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713 2073 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
3122e6f0 2074 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2075 }
a030d084 2076 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
6dc474b8 2077 {
3e11b713
MD		 2078 struct ctf_node *list;
2079
6dc474b8
MD		 2080 $$ = make_node(scanner, NODE_TYPEALIAS);
2081 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2082 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
3e11b713
MD		 2083
2084 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2085 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
3122e6f0
JD		 2086 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2087 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
3e11b713
MD		 2088
2089 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2090 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
3122e6f0
JD		 2091 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2092 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
6dc474b8 2093 }
8b9d5b5e
MD		 2094 ;
2095
1ee8e81d 2096alias_declaration_specifiers:
8b9d5b5e 2097 CONST
6dc474b8 2098 {
3e11b713
MD		 2099 struct ctf_node *node;
2100
2101 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2102 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2103 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 2104 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 2105 }
8b9d5b5e 2106 | type_specifier
3e11b713
MD		 2107 {
2108 struct ctf_node *node;
2109
2110 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2111 node = $1;
3122e6f0 2112 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
3e11b713 2113 }
1ee8e81d
MD		 2114 | IDENTIFIER
2115 {
3e11b713
MD		 2116 struct ctf_node *node;
2117
1ee8e81d 2118 add_type(scanner, $1);
3e11b713
MD		 2119 $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2120 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2121 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
2122 node->u.type_specifier.id_type = yylval.gs->s;
3122e6f0 2123 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1ee8e81d
MD		 2124 }
2125 | alias_declaration_specifiers CONST
6dc474b8
MD		 2126 {
2127 struct ctf_node *node;
2128
2129 $$ = $1;
2130 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2131 node->u.type_specifier.type = TYPESPEC_CONST;
3122e6f0 2132 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 2133 }
1ee8e81d 2134 | alias_declaration_specifiers type_specifier
6dc474b8
MD		 2135 {
2136 $$ = $1;
3122e6f0 2137 bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
6dc474b8 2138 }
1ee8e81d
MD		 2139 | alias_declaration_specifiers IDENTIFIER
2140 {
2141 struct ctf_node *node;
2142
2143 add_type(scanner, $2);
2144 $$ = $1;
2145 node = make_node(scanner, NODE_TYPE_SPECIFIER);
2146 node->u.type_specifier.type = TYPESPEC_ID_TYPE;
2147 node->u.type_specifier.id_type = yylval.gs->s;
3122e6f0 2148 bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
1ee8e81d 2149 }
8b9d5b5e
MD		 2150 ;
2151
2152struct_or_variant_declarator_list:
2153 struct_or_variant_declarator
0009a725 2154 { $$ = $1; }
8b9d5b5e 2155 | struct_or_variant_declarator_list COMMA struct_or_variant_declarator
6dc474b8
MD		 2156 {
2157 $$ = $1;
3122e6f0 2158 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
6dc474b8 2159 }
8b9d5b5e
MD		 2160 ;
2161
2162struct_or_variant_declarator:
2163 declarator
6dc474b8 2164 { $$ = $1; }
8b9d5b5e 2165 | COLON unary_expression
6dc474b8 2166 { $$ = $2; }
8b9d5b5e 2167 | declarator COLON unary_expression
6dc474b8
MD		 2168 {
2169 $$ = $1;
48a01768 2170 if (set_parent_node($3, $1))
6dc474b8
MD		 2171 reparent_error(scanner, "struct_or_variant_declarator");
2172 }
8b9d5b5e
MD		 2173 ;
2174
2175enumerator_list:
2176 enumerator
0009a725 2177 { $$ = $1; }
8b9d5b5e 2178 | enumerator_list COMMA enumerator
6dc474b8
MD		 2179 {
2180 $$ = $1;
3122e6f0 2181 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
6dc474b8 2182 }
8b9d5b5e
MD		 2183 ;
2184
2185enumerator:
2186 IDENTIFIER
6dc474b8
MD		 2187 {
2188 $$ = make_node(scanner, NODE_ENUMERATOR);
2189 $$->u.enumerator.id = $1->s;
2190 }
8b9d5b5e 2191 | ID_TYPE
6dc474b8
MD		 2192 {
2193 $$ = make_node(scanner, NODE_ENUMERATOR);
2194 $$->u.enumerator.id = $1->s;
2195 }
8b9d5b5e 2196 | keywords
6dc474b8
MD		 2197 {
2198 $$ = make_node(scanner, NODE_ENUMERATOR);
2199 $$->u.enumerator.id = $1->s;
2200 }
8b9d5b5e 2201 | STRING_LITERAL_START DQUOTE
6dc474b8
MD		 2202 {
2203 $$ = make_node(scanner, NODE_ENUMERATOR);
2204 $$->u.enumerator.id = "";
2205 }
8b9d5b5e 2206 | STRING_LITERAL_START s_char_sequence DQUOTE
6dc474b8
MD		 2207 {
2208 $$ = make_node(scanner, NODE_ENUMERATOR);
2209 $$->u.enumerator.id = $2->s;
2210 }
8b9d5b5e 2211 | IDENTIFIER EQUAL unary_expression_or_range
6dc474b8
MD		 2212 {
2213 $$ = make_node(scanner, NODE_ENUMERATOR);
2214 $$->u.enumerator.id = $1->s;
3122e6f0 2215 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
6dc474b8 2216 }
8b9d5b5e 2217 | ID_TYPE EQUAL unary_expression_or_range
6dc474b8
MD		 2218 {
2219 $$ = make_node(scanner, NODE_ENUMERATOR);
2220 $$->u.enumerator.id = $1->s;
3122e6f0 2221 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
6dc474b8 2222 }
8b9d5b5e 2223 | keywords EQUAL unary_expression_or_range
6dc474b8
MD		 2224 {
2225 $$ = make_node(scanner, NODE_ENUMERATOR);
2226 $$->u.enumerator.id = $1->s;
3122e6f0 2227 bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
6dc474b8 2228 }
8b9d5b5e 2229 | STRING_LITERAL_START DQUOTE EQUAL unary_expression_or_range
6dc474b8
MD		 2230 {
2231 $$ = make_node(scanner, NODE_ENUMERATOR);
2232 $$->u.enumerator.id = "";
3122e6f0 2233 bt_list_splice(&($4)->tmp_head, &($$)->u.enumerator.values);
6dc474b8 2234 }
8b9d5b5e 2235 | STRING_LITERAL_START s_char_sequence DQUOTE EQUAL unary_expression_or_range
6dc474b8
MD		 2236 {
2237 $$ = make_node(scanner, NODE_ENUMERATOR);
2238 $$->u.enumerator.id = $2->s;
3122e6f0 2239 bt_list_splice(&($5)->tmp_head, &($$)->u.enumerator.values);
6dc474b8 2240 }
8b9d5b5e
MD		 2241 ;
2242
2243abstract_declarator_list:
2244 abstract_declarator
0009a725 2245 { $$ = $1; }
8b9d5b5e 2246 | abstract_declarator_list COMMA abstract_declarator
6dc474b8
MD		 2247 {
2248 $$ = $1;
3122e6f0 2249 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
6dc474b8 2250 }
8b9d5b5e
MD		 2251 ;
2252
2253abstract_declarator:
2254 direct_abstract_declarator
6dc474b8 2255 { $$ = $1; }
8b9d5b5e 2256 | pointer direct_abstract_declarator
6dc474b8
MD		 2257 {
2258 $$ = $2;
3122e6f0 2259 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
6dc474b8 2260 }
8b9d5b5e
MD		 2261 ;
2262
2263direct_abstract_declarator:
2264 /* empty */
6dc474b8
MD		 2265 {
2266 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2267 $$->u.type_declarator.type = TYPEDEC_ID;
2268 /* id is NULL */
2269 }
8b9d5b5e 2270 | IDENTIFIER
6dc474b8
MD		 2271 {
2272 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2273 $$->u.type_declarator.type = TYPEDEC_ID;
2274 $$->u.type_declarator.u.id = $1->s;
2275 }
8b9d5b5e 2276 | LPAREN abstract_declarator RPAREN
6dc474b8
MD		 2277 {
2278 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2279 $$->u.type_declarator.type = TYPEDEC_NESTED;
2280 $$->u.type_declarator.u.nested.type_declarator = $2;
2281 }
98df1c9f 2282 | direct_abstract_declarator LSBRAC unary_expression RSBRAC
6dc474b8
MD		 2283 {
2284 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2285 $$->u.type_declarator.type = TYPEDEC_NESTED;
2286 $$->u.type_declarator.u.nested.type_declarator = $1;
3122e6f0
JD		 2287 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2288 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
6dc474b8 2289 }
8b9d5b5e 2290 | direct_abstract_declarator LSBRAC RSBRAC
6dc474b8
MD		 2291 {
2292 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2293 $$->u.type_declarator.type = TYPEDEC_NESTED;
2294 $$->u.type_declarator.u.nested.type_declarator = $1;
2295 $$->u.type_declarator.u.nested.abstract_array = 1;
2296 }
8b9d5b5e
MD		 2297 ;
2298
e0c14875
MD		 2299alias_abstract_declarator_list:
2300 alias_abstract_declarator
6dc474b8 2301 { $$ = $1; }
e0c14875
MD		 2302 | alias_abstract_declarator_list COMMA alias_abstract_declarator
2303 {
2304 $$ = $1;
3122e6f0 2305 bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
e0c14875
MD		 2306 }
2307 ;
2308
2309alias_abstract_declarator:
2310 direct_alias_abstract_declarator
2311 { $$ = $1; }
2312 | pointer direct_alias_abstract_declarator
6dc474b8
MD		 2313 {
2314 $$ = $2;
3122e6f0 2315 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
6dc474b8 2316 }
8b9d5b5e
MD		 2317 ;
2318
e0c14875
MD		 2319direct_alias_abstract_declarator:
2320 /* empty */
6dc474b8
MD		 2321 {
2322 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
e0c14875
MD		 2323 $$->u.type_declarator.type = TYPEDEC_ID;
2324 /* id is NULL */
6dc474b8 2325 }
e0c14875 2326 | LPAREN alias_abstract_declarator RPAREN
6dc474b8
MD		 2327 {
2328 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2329 $$->u.type_declarator.type = TYPEDEC_NESTED;
2330 $$->u.type_declarator.u.nested.type_declarator = $2;
2331 }
98df1c9f 2332 | direct_alias_abstract_declarator LSBRAC unary_expression RSBRAC
6dc474b8
MD		 2333 {
2334 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2335 $$->u.type_declarator.type = TYPEDEC_NESTED;
2336 $$->u.type_declarator.u.nested.type_declarator = $1;
3122e6f0
JD		 2337 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2338 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
6dc474b8 2339 }
e0c14875
MD		 2340 | direct_alias_abstract_declarator LSBRAC RSBRAC
2341 {
2342 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2343 $$->u.type_declarator.type = TYPEDEC_NESTED;
2344 $$->u.type_declarator.u.nested.type_declarator = $1;
2345 $$->u.type_declarator.u.nested.abstract_array = 1;
2346 }
8b9d5b5e
MD		 2347 ;
2348
e0c14875
MD		 2349declarator:
2350 direct_declarator
6dc474b8 2351 { $$ = $1; }
e0c14875 2352 | pointer direct_declarator
6dc474b8
MD		 2353 {
2354 $$ = $2;
3122e6f0 2355 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
6dc474b8 2356 }
8b9d5b5e
MD		 2357 ;
2358
e0c14875 2359direct_declarator:
8b9d5b5e 2360 IDENTIFIER
6dc474b8 2361 {
6dc474b8
MD		 2362 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2363 $$->u.type_declarator.type = TYPEDEC_ID;
2364 $$->u.type_declarator.u.id = $1->s;
2365 }
e0c14875 2366 | LPAREN declarator RPAREN
6dc474b8
MD		 2367 {
2368 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2369 $$->u.type_declarator.type = TYPEDEC_NESTED;
2370 $$->u.type_declarator.u.nested.type_declarator = $2;
2371 }
98df1c9f 2372 | direct_declarator LSBRAC unary_expression RSBRAC
6dc474b8
MD		 2373 {
2374 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2375 $$->u.type_declarator.type = TYPEDEC_NESTED;
2376 $$->u.type_declarator.u.nested.type_declarator = $1;
3122e6f0
JD		 2377 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2378 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
6dc474b8 2379 }
8b9d5b5e
MD		 2380 ;
2381
e0c14875
MD		 2382type_declarator:
2383 direct_type_declarator
6dc474b8 2384 { $$ = $1; }
e0c14875 2385 | pointer direct_type_declarator
6dc474b8
MD		 2386 {
2387 $$ = $2;
3122e6f0 2388 bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
6dc474b8 2389 }
8b9d5b5e
MD		 2390 ;
2391
e0c14875
MD		 2392direct_type_declarator:
2393 IDENTIFIER
6dc474b8
MD		 2394 {
2395 add_type(scanner, $1);
2396 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2397 $$->u.type_declarator.type = TYPEDEC_ID;
2398 $$->u.type_declarator.u.id = $1->s;
2399 }
e0c14875 2400 | LPAREN type_declarator RPAREN
6dc474b8
MD		 2401 {
2402 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2403 $$->u.type_declarator.type = TYPEDEC_NESTED;
2404 $$->u.type_declarator.u.nested.type_declarator = $2;
2405 }
98df1c9f 2406 | direct_type_declarator LSBRAC unary_expression RSBRAC
6dc474b8
MD		 2407 {
2408 $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2409 $$->u.type_declarator.type = TYPEDEC_NESTED;
2410 $$->u.type_declarator.u.nested.type_declarator = $1;
3122e6f0
JD		 2411 BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
2412 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
6dc474b8 2413 }
8b9d5b5e
MD		 2414 ;
2415
2416pointer:
2417 STAR
48a01768
MD		 2418 {
2419 $$ = make_node(scanner, NODE_POINTER);
48a01768 2420 }
8b9d5b5e 2421 | STAR pointer
6dc474b8
MD		 2422 {
2423 $$ = make_node(scanner, NODE_POINTER);
3122e6f0 2424 bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
6dc474b8 2425 }
8b9d5b5e 2426 | STAR type_qualifier_list pointer
6dc474b8
MD		 2427 {
2428 $$ = make_node(scanner, NODE_POINTER);
2429 $$->u.pointer.const_qualifier = 1;
3122e6f0 2430 bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
6dc474b8 2431 }
8b9d5b5e
MD		 2432 ;
2433
2434type_qualifier_list:
6dc474b8 2435 /* pointer assumes only const type qualifier */
8b9d5b5e
MD		 2436 CONST
2437 | type_qualifier_list CONST
2438 ;
2439
2440/* 2.3: CTF-specific declarations */
2441
2442ctf_assignment_expression_list:
2443 ctf_assignment_expression SEMICOLON
0009a725 2444 { $$ = $1; }
8b9d5b5e 2445 | ctf_assignment_expression_list ctf_assignment_expression SEMICOLON
6dc474b8
MD		 2446 {
2447 $$ = $1;
3122e6f0 2448 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
6dc474b8 2449 }
8b9d5b5e
MD		 2450 ;
2451
2452ctf_assignment_expression:
2453 unary_expression EQUAL unary_expression
02b234c4 2454 {
6dc474b8
MD		 2455 /*
2456 * Because we have left and right, cannot use
48a01768 2457 * set_parent_node.
6dc474b8 2458 */
02b234c4 2459 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
3122e6f0 2460 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
6dc474b8
MD		 2461 if ($1->u.unary_expression.type != UNARY_STRING)
2462 reparent_error(scanner, "ctf_assignment_expression left expects string");
3122e6f0 2463 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
02b234c4 2464 }
427c09b7 2465 | unary_expression TYPEASSIGN declaration_specifiers /* Only allow struct */
6dc474b8
MD		 2466 {
2467 /*
2468 * Because we have left and right, cannot use
48a01768 2469 * set_parent_node.
6dc474b8
MD		 2470 */
2471 $$ = make_node(scanner, NODE_CTF_EXPRESSION);
3122e6f0 2472 _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
6dc474b8
MD		 2473 if ($1->u.unary_expression.type != UNARY_STRING)
2474 reparent_error(scanner, "ctf_assignment_expression left expects string");
3122e6f0 2475 bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
6dc474b8 2476 }
8b9d5b5e 2477 | declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list
6dc474b8 2478 {
3e11b713
MD		 2479 struct ctf_node *list;
2480
2481 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
3122e6f0
JD		 2482 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2483 _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
6dc474b8 2484 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713 2485 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
3122e6f0 2486 _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2487 }
8b9d5b5e 2488 | TYPEDEF declaration_specifiers type_declarator_list
6dc474b8 2489 {
3e11b713
MD		 2490 struct ctf_node *list;
2491
6dc474b8 2492 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713
MD		 2493 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2494 $$->u._typedef.type_specifier_list = list;
3122e6f0
JD		 2495 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2496 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2497 }
8b9d5b5e 2498 | declaration_specifiers TYPEDEF type_declarator_list
6dc474b8 2499 {
3e11b713
MD		 2500 struct ctf_node *list;
2501
2502 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
3122e6f0 2503 _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
6dc474b8 2504 $$ = make_node(scanner, NODE_TYPEDEF);
3e11b713 2505 ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
3122e6f0 2506 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
6dc474b8 2507 }
a030d084 2508 | TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
6dc474b8 2509 {
3e11b713
MD		 2510 struct ctf_node *list;
2511
6dc474b8
MD		 2512 $$ = make_node(scanner, NODE_TYPEALIAS);
2513 $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2514 $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
3e11b713
MD		 2515
2516 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2517 $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
3122e6f0
JD		 2518 _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2519 _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
3e11b713
MD		 2520
2521 list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2522 $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
3122e6f0
JD		 2523 _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
2524 _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
6dc474b8 2525 }
8b9d5b5e 2526 ;
BabelTrace - Trace Format Babel Tower
This page took 0.158827 seconds and 4 git commands to generate.