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

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