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