src/plugins/ctf/common/src/metadata/tsdl/parser.ypp

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