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

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