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