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

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