src/plugins/ctf/common/metadata/parser.y

   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
  28 #define BT_LOG_OUTPUT_LEVEL ctf_plugin_metadata_log_level
  29 #define BT_LOG_TAG "PLUGIN/CTF/META/PARSER"
  30 #include "logging.h"
  31
  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>
  41 #include "common/list.h"
  42 #include "common/assert.h"
  43 #include "scanner.h"
  44 #include "ast.h"
  45 #include "objstack.h"
  46
  47 #include "parser-wrap.h"
  48
  49 /*
  50  * Avoid warning about "yynerrs" being unused, seen with bison 3.5.1 + clang 15
  51  * on Ubuntu 20.04.
  52  */
  53 BT_DIAG_IGNORE_UNUSED_BUT_SET_VARIABLE
  54
  55 /* Join two lists, put "add" at the end of "head".  */
  56 static 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
  68 BT_HIDDEN
  69 int yylex(union YYSTYPE *yyval, yyscan_t yyscanner);
  70 BT_HIDDEN
  71 int yylex_init_extra(struct ctf_scanner *scanner, yyscan_t * ptr_yy_globals);
  72 BT_HIDDEN
  73 int yylex_destroy(yyscan_t yyscanner);
  74 BT_HIDDEN
  75 void yyrestart(FILE * in_str, yyscan_t yyscanner);
  76 BT_HIDDEN
  77 int yyget_lineno(yyscan_t yyscanner);
  78 BT_HIDDEN
  79 char *yyget_text(yyscan_t yyscanner);
  80
  81 static 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  */
  92 static struct ctf_node error_node = {
  93         .type = NODE_ERROR,
  94 };
  95
  96 BT_HIDDEN
  97 const 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
 105 void 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
 111 static
 112 int 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
 122 static
 123 int 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
 140 static
 141 int 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         }
 166         BT_ASSERT_DBG(nr_char > 0);
 167         buffer[nr_char] = '\0';
 168         *buf_len = nr_char;
 169         return 0;
 170 }
 171
 172 static
 173 int 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
 284 int 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
 293                 _BT_LOGE_LINENO(yyget_lineno(scanner),
 294                         "wide characters are not supported as of this version: "
 295                         "scanner-addr=%p", scanner);
 296                 return -1;
 297         } else {
 298                 return import_basic_string(scanner, lvalp, len, src, delim);
 299         }
 300 }
 301
 302 static void init_scope(struct ctf_scanner_scope *scope,
 303                        struct ctf_scanner_scope *parent)
 304 {
 305         scope->parent = parent;
 306         scope->classes = g_hash_table_new_full(g_str_hash, g_str_equal,
 307                                              NULL, NULL);
 308 }
 309
 310 static void finalize_scope(struct ctf_scanner_scope *scope)
 311 {
 312         g_hash_table_destroy(scope->classes);
 313 }
 314
 315 static void push_scope(struct ctf_scanner *scanner)
 316 {
 317         struct ctf_scanner_scope *ns;
 318
 319         BT_LOGT("Pushing scope: scanner-addr=%p", scanner);
 320         ns = malloc(sizeof(struct ctf_scanner_scope));
 321         init_scope(ns, scanner->cs);
 322         scanner->cs = ns;
 323 }
 324
 325 static void pop_scope(struct ctf_scanner *scanner)
 326 {
 327         struct ctf_scanner_scope *os;
 328
 329         BT_LOGT("Popping scope: scanner-addr=%p", scanner);
 330         os = scanner->cs;
 331         scanner->cs = os->parent;
 332         finalize_scope(os);
 333         free(os);
 334 }
 335
 336 static int lookup_type(struct ctf_scanner_scope *s, const char *id)
 337 {
 338         int ret;
 339
 340         ret = GPOINTER_TO_INT(g_hash_table_lookup(s->classes, id));
 341         BT_LOGT("Looked up type: scanner-addr=%p, id=\"%s\", ret=%d",
 342                 s, id, ret);
 343         return ret;
 344 }
 345
 346 BT_HIDDEN
 347 int is_type(struct ctf_scanner *scanner, const char *id)
 348 {
 349         struct ctf_scanner_scope *it;
 350         int ret = 0;
 351
 352         for (it = scanner->cs; it; it = it->parent) {
 353                 if (lookup_type(it, id)) {
 354                         ret = 1;
 355                         break;
 356                 }
 357         }
 358         BT_LOGT("Found if ID is type: scanner-addr=%p, id=\"%s\", ret=%d",
 359                 scanner, id, ret);
 360         return ret;
 361 }
 362
 363 static void add_type(struct ctf_scanner *scanner, char *id)
 364 {
 365         BT_LOGT("Adding type: scanner-addr=%p, id=\"%s\"",
 366                 scanner, id);
 367         if (lookup_type(scanner->cs, id))
 368                 return;
 369         g_hash_table_insert(scanner->cs->classes, id, id);
 370 }
 371
 372 static 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) {
 379                 _BT_LOGE_LINENO(yyget_lineno(scanner->scanner),
 380                         "failed to allocate one stack entry: "
 381                         "scanner-addr=%p", scanner);
 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;
 392                 BT_LOGE("Trying to create root node: scanner-addr=%p",
 393                         scanner);
 394                 break;
 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;
 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;
 419         case NODE_TYPEDEF:
 420                 BT_INIT_LIST_HEAD(&node->u.field_class_def.field_class_declarators);
 421                 break;
 422         case NODE_TYPEALIAS_TARGET:
 423                 BT_INIT_LIST_HEAD(&node->u.field_class_alias_target.field_class_declarators);
 424                 break;
 425         case NODE_TYPEALIAS_ALIAS:
 426                 BT_INIT_LIST_HEAD(&node->u.field_class_alias_name.field_class_declarators);
 427                 break;
 428         case NODE_TYPEALIAS:
 429                 break;
 430         case NODE_TYPE_SPECIFIER:
 431                 break;
 432         case NODE_TYPE_SPECIFIER_LIST:
 433                 BT_INIT_LIST_HEAD(&node->u.field_class_specifier_list.head);
 434                 break;
 435         case NODE_POINTER:
 436                 break;
 437         case NODE_TYPE_DECLARATOR:
 438                 BT_INIT_LIST_HEAD(&node->u.field_class_declarator.pointers);
 439                 break;
 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:
 456                 BT_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.field_class_declarators);
 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;
 465         case NODE_UNKNOWN:
 466         default:
 467                 node->type = NODE_ERROR;
 468                 BT_LOGE("Unknown node type: scanner-addr=%p, node-type=%d",
 469                         scanner, type);
 470                 break;
 471         }
 472
 473         return node;
 474 }
 475
 476 static 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:
 528                 BT_LOGE("Unknown node type: node-type=%d", parent->type);
 529                 return -EINVAL;
 530         }
 531         return 0;
 532 }
 533
 534 static 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:
 585                 BT_LOGE("Unknown node type: node-type=%d", parent->type);
 586                 return -EINVAL;
 587         }
 588         return 0;
 589 }
 590
 591 static int reparent_field_class_alias(struct ctf_node *node, struct ctf_node *parent)
 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:
 642                 BT_LOGE("Unknown node type: node-type=%d", parent->type);
 643                 return -EINVAL;
 644         }
 645         return 0;
 646 }
 647
 648 static int reparent_field_class_specifier(struct ctf_node *node,
 649                                    struct ctf_node *parent)
 650 {
 651         switch (parent->type) {
 652         case NODE_TYPE_SPECIFIER_LIST:
 653                 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_specifier_list.head);
 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:
 683                 BT_LOGE("Unknown node type: node-type=%d", parent->type);
 684                 return -EINVAL;
 685         }
 686         return 0;
 687 }
 688
 689 static int reparent_field_class_specifier_list(struct ctf_node *node,
 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:
 721                 parent->u.field_class_def.field_class_specifier_list = node;
 722                 break;
 723         case NODE_TYPEALIAS_TARGET:
 724                 parent->u.field_class_alias_target.field_class_specifier_list = node;
 725                 break;
 726         case NODE_TYPEALIAS_ALIAS:
 727                 parent->u.field_class_alias_name.field_class_specifier_list = node;
 728                 break;
 729         case NODE_ENUM:
 730                 parent->u._enum.container_field_class = node;
 731                 break;
 732         case NODE_STRUCT_OR_VARIANT_DECLARATION:
 733                 parent->u.struct_or_variant_declaration.field_class_specifier_list = node;
 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:
 749                 BT_LOGE("Unknown node type: node-type=%d", parent->type);
 750                 return -EINVAL;
 751         }
 752         return 0;
 753 }
 754
 755 static int reparent_field_class_declarator(struct ctf_node *node,
 756                                     struct ctf_node *parent)
 757 {
 758         switch (parent->type) {
 759         case NODE_TYPE_DECLARATOR:
 760                 parent->u.field_class_declarator.type = TYPEDEC_NESTED;
 761                 parent->u.field_class_declarator.u.nested.field_class_declarator = node;
 762                 break;
 763         case NODE_STRUCT_OR_VARIANT_DECLARATION:
 764                 _bt_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.field_class_declarators);
 765                 break;
 766         case NODE_TYPEDEF:
 767                 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_def.field_class_declarators);
 768                 break;
 769         case NODE_TYPEALIAS_TARGET:
 770                 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_alias_target.field_class_declarators);
 771                 break;
 772         case NODE_TYPEALIAS_ALIAS:
 773                 _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_alias_name.field_class_declarators);
 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:
 800                 BT_LOGE("Unknown node type: node-type=%d", parent->type);
 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  */
 813 static 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:
 823                 BT_LOGE_STR("Trying to reparent root node.");
 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)
 873                         parent->u.field_class_declarator.bitfield_len = node;
 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)
 882                         parent->u.field_class_alias.target = node;
 883                 else
 884                         return -EINVAL;
 885                 /* fall-through */
 886         case NODE_TYPEALIAS_ALIAS:
 887                 if (parent->type == NODE_TYPEALIAS)
 888                         parent->u.field_class_alias.alias = node;
 889                 else
 890                         return -EINVAL;
 891                 /* fall-through */
 892         case NODE_TYPEALIAS:
 893                 return reparent_field_class_alias(node, parent);
 894
 895         case NODE_POINTER:
 896                 if (parent->type == NODE_TYPE_DECLARATOR) {
 897                         _bt_list_splice_tail(&node->tmp_head, &parent->u.field_class_declarator.pointers);
 898                 } else
 899                         return -EPERM;
 900                 break;
 901         case NODE_TYPE_DECLARATOR:
 902                 return reparent_field_class_declarator(node, parent);
 903
 904         case NODE_TYPE_SPECIFIER_LIST:
 905                 return reparent_field_class_specifier_list(node, parent);
 906
 907         case NODE_TYPE_SPECIFIER:
 908                 return reparent_field_class_specifier(node, parent);
 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:
 940                 BT_LOGE("Unknown node type: node-type=%d", parent->type);
 941                 return -EINVAL;
 942         }
 943         return 0;
 944 }
 945
 946 static
 947 void yyerror(struct ctf_scanner *scanner, yyscan_t yyscanner, const char *str)
 948 {
 949         _BT_LOGE_LINENO(yyget_lineno(scanner->scanner),
 950                 "%s: token=\"%s\"", str, yyget_text(scanner->scanner));
 951 }
 952
 953 #define reparent_error(scanner, str)                            \
 954 do {                                                            \
 955         yyerror(scanner, scanner->scanner, YY_("reparent_error: " str)); \
 956         YYERROR;                                                \
 957 } while (0)
 958
 959 static 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
 978 int ctf_scanner_append_ast(struct ctf_scanner *scanner, FILE *input)
 979 {
 980         /* Start processing new stream */
 981         yyrestart(input, scanner->scanner);
 982         return yyparse(scanner, scanner->scanner);
 983 }
 984
 985 struct ctf_scanner *ctf_scanner_alloc(void)
 986 {
 987         struct ctf_scanner *scanner;
 988         int ret;
 989
 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) {
 996                 BT_LOGE("yylex_init_extra() failed: ret=%d", ret);
 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
1010 cleanup_objstack:
1011         objstack_destroy(scanner->objstack);
1012 cleanup_lexer:
1013         ret = yylex_destroy(scanner->scanner);
1014         if (!ret)
1015                 BT_LOGE("yylex_destroy() failed: scanner-addr=%p, ret=%d",
1016                         scanner, ret);
1017 cleanup_scanner:
1018         free(scanner);
1019         return NULL;
1020 }
1021
1022 void 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)
1032                 BT_LOGE("yylex_destroy() failed: scanner-addr=%p, ret=%d",
1033                         scanner, ret);
1034         free(scanner);
1035 }
1036
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
1048 %}
1049
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
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 }
1067
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
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
1085 %token <s> IDENTIFIER ID_TYPE
1086 %token CTF_ERROR
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
1096 %type <s> CTF_STRING_LITERAL CTF_CHARACTER_LITERAL
1097
1098 %type <s> keywords
1099
1100 %type <ull> CTF_INTEGER_LITERAL
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
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
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
1134 %type <n> field_class_declarator
1135 %type <n> direct_field_class_declarator
1136 %type <n> pointer
1137 %type <n> ctf_assignment_expression_list
1138 %type <n> ctf_assignment_expression
1139
1140 %%
1141
1142 file:
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
1155 keywords:
1156                 CTF_VOID
1157                 {       $$ = yylval.s;          }
1158         |       CTF_CHAR
1159                 {       $$ = yylval.s;          }
1160         |       CTF_SHORT
1161                 {       $$ = yylval.s;          }
1162         |       CTF_INT
1163                 {       $$ = yylval.s;          }
1164         |       CTF_LONG
1165                 {       $$ = yylval.s;          }
1166         |       CTF_FLOAT
1167                 {       $$ = yylval.s;          }
1168         |       CTF_DOUBLE
1169                 {       $$ = yylval.s;          }
1170         |       CTF_SIGNED
1171                 {       $$ = yylval.s;          }
1172         |       CTF_UNSIGNED
1173                 {       $$ = yylval.s;          }
1174         |       CTF_BOOL
1175                 {       $$ = yylval.s;          }
1176         |       CTF_COMPLEX
1177                 {       $$ = yylval.s;          }
1178         |       CTF_IMAGINARY
1179                 {       $$ = yylval.s;          }
1180         |       CTF_FLOATING_POINT
1181                 {       $$ = yylval.s;          }
1182         |       CTF_INTEGER
1183                 {       $$ = yylval.s;          }
1184         |       CTF_STRING
1185                 {       $$ = yylval.s;          }
1186         |       CTF_ENUM
1187                 {       $$ = yylval.s;          }
1188         |       CTF_VARIANT
1189                 {       $$ = yylval.s;          }
1190         |       CTF_STRUCT
1191                 {       $$ = yylval.s;          }
1192         |       CTF_CONST
1193                 {       $$ = yylval.s;          }
1194         |       CTF_TYPEDEF
1195                 {       $$ = yylval.s;          }
1196         |       CTF_EVENT
1197                 {       $$ = yylval.s;          }
1198         |       CTF_STREAM
1199                 {       $$ = yylval.s;          }
1200         |       CTF_ENV
1201                 {       $$ = yylval.s;          }
1202         |       CTF_TRACE
1203                 {       $$ = yylval.s;          }
1204         |       CTF_CLOCK
1205                 {       $$ = yylval.s;          }
1206         |       CTF_CALLSITE
1207                 {       $$ = yylval.s;          }
1208         |       CTF_TOK_ALIGN
1209                 {       $$ = yylval.s;          }
1210         ;
1211
1212
1213 /* 2: Phrase structure grammar */
1214
1215 postfix_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                 }
1234         |       CTF_INTEGER_LITERAL
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                 }
1240         |       CTF_STRING_LITERAL
1241                 {
1242                         $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1243                         $$->u.unary_expression.type = UNARY_STRING;
1244                         $$->u.unary_expression.u.string = $1;
1245                 }
1246         |       CTF_CHARACTER_LITERAL
1247                 {
1248                         $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1249                         $$->u.unary_expression.type = UNARY_STRING;
1250                         $$->u.unary_expression.u.string = $1;
1251                 }
1252         |       CTF_LPAREN unary_expression CTF_RPAREN
1253                 {
1254                         $$ = $2;
1255                 }
1256         |       postfix_expression CTF_LSBRAC unary_expression CTF_RSBRAC
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                 }
1264         |       postfix_expression CTF_DOT IDENTIFIER
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                 }
1273         |       postfix_expression CTF_DOT ID_TYPE
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                 }
1282         |       postfix_expression CTF_DOT keywords
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                 }
1291         |       postfix_expression CTF_RARROW IDENTIFIER
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                 }
1300         |       postfix_expression CTF_RARROW ID_TYPE
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
1311 unary_expression:
1312                 postfix_expression
1313                 {       $$ = $1;                                }
1314         |       CTF_PLUS postfix_expression
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                 }
1322         |       CTF_MINUS postfix_expression
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);
1329                         } else if ($$->u.unary_expression.type == UNARY_SIGNED_CONSTANT) {
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
1338 unary_expression_or_range:
1339                 unary_expression CTF_DOTDOTDOT unary_expression
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
1351 declaration:
1352                 declaration_specifiers CTF_SEMICOLON
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;        }
1366         |       declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
1367                 {
1368                         struct ctf_node *list;
1369
1370                         $$ = make_node(scanner, NODE_TYPEDEF);
1371                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
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);
1376                 }
1377         |       CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
1378                 {
1379                         struct ctf_node *list;
1380
1381                         $$ = make_node(scanner, NODE_TYPEDEF);
1382                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
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);
1386                 }
1387         |       declaration_specifiers CTF_TYPEDEF field_class_declarator_list CTF_SEMICOLON
1388                 {
1389                         struct ctf_node *list;
1390
1391                         $$ = make_node(scanner, NODE_TYPEDEF);
1392                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
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);
1396                 }
1397         |       CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
1398                 {
1399                         struct ctf_node *list;
1400
1401                         $$ = make_node(scanner, NODE_TYPEALIAS);
1402                         $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1403                         $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1404
1405                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
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);
1409
1410                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
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);
1414                 }
1415         ;
1416
1417 event_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
1430 event_declaration_begin:
1431                 CTF_EVENT CTF_LBRAC
1432                 {       push_scope(scanner);    }
1433         ;
1434
1435 event_declaration_end:
1436                 CTF_RBRAC CTF_SEMICOLON
1437                 {       pop_scope(scanner);     }
1438         ;
1439
1440
1441 stream_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
1454 stream_declaration_begin:
1455                 CTF_STREAM CTF_LBRAC
1456                 {       push_scope(scanner);    }
1457         ;
1458
1459 stream_declaration_end:
1460                 CTF_RBRAC CTF_SEMICOLON
1461                 {       pop_scope(scanner);     }
1462         ;
1463
1464 env_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
1477 env_declaration_begin:
1478                 CTF_ENV CTF_LBRAC
1479                 {       push_scope(scanner);    }
1480         ;
1481
1482 env_declaration_end:
1483                 CTF_RBRAC CTF_SEMICOLON
1484                 {       pop_scope(scanner);     }
1485         ;
1486
1487 trace_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
1500 trace_declaration_begin:
1501                 CTF_TRACE CTF_LBRAC
1502                 {       push_scope(scanner);    }
1503         ;
1504
1505 trace_declaration_end:
1506                 CTF_RBRAC CTF_SEMICOLON
1507                 {       pop_scope(scanner);     }
1508         ;
1509
1510 clock_declaration:
1511                 CTF_CLOCK clock_declaration_begin clock_declaration_end
1512                 {
1513                         $$ = make_node(scanner, NODE_CLOCK);
1514                 }
1515         |       CTF_CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
1516                 {
1517                         $$ = make_node(scanner, NODE_CLOCK);
1518                         if (set_parent_node($3, $$))
1519                                 reparent_error(scanner, "trace_declaration");
1520                 }
1521         ;
1522
1523 clock_declaration_begin:
1524                 CTF_LBRAC
1525                 {       push_scope(scanner);    }
1526         ;
1527
1528 clock_declaration_end:
1529                 CTF_RBRAC CTF_SEMICOLON
1530                 {       pop_scope(scanner);     }
1531         ;
1532
1533 callsite_declaration:
1534                 CTF_CALLSITE callsite_declaration_begin callsite_declaration_end
1535                 {
1536                         $$ = make_node(scanner, NODE_CALLSITE);
1537                 }
1538         |       CTF_CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
1539                 {
1540                         $$ = make_node(scanner, NODE_CALLSITE);
1541                         if (set_parent_node($3, $$))
1542                                 reparent_error(scanner, "trace_declaration");
1543                 }
1544         ;
1545
1546 callsite_declaration_begin:
1547                 CTF_LBRAC
1548                 {       push_scope(scanner);    }
1549         ;
1550
1551 callsite_declaration_end:
1552                 CTF_RBRAC CTF_SEMICOLON
1553                 {       pop_scope(scanner);     }
1554         ;
1555
1556 integer_declaration_specifiers:
1557                 CTF_CONST
1558                 {
1559                         struct ctf_node *node;
1560
1561                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1562                         node = make_node(scanner, NODE_TYPE_SPECIFIER);
1563                         node->u.field_class_specifier.type = TYPESPEC_CONST;
1564                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1565                 }
1566         |       integer_field_class_specifier
1567                 {
1568                         struct ctf_node *node;
1569
1570                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1571                         node = $1;
1572                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1573                 }
1574         |       integer_declaration_specifiers CTF_CONST
1575                 {
1576                         struct ctf_node *node;
1577
1578                         $$ = $1;
1579                         node = make_node(scanner, NODE_TYPE_SPECIFIER);
1580                         node->u.field_class_specifier.type = TYPESPEC_CONST;
1581                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1582                 }
1583         |       integer_declaration_specifiers integer_field_class_specifier
1584                 {
1585                         $$ = $1;
1586                         bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
1587                 }
1588         ;
1589
1590 declaration_specifiers:
1591                 CTF_CONST
1592                 {
1593                         struct ctf_node *node;
1594
1595                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1596                         node = make_node(scanner, NODE_TYPE_SPECIFIER);
1597                         node->u.field_class_specifier.type = TYPESPEC_CONST;
1598                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1599                 }
1600         |       field_class_specifier
1601                 {
1602                         struct ctf_node *node;
1603
1604                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1605                         node = $1;
1606                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1607                 }
1608         |       declaration_specifiers CTF_CONST
1609                 {
1610                         struct ctf_node *node;
1611
1612                         $$ = $1;
1613                         node = make_node(scanner, NODE_TYPE_SPECIFIER);
1614                         node->u.field_class_specifier.type = TYPESPEC_CONST;
1615                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1616                 }
1617         |       declaration_specifiers field_class_specifier
1618                 {
1619                         $$ = $1;
1620                         bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
1621                 }
1622         ;
1623
1624 field_class_declarator_list:
1625                 field_class_declarator
1626                 {       $$ = $1;        }
1627         |       field_class_declarator_list CTF_COMMA field_class_declarator
1628                 {
1629                         $$ = $1;
1630                         bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1631                 }
1632         ;
1633
1634 integer_field_class_specifier:
1635                 CTF_CHAR
1636                 {
1637                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1638                         $$->u.field_class_specifier.type = TYPESPEC_CHAR;
1639                 }
1640         |       CTF_SHORT
1641                 {
1642                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1643                         $$->u.field_class_specifier.type = TYPESPEC_SHORT;
1644                 }
1645         |       CTF_INT
1646                 {
1647                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1648                         $$->u.field_class_specifier.type = TYPESPEC_INT;
1649                 }
1650         |       CTF_LONG
1651                 {
1652                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1653                         $$->u.field_class_specifier.type = TYPESPEC_LONG;
1654                 }
1655         |       CTF_SIGNED
1656                 {
1657                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1658                         $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
1659                 }
1660         |       CTF_UNSIGNED
1661                 {
1662                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1663                         $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
1664                 }
1665         |       CTF_BOOL
1666                 {
1667                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1668                         $$->u.field_class_specifier.type = TYPESPEC_BOOL;
1669                 }
1670         |       ID_TYPE
1671                 {
1672                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1673                         $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
1674                         $$->u.field_class_specifier.id_type = yylval.s;
1675                 }
1676         |       CTF_INTEGER CTF_LBRAC CTF_RBRAC
1677                 {
1678                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1679                         $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1680                         $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1681                 }
1682         |       CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1683                 {
1684                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
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))
1688                                 reparent_error(scanner, "integer reparent error");
1689                 }
1690         ;
1691
1692 field_class_specifier:
1693                 CTF_VOID
1694                 {
1695                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1696                         $$->u.field_class_specifier.type = TYPESPEC_VOID;
1697                 }
1698         |       CTF_CHAR
1699                 {
1700                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1701                         $$->u.field_class_specifier.type = TYPESPEC_CHAR;
1702                 }
1703         |       CTF_SHORT
1704                 {
1705                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1706                         $$->u.field_class_specifier.type = TYPESPEC_SHORT;
1707                 }
1708         |       CTF_INT
1709                 {
1710                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1711                         $$->u.field_class_specifier.type = TYPESPEC_INT;
1712                 }
1713         |       CTF_LONG
1714                 {
1715                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1716                         $$->u.field_class_specifier.type = TYPESPEC_LONG;
1717                 }
1718         |       CTF_FLOAT
1719                 {
1720                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1721                         $$->u.field_class_specifier.type = TYPESPEC_FLOAT;
1722                 }
1723         |       CTF_DOUBLE
1724                 {
1725                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1726                         $$->u.field_class_specifier.type = TYPESPEC_DOUBLE;
1727                 }
1728         |       CTF_SIGNED
1729                 {
1730                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1731                         $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
1732                 }
1733         |       CTF_UNSIGNED
1734                 {
1735                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1736                         $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
1737                 }
1738         |       CTF_BOOL
1739                 {
1740                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1741                         $$->u.field_class_specifier.type = TYPESPEC_BOOL;
1742                 }
1743         |       CTF_COMPLEX
1744                 {
1745                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1746                         $$->u.field_class_specifier.type = TYPESPEC_COMPLEX;
1747                 }
1748         |       CTF_IMAGINARY
1749                 {
1750                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1751                         $$->u.field_class_specifier.type = TYPESPEC_IMAGINARY;
1752                 }
1753         |       ID_TYPE
1754                 {
1755                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1756                         $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
1757                         $$->u.field_class_specifier.id_type = yylval.s;
1758                 }
1759         |       CTF_FLOATING_POINT CTF_LBRAC CTF_RBRAC
1760                 {
1761                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1762                         $$->u.field_class_specifier.type = TYPESPEC_FLOATING_POINT;
1763                         $$->u.field_class_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1764                 }
1765         |       CTF_FLOATING_POINT CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1766                 {
1767                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
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))
1771                                 reparent_error(scanner, "floating point reparent error");
1772                 }
1773         |       CTF_INTEGER CTF_LBRAC CTF_RBRAC
1774                 {
1775                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1776                         $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1777                         $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1778                 }
1779         |       CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1780                 {
1781                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
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))
1785                                 reparent_error(scanner, "integer reparent error");
1786                 }
1787         |       CTF_STRING
1788                 {
1789                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1790                         $$->u.field_class_specifier.type = TYPESPEC_STRING;
1791                         $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1792                 }
1793         |       CTF_STRING CTF_LBRAC CTF_RBRAC
1794                 {
1795                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1796                         $$->u.field_class_specifier.type = TYPESPEC_STRING;
1797                         $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1798                 }
1799         |       CTF_STRING CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1800                 {
1801                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
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))
1805                                 reparent_error(scanner, "string reparent error");
1806                 }
1807         |       CTF_ENUM enum_field_class_specifier
1808                 {
1809                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1810                         $$->u.field_class_specifier.type = TYPESPEC_ENUM;
1811                         $$->u.field_class_specifier.node = $2;
1812                 }
1813         |       CTF_VARIANT variant_field_class_specifier
1814                 {
1815                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1816                         $$->u.field_class_specifier.type = TYPESPEC_VARIANT;
1817                         $$->u.field_class_specifier.node = $2;
1818                 }
1819         |       CTF_STRUCT struct_class_specifier
1820                 {
1821                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1822                         $$->u.field_class_specifier.type = TYPESPEC_STRUCT;
1823                         $$->u.field_class_specifier.node = $2;
1824                 }
1825         ;
1826
1827 struct_class_specifier:
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                 }
1863         |       struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
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                 }
1871         |       IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
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                 }
1880         |       ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
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
1891 struct_declaration_begin:
1892                 CTF_LBRAC
1893                 {       push_scope(scanner);    }
1894         ;
1895
1896 struct_declaration_end:
1897                 CTF_RBRAC
1898                 {       pop_scope(scanner);     }
1899         ;
1900
1901 variant_field_class_specifier:
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                 }
1909         |       CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
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                 }
1917         |       CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
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                 }
1933         |       IDENTIFIER CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
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                 }
1942         |       IDENTIFIER CTF_LT IDENTIFIER CTF_GT
1943                 {
1944                         $$ = make_node(scanner, NODE_VARIANT);
1945                         $$->u.variant.has_body = 0;
1946                         $$->u.variant.name = $1;
1947                         $$->u.variant.choice = $3;
1948                 }
1949         |       IDENTIFIER CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
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                 }
1958         |       IDENTIFIER CTF_LT ID_TYPE CTF_GT
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                 }
1973         |       ID_TYPE CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
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                 }
1982         |       ID_TYPE CTF_LT IDENTIFIER CTF_GT
1983                 {
1984                         $$ = make_node(scanner, NODE_VARIANT);
1985                         $$->u.variant.has_body = 0;
1986                         $$->u.variant.name = $1;
1987                         $$->u.variant.choice = $3;
1988                 }
1989         |       ID_TYPE CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
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                 }
1998         |       ID_TYPE CTF_LT ID_TYPE CTF_GT
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
2007 variant_declaration_begin:
2008                 CTF_LBRAC
2009                 {       push_scope(scanner);    }
2010         ;
2011
2012 variant_declaration_end:
2013                 CTF_RBRAC
2014                 {       pop_scope(scanner);     }
2015         ;
2016
2017 enum_field_class_specifier:
2018                 CTF_LBRAC enumerator_list CTF_RBRAC
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                 }
2024         |       CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2025                 {
2026                         $$ = make_node(scanner, NODE_ENUM);
2027                         $$->u._enum.has_body = 1;
2028                         ($$)->u._enum.container_field_class = $2;
2029                         _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2030                 }
2031         |       IDENTIFIER CTF_LBRAC enumerator_list CTF_RBRAC
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                 }
2038         |       IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2039                 {
2040                         $$ = make_node(scanner, NODE_ENUM);
2041                         $$->u._enum.has_body = 1;
2042                         $$->u._enum.enum_id = $1;
2043                         ($$)->u._enum.container_field_class = $3;
2044                         _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2045                 }
2046         |       ID_TYPE CTF_LBRAC enumerator_list CTF_RBRAC
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                 }
2053         |       ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2054                 {
2055                         $$ = make_node(scanner, NODE_ENUM);
2056                         $$->u._enum.has_body = 1;
2057                         $$->u._enum.enum_id = $1;
2058                         ($$)->u._enum.container_field_class = $3;
2059                         _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2060                 }
2061         |       CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
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                 }
2067         |       CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2068                 {
2069                         $$ = make_node(scanner, NODE_ENUM);
2070                         $$->u._enum.has_body = 1;
2071                         ($$)->u._enum.container_field_class = $2;
2072                         _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2073                 }
2074         |       IDENTIFIER CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
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                 }
2081         |       IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2082                 {
2083                         $$ = make_node(scanner, NODE_ENUM);
2084                         $$->u._enum.has_body = 1;
2085                         $$->u._enum.enum_id = $1;
2086                         ($$)->u._enum.container_field_class = $3;
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                 }
2095         |       ID_TYPE CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
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                 }
2102         |       ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2103                 {
2104                         $$ = make_node(scanner, NODE_ENUM);
2105                         $$->u._enum.has_body = 1;
2106                         $$->u._enum.enum_id = $1;
2107                         ($$)->u._enum.container_field_class = $3;
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
2118 struct_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
2133 struct_or_variant_declaration:
2134                 declaration_specifiers struct_or_variant_declarator_list CTF_SEMICOLON
2135                 {
2136                         struct ctf_node *list;
2137
2138                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2139                         _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2140                         $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
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);
2143                 }
2144         |       declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
2145                 {
2146                         struct ctf_node *list;
2147
2148                         $$ = make_node(scanner, NODE_TYPEDEF);
2149                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
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);
2154                 }
2155         |       CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
2156                 {
2157                         struct ctf_node *list;
2158
2159                         $$ = make_node(scanner, NODE_TYPEDEF);
2160                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
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);
2164                 }
2165         |       declaration_specifiers CTF_TYPEDEF field_class_declarator_list CTF_SEMICOLON
2166                 {
2167                         struct ctf_node *list;
2168
2169                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2170                         _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2171                         $$ = make_node(scanner, NODE_TYPEDEF);
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);
2174                 }
2175         |       CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
2176                 {
2177                         struct ctf_node *list;
2178
2179                         $$ = make_node(scanner, NODE_TYPEALIAS);
2180                         $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2181                         $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2182
2183                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
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);
2187
2188                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
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);
2192                 }
2193         ;
2194
2195 alias_declaration_specifiers:
2196                 CTF_CONST
2197                 {
2198                         struct ctf_node *node;
2199
2200                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2201                         node = make_node(scanner, NODE_TYPE_SPECIFIER);
2202                         node->u.field_class_specifier.type = TYPESPEC_CONST;
2203                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2204                 }
2205         |       field_class_specifier
2206                 {
2207                         struct ctf_node *node;
2208
2209                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2210                         node = $1;
2211                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
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);
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);
2223                 }
2224         |       alias_declaration_specifiers CTF_CONST
2225                 {
2226                         struct ctf_node *node;
2227
2228                         $$ = $1;
2229                         node = make_node(scanner, NODE_TYPE_SPECIFIER);
2230                         node->u.field_class_specifier.type = TYPESPEC_CONST;
2231                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2232                 }
2233         |       alias_declaration_specifiers field_class_specifier
2234                 {
2235                         $$ = $1;
2236                         bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
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);
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);
2248                 }
2249         ;
2250
2251 struct_or_variant_declarator_list:
2252                 struct_or_variant_declarator
2253                 {       $$ = $1;        }
2254         |       struct_or_variant_declarator_list CTF_COMMA struct_or_variant_declarator
2255                 {
2256                         $$ = $1;
2257                         bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2258                 }
2259         ;
2260
2261 struct_or_variant_declarator:
2262                 declarator
2263                 {       $$ = $1;        }
2264         |       CTF_COLON unary_expression
2265                 {       $$ = $2;        }
2266         |       declarator CTF_COLON unary_expression
2267                 {
2268                         $$ = $1;
2269                         if (set_parent_node($3, $1))
2270                                 reparent_error(scanner, "struct_or_variant_declarator");
2271                 }
2272         ;
2273
2274 enumerator_list:
2275                 enumerator
2276                 {       $$ = $1;        }
2277         |       enumerator_list CTF_COMMA enumerator
2278                 {
2279                         $$ = $1;
2280                         bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2281                 }
2282         ;
2283
2284 enumerator:
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                 }
2300         |       CTF_STRING_LITERAL
2301                 {
2302                         $$ = make_node(scanner, NODE_ENUMERATOR);
2303                         $$->u.enumerator.id = $1;
2304                 }
2305         |       IDENTIFIER CTF_EQUAL unary_expression_or_range
2306                 {
2307                         $$ = make_node(scanner, NODE_ENUMERATOR);
2308                         $$->u.enumerator.id = $1;
2309                         bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2310                 }
2311         |       ID_TYPE CTF_EQUAL unary_expression_or_range
2312                 {
2313                         $$ = make_node(scanner, NODE_ENUMERATOR);
2314                         $$->u.enumerator.id = $1;
2315                         bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2316                 }
2317         |       keywords CTF_EQUAL unary_expression_or_range
2318                 {
2319                         $$ = make_node(scanner, NODE_ENUMERATOR);
2320                         $$->u.enumerator.id = $1;
2321                         bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2322                 }
2323         |       CTF_STRING_LITERAL CTF_EQUAL unary_expression_or_range
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
2331 abstract_declarator_list:
2332                 abstract_declarator
2333                 {       $$ = $1;        }
2334         |       abstract_declarator_list CTF_COMMA abstract_declarator
2335                 {
2336                         $$ = $1;
2337                         bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2338                 }
2339         ;
2340
2341 abstract_declarator:
2342                 direct_abstract_declarator
2343                 {       $$ = $1;        }
2344         |       pointer direct_abstract_declarator
2345                 {
2346                         $$ = $2;
2347                         bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2348                 }
2349         ;
2350
2351 direct_abstract_declarator:
2352                 /* empty */
2353                 {
2354                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2355                         $$->u.field_class_declarator.type = TYPEDEC_ID;
2356                         /* id is NULL */
2357                 }
2358         |       IDENTIFIER
2359                 {
2360                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2361                         $$->u.field_class_declarator.type = TYPEDEC_ID;
2362                         $$->u.field_class_declarator.u.id = $1;
2363                 }
2364         |       CTF_LPAREN abstract_declarator CTF_RPAREN
2365                 {
2366                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2367                         $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2368                         $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2369                 }
2370         |       direct_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2371                 {
2372                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
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);
2377                 }
2378         |       direct_abstract_declarator CTF_LSBRAC CTF_RSBRAC
2379                 {
2380                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
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;
2384                 }
2385         ;
2386
2387 alias_abstract_declarator_list:
2388                 alias_abstract_declarator
2389                 {       $$ = $1;        }
2390         |       alias_abstract_declarator_list CTF_COMMA alias_abstract_declarator
2391                 {
2392                         $$ = $1;
2393                         bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2394                 }
2395         ;
2396
2397 alias_abstract_declarator:
2398                 direct_alias_abstract_declarator
2399                 {       $$ = $1;        }
2400         |       pointer direct_alias_abstract_declarator
2401                 {
2402                         $$ = $2;
2403                         bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2404                 }
2405         ;
2406
2407 direct_alias_abstract_declarator:
2408                 /* empty */
2409                 {
2410                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2411                         $$->u.field_class_declarator.type = TYPEDEC_ID;
2412                         /* id is NULL */
2413                 }
2414         |       CTF_LPAREN alias_abstract_declarator CTF_RPAREN
2415                 {
2416                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2417                         $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2418                         $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2419                 }
2420         |       direct_alias_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2421                 {
2422                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
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);
2427                 }
2428         |       direct_alias_abstract_declarator CTF_LSBRAC CTF_RSBRAC
2429                 {
2430                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
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;
2434                 }
2435         ;
2436
2437 declarator:
2438                 direct_declarator
2439                 {       $$ = $1;        }
2440         |       pointer direct_declarator
2441                 {
2442                         $$ = $2;
2443                         bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2444                 }
2445         ;
2446
2447 direct_declarator:
2448                 IDENTIFIER
2449                 {
2450                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2451                         $$->u.field_class_declarator.type = TYPEDEC_ID;
2452                         $$->u.field_class_declarator.u.id = $1;
2453                 }
2454         |       CTF_LPAREN declarator CTF_RPAREN
2455                 {
2456                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2457                         $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2458                         $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2459                 }
2460         |       direct_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2461                 {
2462                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
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);
2467                 }
2468         ;
2469
2470 field_class_declarator:
2471                 direct_field_class_declarator
2472                 {       $$ = $1;        }
2473         |       pointer direct_field_class_declarator
2474                 {
2475                         $$ = $2;
2476                         bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2477                 }
2478         ;
2479
2480 direct_field_class_declarator:
2481                 IDENTIFIER
2482                 {
2483                         add_type(scanner, $1);
2484                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2485                         $$->u.field_class_declarator.type = TYPEDEC_ID;
2486                         $$->u.field_class_declarator.u.id = $1;
2487                 }
2488         |       CTF_LPAREN field_class_declarator CTF_RPAREN
2489                 {
2490                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2491                         $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2492                         $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2493                 }
2494         |       direct_field_class_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2495                 {
2496                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
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);
2501                 }
2502         ;
2503
2504 pointer:
2505                 CTF_STAR
2506                 {
2507                         $$ = make_node(scanner, NODE_POINTER);
2508                 }
2509         |       CTF_STAR pointer
2510                 {
2511                         $$ = make_node(scanner, NODE_POINTER);
2512                         bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
2513                 }
2514         |       CTF_STAR type_qualifier_list pointer
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
2522 type_qualifier_list:
2523                 /* pointer assumes only const type qualifier */
2524                 CTF_CONST
2525         |       type_qualifier_list CTF_CONST
2526         ;
2527
2528 /* 2.3: CTF-specific declarations */
2529
2530 ctf_assignment_expression_list:
2531                 ctf_assignment_expression CTF_SEMICOLON
2532                 {       $$ = $1;        }
2533         |       ctf_assignment_expression_list ctf_assignment_expression CTF_SEMICOLON
2534                 {
2535                         $$ = $1;
2536                         bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2537                 }
2538         ;
2539
2540 ctf_assignment_expression:
2541                 unary_expression CTF_EQUAL unary_expression
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                 }
2553         |       unary_expression CTF_TYPEASSIGN declaration_specifiers  /* Only allow struct */
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                 }
2565         |       declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list
2566                 {
2567                         struct ctf_node *list;
2568
2569                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
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);
2572                         $$ = make_node(scanner, NODE_TYPEDEF);
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);
2575                 }
2576         |       CTF_TYPEDEF declaration_specifiers field_class_declarator_list
2577                 {
2578                         struct ctf_node *list;
2579
2580                         $$ = make_node(scanner, NODE_TYPEDEF);
2581                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
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);
2585                 }
2586         |       declaration_specifiers CTF_TYPEDEF field_class_declarator_list
2587                 {
2588                         struct ctf_node *list;
2589
2590                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2591                         _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2592                         $$ = make_node(scanner, NODE_TYPEDEF);
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);
2595                 }
2596         |       CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
2597                 {
2598                         struct ctf_node *list;
2599
2600                         $$ = make_node(scanner, NODE_TYPEALIAS);
2601                         $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2602                         $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2603
2604                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
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);
2608
2609                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
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);
2613                 }
2614         ;