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