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