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