plugins/ctf/common/metadata/parser.y

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