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  * The bison-provided version of strlen (yystrlen) generates a benign
1041  * -Wnull-dereference warning.  That version is used when building on cygwin,
1042  * for example, but you can also enable it by hand (to test) by removing the
1043  * preprocessor conditional around it.
1044  *
1045  * Define yystrlen such that it will always use strlen.  As far as we know,
1046  * strlen provided by all the platforms we use is reliable.
1047  */
1048 #define yystrlen strlen
1049
1050 %}
1051
1052 /*
1053  * This ends up in parser.h and makes sure those who want to include it pass
1054  * through parser-wrap.h.
1055  */
1056 %code requires {
1057 #ifndef ALLOW_INCLUDE_PARSER_H
1058 # error "Don't include parser.h directly, include parser-wrap.h instead."
1059 #endif
1060 }
1061
1062
1063 %define api.pure
1064         /* %locations */
1065 %error-verbose
1066 %parse-param {struct ctf_scanner *scanner}
1067 %parse-param {yyscan_t yyscanner}
1068 %lex-param {yyscan_t yyscanner}
1069 /*
1070  * Expect two shift-reduce conflicts. Caused by enum name-opt : type {}
1071  * vs struct { int :value; } (unnamed bit-field). The default is to
1072  * shift, so whenever we encounter an enumeration, we are doing the
1073  * proper thing (shift). It is illegal to declare an enumeration
1074  * "bit-field", so it is OK if this situation ends up in a parsing
1075  * error.
1076  */
1077 %expect 2
1078 %start file
1079 %token CTF_INTEGER_LITERAL CTF_STRING_LITERAL CTF_CHARACTER_LITERAL CTF_LSBRAC CTF_RSBRAC CTF_LPAREN CTF_RPAREN CTF_LBRAC CTF_RBRAC CTF_RARROW CTF_STAR CTF_PLUS CTF_MINUS CTF_LT CTF_GT CTF_TYPEASSIGN CTF_COLON CTF_SEMICOLON CTF_DOTDOTDOT CTF_DOT CTF_EQUAL CTF_COMMA CTF_CONST CTF_CHAR CTF_DOUBLE CTF_ENUM CTF_ENV CTF_EVENT CTF_FLOATING_POINT CTF_FLOAT CTF_INTEGER CTF_INT CTF_LONG CTF_SHORT CTF_SIGNED CTF_STREAM CTF_STRING CTF_STRUCT CTF_TRACE CTF_CALLSITE CTF_CLOCK CTF_TYPEALIAS CTF_TYPEDEF CTF_UNSIGNED CTF_VARIANT CTF_VOID CTF_BOOL CTF_COMPLEX CTF_IMAGINARY CTF_TOK_ALIGN
1080 %token <s> IDENTIFIER ID_TYPE
1081 %token CTF_ERROR
1082 %union
1083 {
1084         long long ll;
1085         unsigned long long ull;
1086         char c;
1087         char *s;
1088         struct ctf_node *n;
1089 }
1090
1091 %type <s> CTF_STRING_LITERAL CTF_CHARACTER_LITERAL
1092
1093 %type <s> keywords
1094
1095 %type <ull> CTF_INTEGER_LITERAL
1096 %type <n> postfix_expression unary_expression unary_expression_or_range
1097
1098 %type <n> declaration
1099 %type <n> event_declaration
1100 %type <n> stream_declaration
1101 %type <n> env_declaration
1102 %type <n> trace_declaration
1103 %type <n> clock_declaration
1104 %type <n> callsite_declaration
1105 %type <n> integer_declaration_specifiers
1106 %type <n> declaration_specifiers
1107 %type <n> alias_declaration_specifiers
1108
1109 %type <n> field_class_declarator_list
1110 %type <n> integer_field_class_specifier
1111 %type <n> field_class_specifier
1112 %type <n> struct_class_specifier
1113 %type <n> variant_field_class_specifier
1114 %type <n> enum_field_class_specifier
1115 %type <n> struct_or_variant_declaration_list
1116 %type <n> struct_or_variant_declaration
1117 %type <n> struct_or_variant_declarator_list
1118 %type <n> struct_or_variant_declarator
1119 %type <n> enumerator_list
1120 %type <n> enumerator
1121 %type <n> abstract_declarator_list
1122 %type <n> abstract_declarator
1123 %type <n> direct_abstract_declarator
1124 %type <n> alias_abstract_declarator_list
1125 %type <n> alias_abstract_declarator
1126 %type <n> direct_alias_abstract_declarator
1127 %type <n> declarator
1128 %type <n> direct_declarator
1129 %type <n> field_class_declarator
1130 %type <n> direct_field_class_declarator
1131 %type <n> pointer
1132 %type <n> ctf_assignment_expression_list
1133 %type <n> ctf_assignment_expression
1134
1135 %%
1136
1137 file:
1138                 declaration
1139                 {
1140                         if (set_parent_node($1, &ctf_scanner_get_ast(scanner)->root))
1141                                 reparent_error(scanner, "error reparenting to root");
1142                 }
1143         |       file declaration
1144                 {
1145                         if (set_parent_node($2, &ctf_scanner_get_ast(scanner)->root))
1146                                 reparent_error(scanner, "error reparenting to root");
1147                 }
1148         ;
1149
1150 keywords:
1151                 CTF_VOID
1152                 {       $$ = yylval.s;          }
1153         |       CTF_CHAR
1154                 {       $$ = yylval.s;          }
1155         |       CTF_SHORT
1156                 {       $$ = yylval.s;          }
1157         |       CTF_INT
1158                 {       $$ = yylval.s;          }
1159         |       CTF_LONG
1160                 {       $$ = yylval.s;          }
1161         |       CTF_FLOAT
1162                 {       $$ = yylval.s;          }
1163         |       CTF_DOUBLE
1164                 {       $$ = yylval.s;          }
1165         |       CTF_SIGNED
1166                 {       $$ = yylval.s;          }
1167         |       CTF_UNSIGNED
1168                 {       $$ = yylval.s;          }
1169         |       CTF_BOOL
1170                 {       $$ = yylval.s;          }
1171         |       CTF_COMPLEX
1172                 {       $$ = yylval.s;          }
1173         |       CTF_IMAGINARY
1174                 {       $$ = yylval.s;          }
1175         |       CTF_FLOATING_POINT
1176                 {       $$ = yylval.s;          }
1177         |       CTF_INTEGER
1178                 {       $$ = yylval.s;          }
1179         |       CTF_STRING
1180                 {       $$ = yylval.s;          }
1181         |       CTF_ENUM
1182                 {       $$ = yylval.s;          }
1183         |       CTF_VARIANT
1184                 {       $$ = yylval.s;          }
1185         |       CTF_STRUCT
1186                 {       $$ = yylval.s;          }
1187         |       CTF_CONST
1188                 {       $$ = yylval.s;          }
1189         |       CTF_TYPEDEF
1190                 {       $$ = yylval.s;          }
1191         |       CTF_EVENT
1192                 {       $$ = yylval.s;          }
1193         |       CTF_STREAM
1194                 {       $$ = yylval.s;          }
1195         |       CTF_ENV
1196                 {       $$ = yylval.s;          }
1197         |       CTF_TRACE
1198                 {       $$ = yylval.s;          }
1199         |       CTF_CLOCK
1200                 {       $$ = yylval.s;          }
1201         |       CTF_CALLSITE
1202                 {       $$ = yylval.s;          }
1203         |       CTF_TOK_ALIGN
1204                 {       $$ = yylval.s;          }
1205         ;
1206
1207
1208 /* 2: Phrase structure grammar */
1209
1210 postfix_expression:
1211                 IDENTIFIER
1212                 {
1213                         $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1214                         $$->u.unary_expression.type = UNARY_STRING;
1215                         $$->u.unary_expression.u.string = yylval.s;
1216                 }
1217         |       ID_TYPE
1218                 {
1219                         $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1220                         $$->u.unary_expression.type = UNARY_STRING;
1221                         $$->u.unary_expression.u.string = yylval.s;
1222                 }
1223         |       keywords
1224                 {
1225                         $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1226                         $$->u.unary_expression.type = UNARY_STRING;
1227                         $$->u.unary_expression.u.string = yylval.s;
1228                 }
1229         |       CTF_INTEGER_LITERAL
1230                 {
1231                         $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1232                         $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
1233                         $$->u.unary_expression.u.unsigned_constant = $1;
1234                 }
1235         |       CTF_STRING_LITERAL
1236                 {
1237                         $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1238                         $$->u.unary_expression.type = UNARY_STRING;
1239                         $$->u.unary_expression.u.string = $1;
1240                 }
1241         |       CTF_CHARACTER_LITERAL
1242                 {
1243                         $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1244                         $$->u.unary_expression.type = UNARY_STRING;
1245                         $$->u.unary_expression.u.string = $1;
1246                 }
1247         |       CTF_LPAREN unary_expression CTF_RPAREN
1248                 {
1249                         $$ = $2;
1250                 }
1251         |       postfix_expression CTF_LSBRAC unary_expression CTF_RSBRAC
1252                 {
1253                         $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1254                         $$->u.unary_expression.type = UNARY_SBRAC;
1255                         $$->u.unary_expression.u.sbrac_exp = $3;
1256                         bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1257                         bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1258                 }
1259         |       postfix_expression CTF_DOT IDENTIFIER
1260                 {
1261                         $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1262                         $$->u.unary_expression.type = UNARY_STRING;
1263                         $$->u.unary_expression.u.string = yylval.s;
1264                         $$->u.unary_expression.link = UNARY_DOTLINK;
1265                         bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1266                         bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1267                 }
1268         |       postfix_expression CTF_DOT ID_TYPE
1269                 {
1270                         $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1271                         $$->u.unary_expression.type = UNARY_STRING;
1272                         $$->u.unary_expression.u.string = yylval.s;
1273                         $$->u.unary_expression.link = UNARY_DOTLINK;
1274                         bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1275                         bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1276                 }
1277         |       postfix_expression CTF_DOT keywords
1278                 {
1279                         $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1280                         $$->u.unary_expression.type = UNARY_STRING;
1281                         $$->u.unary_expression.u.string = yylval.s;
1282                         $$->u.unary_expression.link = UNARY_DOTLINK;
1283                         bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1284                         bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1285                 }
1286         |       postfix_expression CTF_RARROW IDENTIFIER
1287                 {
1288                         $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1289                         $$->u.unary_expression.type = UNARY_STRING;
1290                         $$->u.unary_expression.u.string = yylval.s;
1291                         $$->u.unary_expression.link = UNARY_ARROWLINK;
1292                         bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1293                         bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1294                 }
1295         |       postfix_expression CTF_RARROW ID_TYPE
1296                 {
1297                         $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
1298                         $$->u.unary_expression.type = UNARY_STRING;
1299                         $$->u.unary_expression.u.string = yylval.s;
1300                         $$->u.unary_expression.link = UNARY_ARROWLINK;
1301                         bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
1302                         bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
1303                 }
1304         ;
1305
1306 unary_expression:
1307                 postfix_expression
1308                 {       $$ = $1;                                }
1309         |       CTF_PLUS postfix_expression
1310                 {
1311                         $$ = $2;
1312                         if ($$->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT
1313                                 && $$->u.unary_expression.type != UNARY_SIGNED_CONSTANT) {
1314                                 reparent_error(scanner, "expecting numeric constant");
1315                         }
1316                 }
1317         |       CTF_MINUS postfix_expression
1318                 {
1319                         $$ = $2;
1320                         if ($$->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT) {
1321                                 $$->u.unary_expression.type = UNARY_SIGNED_CONSTANT;
1322                                 $$->u.unary_expression.u.signed_constant =
1323                                         -($$->u.unary_expression.u.unsigned_constant);
1324                         } else if ($$->u.unary_expression.type == UNARY_SIGNED_CONSTANT) {
1325                                 $$->u.unary_expression.u.signed_constant =
1326                                         -($$->u.unary_expression.u.signed_constant);
1327                         } else {
1328                                 reparent_error(scanner, "expecting numeric constant");
1329                         }
1330                 }
1331         ;
1332
1333 unary_expression_or_range:
1334                 unary_expression CTF_DOTDOTDOT unary_expression
1335                 {
1336                         $$ = $1;
1337                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
1338                         $3->u.unary_expression.link = UNARY_DOTDOTDOT;
1339                 }
1340         |       unary_expression
1341                 {       $$ = $1;                }
1342         ;
1343
1344 /* 2.2: Declarations */
1345
1346 declaration:
1347                 declaration_specifiers CTF_SEMICOLON
1348                 {       $$ = $1;        }
1349         |       event_declaration
1350                 {       $$ = $1;        }
1351         |       stream_declaration
1352                 {       $$ = $1;        }
1353         |       env_declaration
1354                 {       $$ = $1;        }
1355         |       trace_declaration
1356                 {       $$ = $1;        }
1357         |       clock_declaration
1358                 {       $$ = $1;        }
1359         |       callsite_declaration
1360                 {       $$ = $1;        }
1361         |       declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
1362                 {
1363                         struct ctf_node *list;
1364
1365                         $$ = make_node(scanner, NODE_TYPEDEF);
1366                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1367                         $$->u.field_class_def.field_class_specifier_list = list;
1368                         _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1369                         _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1370                         _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1371                 }
1372         |       CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
1373                 {
1374                         struct ctf_node *list;
1375
1376                         $$ = make_node(scanner, NODE_TYPEDEF);
1377                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1378                         $$->u.field_class_def.field_class_specifier_list = list;
1379                         _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1380                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1381                 }
1382         |       declaration_specifiers CTF_TYPEDEF field_class_declarator_list CTF_SEMICOLON
1383                 {
1384                         struct ctf_node *list;
1385
1386                         $$ = make_node(scanner, NODE_TYPEDEF);
1387                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1388                         $$->u.field_class_def.field_class_specifier_list = list;
1389                         _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1390                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
1391                 }
1392         |       CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
1393                 {
1394                         struct ctf_node *list;
1395
1396                         $$ = make_node(scanner, NODE_TYPEALIAS);
1397                         $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
1398                         $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
1399
1400                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1401                         $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
1402                         _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1403                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
1404
1405                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1406                         $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
1407                         _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
1408                         _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
1409                 }
1410         ;
1411
1412 event_declaration:
1413                 event_declaration_begin event_declaration_end
1414                 {
1415                         $$ = make_node(scanner, NODE_EVENT);
1416                 }
1417         |       event_declaration_begin ctf_assignment_expression_list event_declaration_end
1418                 {
1419                         $$ = make_node(scanner, NODE_EVENT);
1420                         if (set_parent_node($2, $$))
1421                                 reparent_error(scanner, "event_declaration");
1422                 }
1423         ;
1424
1425 event_declaration_begin:
1426                 CTF_EVENT CTF_LBRAC
1427                 {       push_scope(scanner);    }
1428         ;
1429
1430 event_declaration_end:
1431                 CTF_RBRAC CTF_SEMICOLON
1432                 {       pop_scope(scanner);     }
1433         ;
1434
1435
1436 stream_declaration:
1437                 stream_declaration_begin stream_declaration_end
1438                 {
1439                         $$ = make_node(scanner, NODE_STREAM);
1440                 }
1441         |       stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
1442                 {
1443                         $$ = make_node(scanner, NODE_STREAM);
1444                         if (set_parent_node($2, $$))
1445                                 reparent_error(scanner, "stream_declaration");
1446                 }
1447         ;
1448
1449 stream_declaration_begin:
1450                 CTF_STREAM CTF_LBRAC
1451                 {       push_scope(scanner);    }
1452         ;
1453
1454 stream_declaration_end:
1455                 CTF_RBRAC CTF_SEMICOLON
1456                 {       pop_scope(scanner);     }
1457         ;
1458
1459 env_declaration:
1460                 env_declaration_begin env_declaration_end
1461                 {
1462                         $$ = make_node(scanner, NODE_ENV);
1463                 }
1464         |       env_declaration_begin ctf_assignment_expression_list env_declaration_end
1465                 {
1466                         $$ = make_node(scanner, NODE_ENV);
1467                         if (set_parent_node($2, $$))
1468                                 reparent_error(scanner, "env declaration");
1469                 }
1470         ;
1471
1472 env_declaration_begin:
1473                 CTF_ENV CTF_LBRAC
1474                 {       push_scope(scanner);    }
1475         ;
1476
1477 env_declaration_end:
1478                 CTF_RBRAC CTF_SEMICOLON
1479                 {       pop_scope(scanner);     }
1480         ;
1481
1482 trace_declaration:
1483                 trace_declaration_begin trace_declaration_end
1484                 {
1485                         $$ = make_node(scanner, NODE_TRACE);
1486                 }
1487         |       trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
1488                 {
1489                         $$ = make_node(scanner, NODE_TRACE);
1490                         if (set_parent_node($2, $$))
1491                                 reparent_error(scanner, "trace_declaration");
1492                 }
1493         ;
1494
1495 trace_declaration_begin:
1496                 CTF_TRACE CTF_LBRAC
1497                 {       push_scope(scanner);    }
1498         ;
1499
1500 trace_declaration_end:
1501                 CTF_RBRAC CTF_SEMICOLON
1502                 {       pop_scope(scanner);     }
1503         ;
1504
1505 clock_declaration:
1506                 CTF_CLOCK clock_declaration_begin clock_declaration_end
1507                 {
1508                         $$ = make_node(scanner, NODE_CLOCK);
1509                 }
1510         |       CTF_CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
1511                 {
1512                         $$ = make_node(scanner, NODE_CLOCK);
1513                         if (set_parent_node($3, $$))
1514                                 reparent_error(scanner, "trace_declaration");
1515                 }
1516         ;
1517
1518 clock_declaration_begin:
1519                 CTF_LBRAC
1520                 {       push_scope(scanner);    }
1521         ;
1522
1523 clock_declaration_end:
1524                 CTF_RBRAC CTF_SEMICOLON
1525                 {       pop_scope(scanner);     }
1526         ;
1527
1528 callsite_declaration:
1529                 CTF_CALLSITE callsite_declaration_begin callsite_declaration_end
1530                 {
1531                         $$ = make_node(scanner, NODE_CALLSITE);
1532                 }
1533         |       CTF_CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
1534                 {
1535                         $$ = make_node(scanner, NODE_CALLSITE);
1536                         if (set_parent_node($3, $$))
1537                                 reparent_error(scanner, "trace_declaration");
1538                 }
1539         ;
1540
1541 callsite_declaration_begin:
1542                 CTF_LBRAC
1543                 {       push_scope(scanner);    }
1544         ;
1545
1546 callsite_declaration_end:
1547                 CTF_RBRAC CTF_SEMICOLON
1548                 {       pop_scope(scanner);     }
1549         ;
1550
1551 integer_declaration_specifiers:
1552                 CTF_CONST
1553                 {
1554                         struct ctf_node *node;
1555
1556                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1557                         node = make_node(scanner, NODE_TYPE_SPECIFIER);
1558                         node->u.field_class_specifier.type = TYPESPEC_CONST;
1559                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1560                 }
1561         |       integer_field_class_specifier
1562                 {
1563                         struct ctf_node *node;
1564
1565                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1566                         node = $1;
1567                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1568                 }
1569         |       integer_declaration_specifiers CTF_CONST
1570                 {
1571                         struct ctf_node *node;
1572
1573                         $$ = $1;
1574                         node = make_node(scanner, NODE_TYPE_SPECIFIER);
1575                         node->u.field_class_specifier.type = TYPESPEC_CONST;
1576                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1577                 }
1578         |       integer_declaration_specifiers integer_field_class_specifier
1579                 {
1580                         $$ = $1;
1581                         bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
1582                 }
1583         ;
1584
1585 declaration_specifiers:
1586                 CTF_CONST
1587                 {
1588                         struct ctf_node *node;
1589
1590                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1591                         node = make_node(scanner, NODE_TYPE_SPECIFIER);
1592                         node->u.field_class_specifier.type = TYPESPEC_CONST;
1593                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1594                 }
1595         |       field_class_specifier
1596                 {
1597                         struct ctf_node *node;
1598
1599                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
1600                         node = $1;
1601                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1602                 }
1603         |       declaration_specifiers CTF_CONST
1604                 {
1605                         struct ctf_node *node;
1606
1607                         $$ = $1;
1608                         node = make_node(scanner, NODE_TYPE_SPECIFIER);
1609                         node->u.field_class_specifier.type = TYPESPEC_CONST;
1610                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
1611                 }
1612         |       declaration_specifiers field_class_specifier
1613                 {
1614                         $$ = $1;
1615                         bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
1616                 }
1617         ;
1618
1619 field_class_declarator_list:
1620                 field_class_declarator
1621                 {       $$ = $1;        }
1622         |       field_class_declarator_list CTF_COMMA field_class_declarator
1623                 {
1624                         $$ = $1;
1625                         bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
1626                 }
1627         ;
1628
1629 integer_field_class_specifier:
1630                 CTF_CHAR
1631                 {
1632                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1633                         $$->u.field_class_specifier.type = TYPESPEC_CHAR;
1634                 }
1635         |       CTF_SHORT
1636                 {
1637                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1638                         $$->u.field_class_specifier.type = TYPESPEC_SHORT;
1639                 }
1640         |       CTF_INT
1641                 {
1642                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1643                         $$->u.field_class_specifier.type = TYPESPEC_INT;
1644                 }
1645         |       CTF_LONG
1646                 {
1647                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1648                         $$->u.field_class_specifier.type = TYPESPEC_LONG;
1649                 }
1650         |       CTF_SIGNED
1651                 {
1652                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1653                         $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
1654                 }
1655         |       CTF_UNSIGNED
1656                 {
1657                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1658                         $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
1659                 }
1660         |       CTF_BOOL
1661                 {
1662                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1663                         $$->u.field_class_specifier.type = TYPESPEC_BOOL;
1664                 }
1665         |       ID_TYPE
1666                 {
1667                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1668                         $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
1669                         $$->u.field_class_specifier.id_type = yylval.s;
1670                 }
1671         |       CTF_INTEGER CTF_LBRAC CTF_RBRAC
1672                 {
1673                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1674                         $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1675                         $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1676                 }
1677         |       CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1678                 {
1679                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1680                         $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1681                         $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1682                         if (set_parent_node($3, $$->u.field_class_specifier.node))
1683                                 reparent_error(scanner, "integer reparent error");
1684                 }
1685         ;
1686
1687 field_class_specifier:
1688                 CTF_VOID
1689                 {
1690                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1691                         $$->u.field_class_specifier.type = TYPESPEC_VOID;
1692                 }
1693         |       CTF_CHAR
1694                 {
1695                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1696                         $$->u.field_class_specifier.type = TYPESPEC_CHAR;
1697                 }
1698         |       CTF_SHORT
1699                 {
1700                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1701                         $$->u.field_class_specifier.type = TYPESPEC_SHORT;
1702                 }
1703         |       CTF_INT
1704                 {
1705                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1706                         $$->u.field_class_specifier.type = TYPESPEC_INT;
1707                 }
1708         |       CTF_LONG
1709                 {
1710                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1711                         $$->u.field_class_specifier.type = TYPESPEC_LONG;
1712                 }
1713         |       CTF_FLOAT
1714                 {
1715                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1716                         $$->u.field_class_specifier.type = TYPESPEC_FLOAT;
1717                 }
1718         |       CTF_DOUBLE
1719                 {
1720                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1721                         $$->u.field_class_specifier.type = TYPESPEC_DOUBLE;
1722                 }
1723         |       CTF_SIGNED
1724                 {
1725                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1726                         $$->u.field_class_specifier.type = TYPESPEC_SIGNED;
1727                 }
1728         |       CTF_UNSIGNED
1729                 {
1730                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1731                         $$->u.field_class_specifier.type = TYPESPEC_UNSIGNED;
1732                 }
1733         |       CTF_BOOL
1734                 {
1735                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1736                         $$->u.field_class_specifier.type = TYPESPEC_BOOL;
1737                 }
1738         |       CTF_COMPLEX
1739                 {
1740                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1741                         $$->u.field_class_specifier.type = TYPESPEC_COMPLEX;
1742                 }
1743         |       CTF_IMAGINARY
1744                 {
1745                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1746                         $$->u.field_class_specifier.type = TYPESPEC_IMAGINARY;
1747                 }
1748         |       ID_TYPE
1749                 {
1750                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1751                         $$->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
1752                         $$->u.field_class_specifier.id_type = yylval.s;
1753                 }
1754         |       CTF_FLOATING_POINT CTF_LBRAC CTF_RBRAC
1755                 {
1756                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1757                         $$->u.field_class_specifier.type = TYPESPEC_FLOATING_POINT;
1758                         $$->u.field_class_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1759                 }
1760         |       CTF_FLOATING_POINT CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1761                 {
1762                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1763                         $$->u.field_class_specifier.type = TYPESPEC_FLOATING_POINT;
1764                         $$->u.field_class_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
1765                         if (set_parent_node($3, $$->u.field_class_specifier.node))
1766                                 reparent_error(scanner, "floating point reparent error");
1767                 }
1768         |       CTF_INTEGER CTF_LBRAC CTF_RBRAC
1769                 {
1770                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1771                         $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1772                         $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1773                 }
1774         |       CTF_INTEGER CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1775                 {
1776                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1777                         $$->u.field_class_specifier.type = TYPESPEC_INTEGER;
1778                         $$->u.field_class_specifier.node = make_node(scanner, NODE_INTEGER);
1779                         if (set_parent_node($3, $$->u.field_class_specifier.node))
1780                                 reparent_error(scanner, "integer reparent error");
1781                 }
1782         |       CTF_STRING
1783                 {
1784                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1785                         $$->u.field_class_specifier.type = TYPESPEC_STRING;
1786                         $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1787                 }
1788         |       CTF_STRING CTF_LBRAC CTF_RBRAC
1789                 {
1790                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1791                         $$->u.field_class_specifier.type = TYPESPEC_STRING;
1792                         $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1793                 }
1794         |       CTF_STRING CTF_LBRAC ctf_assignment_expression_list CTF_RBRAC
1795                 {
1796                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1797                         $$->u.field_class_specifier.type = TYPESPEC_STRING;
1798                         $$->u.field_class_specifier.node = make_node(scanner, NODE_STRING);
1799                         if (set_parent_node($3, $$->u.field_class_specifier.node))
1800                                 reparent_error(scanner, "string reparent error");
1801                 }
1802         |       CTF_ENUM enum_field_class_specifier
1803                 {
1804                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1805                         $$->u.field_class_specifier.type = TYPESPEC_ENUM;
1806                         $$->u.field_class_specifier.node = $2;
1807                 }
1808         |       CTF_VARIANT variant_field_class_specifier
1809                 {
1810                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1811                         $$->u.field_class_specifier.type = TYPESPEC_VARIANT;
1812                         $$->u.field_class_specifier.node = $2;
1813                 }
1814         |       CTF_STRUCT struct_class_specifier
1815                 {
1816                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
1817                         $$->u.field_class_specifier.type = TYPESPEC_STRUCT;
1818                         $$->u.field_class_specifier.node = $2;
1819                 }
1820         ;
1821
1822 struct_class_specifier:
1823                 struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1824                 {
1825                         $$ = make_node(scanner, NODE_STRUCT);
1826                         $$->u._struct.has_body = 1;
1827                         if ($2 && set_parent_node($2, $$))
1828                                 reparent_error(scanner, "struct reparent error");
1829                 }
1830         |       IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1831                 {
1832                         $$ = make_node(scanner, NODE_STRUCT);
1833                         $$->u._struct.has_body = 1;
1834                         $$->u._struct.name = $1;
1835                         if ($3 && set_parent_node($3, $$))
1836                                 reparent_error(scanner, "struct reparent error");
1837                 }
1838         |       ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
1839                 {
1840                         $$ = make_node(scanner, NODE_STRUCT);
1841                         $$->u._struct.has_body = 1;
1842                         $$->u._struct.name = $1;
1843                         if ($3 && set_parent_node($3, $$))
1844                                 reparent_error(scanner, "struct reparent error");
1845                 }
1846         |       IDENTIFIER
1847                 {
1848                         $$ = make_node(scanner, NODE_STRUCT);
1849                         $$->u._struct.has_body = 0;
1850                         $$->u._struct.name = $1;
1851                 }
1852         |       ID_TYPE
1853                 {
1854                         $$ = make_node(scanner, NODE_STRUCT);
1855                         $$->u._struct.has_body = 0;
1856                         $$->u._struct.name = $1;
1857                 }
1858         |       struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1859                 {
1860                         $$ = make_node(scanner, NODE_STRUCT);
1861                         $$->u._struct.has_body = 1;
1862                         bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
1863                         if ($2 && set_parent_node($2, $$))
1864                                 reparent_error(scanner, "struct reparent error");
1865                 }
1866         |       IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1867                 {
1868                         $$ = make_node(scanner, NODE_STRUCT);
1869                         $$->u._struct.has_body = 1;
1870                         $$->u._struct.name = $1;
1871                         bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1872                         if ($3 && set_parent_node($3, $$))
1873                                 reparent_error(scanner, "struct reparent error");
1874                 }
1875         |       ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end CTF_TOK_ALIGN CTF_LPAREN unary_expression CTF_RPAREN
1876                 {
1877                         $$ = make_node(scanner, NODE_STRUCT);
1878                         $$->u._struct.has_body = 1;
1879                         $$->u._struct.name = $1;
1880                         bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
1881                         if ($3 && set_parent_node($3, $$))
1882                                 reparent_error(scanner, "struct reparent error");
1883                 }
1884         ;
1885
1886 struct_declaration_begin:
1887                 CTF_LBRAC
1888                 {       push_scope(scanner);    }
1889         ;
1890
1891 struct_declaration_end:
1892                 CTF_RBRAC
1893                 {       pop_scope(scanner);     }
1894         ;
1895
1896 variant_field_class_specifier:
1897                 variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1898                 {
1899                         $$ = make_node(scanner, NODE_VARIANT);
1900                         $$->u.variant.has_body = 1;
1901                         if ($2 && set_parent_node($2, $$))
1902                                 reparent_error(scanner, "variant reparent error");
1903                 }
1904         |       CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1905                 {
1906                         $$ = make_node(scanner, NODE_VARIANT);
1907                         $$->u.variant.has_body = 1;
1908                         $$->u.variant.choice = $2;
1909                         if ($5 && set_parent_node($5, $$))
1910                                 reparent_error(scanner, "variant reparent error");
1911                 }
1912         |       CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1913                 {
1914                         $$ = make_node(scanner, NODE_VARIANT);
1915                         $$->u.variant.has_body = 1;
1916                         $$->u.variant.choice = $2;
1917                         if ($5 && set_parent_node($5, $$))
1918                                 reparent_error(scanner, "variant reparent error");
1919                 }
1920         |       IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1921                 {
1922                         $$ = make_node(scanner, NODE_VARIANT);
1923                         $$->u.variant.has_body = 1;
1924                         $$->u.variant.name = $1;
1925                         if ($3 && set_parent_node($3, $$))
1926                                 reparent_error(scanner, "variant reparent error");
1927                 }
1928         |       IDENTIFIER CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1929                 {
1930                         $$ = make_node(scanner, NODE_VARIANT);
1931                         $$->u.variant.has_body = 1;
1932                         $$->u.variant.name = $1;
1933                         $$->u.variant.choice = $3;
1934                         if ($6 && set_parent_node($6, $$))
1935                                 reparent_error(scanner, "variant reparent error");
1936                 }
1937         |       IDENTIFIER CTF_LT IDENTIFIER CTF_GT
1938                 {
1939                         $$ = make_node(scanner, NODE_VARIANT);
1940                         $$->u.variant.has_body = 0;
1941                         $$->u.variant.name = $1;
1942                         $$->u.variant.choice = $3;
1943                 }
1944         |       IDENTIFIER CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1945                 {
1946                         $$ = make_node(scanner, NODE_VARIANT);
1947                         $$->u.variant.has_body = 1;
1948                         $$->u.variant.name = $1;
1949                         $$->u.variant.choice = $3;
1950                         if ($6 && set_parent_node($6, $$))
1951                                 reparent_error(scanner, "variant reparent error");
1952                 }
1953         |       IDENTIFIER CTF_LT ID_TYPE CTF_GT
1954                 {
1955                         $$ = make_node(scanner, NODE_VARIANT);
1956                         $$->u.variant.has_body = 0;
1957                         $$->u.variant.name = $1;
1958                         $$->u.variant.choice = $3;
1959                 }
1960         |       ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1961                 {
1962                         $$ = make_node(scanner, NODE_VARIANT);
1963                         $$->u.variant.has_body = 1;
1964                         $$->u.variant.name = $1;
1965                         if ($3 && set_parent_node($3, $$))
1966                                 reparent_error(scanner, "variant reparent error");
1967                 }
1968         |       ID_TYPE CTF_LT IDENTIFIER CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1969                 {
1970                         $$ = make_node(scanner, NODE_VARIANT);
1971                         $$->u.variant.has_body = 1;
1972                         $$->u.variant.name = $1;
1973                         $$->u.variant.choice = $3;
1974                         if ($6 && set_parent_node($6, $$))
1975                                 reparent_error(scanner, "variant reparent error");
1976                 }
1977         |       ID_TYPE CTF_LT IDENTIFIER CTF_GT
1978                 {
1979                         $$ = make_node(scanner, NODE_VARIANT);
1980                         $$->u.variant.has_body = 0;
1981                         $$->u.variant.name = $1;
1982                         $$->u.variant.choice = $3;
1983                 }
1984         |       ID_TYPE CTF_LT ID_TYPE CTF_GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
1985                 {
1986                         $$ = make_node(scanner, NODE_VARIANT);
1987                         $$->u.variant.has_body = 1;
1988                         $$->u.variant.name = $1;
1989                         $$->u.variant.choice = $3;
1990                         if ($6 && set_parent_node($6, $$))
1991                                 reparent_error(scanner, "variant reparent error");
1992                 }
1993         |       ID_TYPE CTF_LT ID_TYPE CTF_GT
1994                 {
1995                         $$ = make_node(scanner, NODE_VARIANT);
1996                         $$->u.variant.has_body = 0;
1997                         $$->u.variant.name = $1;
1998                         $$->u.variant.choice = $3;
1999                 }
2000         ;
2001
2002 variant_declaration_begin:
2003                 CTF_LBRAC
2004                 {       push_scope(scanner);    }
2005         ;
2006
2007 variant_declaration_end:
2008                 CTF_RBRAC
2009                 {       pop_scope(scanner);     }
2010         ;
2011
2012 enum_field_class_specifier:
2013                 CTF_LBRAC enumerator_list CTF_RBRAC
2014                 {
2015                         $$ = make_node(scanner, NODE_ENUM);
2016                         $$->u._enum.has_body = 1;
2017                         _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
2018                 }
2019         |       CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2020                 {
2021                         $$ = make_node(scanner, NODE_ENUM);
2022                         $$->u._enum.has_body = 1;
2023                         ($$)->u._enum.container_field_class = $2;
2024                         _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2025                 }
2026         |       IDENTIFIER CTF_LBRAC enumerator_list CTF_RBRAC
2027                 {
2028                         $$ = make_node(scanner, NODE_ENUM);
2029                         $$->u._enum.has_body = 1;
2030                         $$->u._enum.enum_id = $1;
2031                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2032                 }
2033         |       IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2034                 {
2035                         $$ = make_node(scanner, NODE_ENUM);
2036                         $$->u._enum.has_body = 1;
2037                         $$->u._enum.enum_id = $1;
2038                         ($$)->u._enum.container_field_class = $3;
2039                         _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2040                 }
2041         |       ID_TYPE CTF_LBRAC enumerator_list CTF_RBRAC
2042                 {
2043                         $$ = make_node(scanner, NODE_ENUM);
2044                         $$->u._enum.has_body = 1;
2045                         $$->u._enum.enum_id = $1;
2046                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2047                 }
2048         |       ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_RBRAC
2049                 {
2050                         $$ = make_node(scanner, NODE_ENUM);
2051                         $$->u._enum.has_body = 1;
2052                         $$->u._enum.enum_id = $1;
2053                         ($$)->u._enum.container_field_class = $3;
2054                         _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2055                 }
2056         |       CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2057                 {
2058                         $$ = make_node(scanner, NODE_ENUM);
2059                         $$->u._enum.has_body = 1;
2060                         _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
2061                 }
2062         |       CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2063                 {
2064                         $$ = make_node(scanner, NODE_ENUM);
2065                         $$->u._enum.has_body = 1;
2066                         ($$)->u._enum.container_field_class = $2;
2067                         _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
2068                 }
2069         |       IDENTIFIER CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2070                 {
2071                         $$ = make_node(scanner, NODE_ENUM);
2072                         $$->u._enum.has_body = 1;
2073                         $$->u._enum.enum_id = $1;
2074                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2075                 }
2076         |       IDENTIFIER CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2077                 {
2078                         $$ = make_node(scanner, NODE_ENUM);
2079                         $$->u._enum.has_body = 1;
2080                         $$->u._enum.enum_id = $1;
2081                         ($$)->u._enum.container_field_class = $3;
2082                         _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2083                 }
2084         |       IDENTIFIER
2085                 {
2086                         $$ = make_node(scanner, NODE_ENUM);
2087                         $$->u._enum.has_body = 0;
2088                         $$->u._enum.enum_id = $1;
2089                 }
2090         |       ID_TYPE CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2091                 {
2092                         $$ = make_node(scanner, NODE_ENUM);
2093                         $$->u._enum.has_body = 1;
2094                         $$->u._enum.enum_id = $1;
2095                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
2096                 }
2097         |       ID_TYPE CTF_COLON integer_declaration_specifiers CTF_LBRAC enumerator_list CTF_COMMA CTF_RBRAC
2098                 {
2099                         $$ = make_node(scanner, NODE_ENUM);
2100                         $$->u._enum.has_body = 1;
2101                         $$->u._enum.enum_id = $1;
2102                         ($$)->u._enum.container_field_class = $3;
2103                         _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
2104                 }
2105         |       ID_TYPE
2106                 {
2107                         $$ = make_node(scanner, NODE_ENUM);
2108                         $$->u._enum.has_body = 0;
2109                         $$->u._enum.enum_id = $1;
2110                 }
2111         ;
2112
2113 struct_or_variant_declaration_list:
2114                 /* empty */
2115                 {       $$ = NULL;      }
2116         |       struct_or_variant_declaration_list struct_or_variant_declaration
2117                 {
2118                         if ($1) {
2119                                 $$ = $1;
2120                                 bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2121                         } else {
2122                                 $$ = $2;
2123                                 bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
2124                         }
2125                 }
2126         ;
2127
2128 struct_or_variant_declaration:
2129                 declaration_specifiers struct_or_variant_declarator_list CTF_SEMICOLON
2130                 {
2131                         struct ctf_node *list;
2132
2133                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2134                         _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2135                         $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
2136                         ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2137                         _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.field_class_declarators);
2138                 }
2139         |       declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
2140                 {
2141                         struct ctf_node *list;
2142
2143                         $$ = make_node(scanner, NODE_TYPEDEF);
2144                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2145                         $$->u.field_class_def.field_class_specifier_list = list;
2146                         _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2147                         _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2148                         _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2149                 }
2150         |       CTF_TYPEDEF declaration_specifiers field_class_declarator_list CTF_SEMICOLON
2151                 {
2152                         struct ctf_node *list;
2153
2154                         $$ = make_node(scanner, NODE_TYPEDEF);
2155                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2156                         $$->u.field_class_def.field_class_specifier_list = list;
2157                         _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2158                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2159                 }
2160         |       declaration_specifiers CTF_TYPEDEF field_class_declarator_list CTF_SEMICOLON
2161                 {
2162                         struct ctf_node *list;
2163
2164                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2165                         _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2166                         $$ = make_node(scanner, NODE_TYPEDEF);
2167                         ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2168                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2169                 }
2170         |       CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list CTF_SEMICOLON
2171                 {
2172                         struct ctf_node *list;
2173
2174                         $$ = make_node(scanner, NODE_TYPEALIAS);
2175                         $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2176                         $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2177
2178                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2179                         $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
2180                         _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2181                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
2182
2183                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2184                         $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
2185                         _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2186                         _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
2187                 }
2188         ;
2189
2190 alias_declaration_specifiers:
2191                 CTF_CONST
2192                 {
2193                         struct ctf_node *node;
2194
2195                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2196                         node = make_node(scanner, NODE_TYPE_SPECIFIER);
2197                         node->u.field_class_specifier.type = TYPESPEC_CONST;
2198                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2199                 }
2200         |       field_class_specifier
2201                 {
2202                         struct ctf_node *node;
2203
2204                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2205                         node = $1;
2206                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2207                 }
2208         |       IDENTIFIER
2209                 {
2210                         struct ctf_node *node;
2211
2212                         add_type(scanner, $1);
2213                         $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2214                         node = make_node(scanner, NODE_TYPE_SPECIFIER);
2215                         node->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
2216                         node->u.field_class_specifier.id_type = yylval.s;
2217                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2218                 }
2219         |       alias_declaration_specifiers CTF_CONST
2220                 {
2221                         struct ctf_node *node;
2222
2223                         $$ = $1;
2224                         node = make_node(scanner, NODE_TYPE_SPECIFIER);
2225                         node->u.field_class_specifier.type = TYPESPEC_CONST;
2226                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2227                 }
2228         |       alias_declaration_specifiers field_class_specifier
2229                 {
2230                         $$ = $1;
2231                         bt_list_add_tail(&($2)->siblings, &($$)->u.field_class_specifier_list.head);
2232                 }
2233         |       alias_declaration_specifiers IDENTIFIER
2234                 {
2235                         struct ctf_node *node;
2236
2237                         add_type(scanner, $2);
2238                         $$ = $1;
2239                         node = make_node(scanner, NODE_TYPE_SPECIFIER);
2240                         node->u.field_class_specifier.type = TYPESPEC_ID_TYPE;
2241                         node->u.field_class_specifier.id_type = yylval.s;
2242                         bt_list_add_tail(&node->siblings, &($$)->u.field_class_specifier_list.head);
2243                 }
2244         ;
2245
2246 struct_or_variant_declarator_list:
2247                 struct_or_variant_declarator
2248                 {       $$ = $1;        }
2249         |       struct_or_variant_declarator_list CTF_COMMA struct_or_variant_declarator
2250                 {
2251                         $$ = $1;
2252                         bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2253                 }
2254         ;
2255
2256 struct_or_variant_declarator:
2257                 declarator
2258                 {       $$ = $1;        }
2259         |       CTF_COLON unary_expression
2260                 {       $$ = $2;        }
2261         |       declarator CTF_COLON unary_expression
2262                 {
2263                         $$ = $1;
2264                         if (set_parent_node($3, $1))
2265                                 reparent_error(scanner, "struct_or_variant_declarator");
2266                 }
2267         ;
2268
2269 enumerator_list:
2270                 enumerator
2271                 {       $$ = $1;        }
2272         |       enumerator_list CTF_COMMA enumerator
2273                 {
2274                         $$ = $1;
2275                         bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2276                 }
2277         ;
2278
2279 enumerator:
2280                 IDENTIFIER
2281                 {
2282                         $$ = make_node(scanner, NODE_ENUMERATOR);
2283                         $$->u.enumerator.id = $1;
2284                 }
2285         |       ID_TYPE
2286                 {
2287                         $$ = make_node(scanner, NODE_ENUMERATOR);
2288                         $$->u.enumerator.id = $1;
2289                 }
2290         |       keywords
2291                 {
2292                         $$ = make_node(scanner, NODE_ENUMERATOR);
2293                         $$->u.enumerator.id = $1;
2294                 }
2295         |       CTF_STRING_LITERAL
2296                 {
2297                         $$ = make_node(scanner, NODE_ENUMERATOR);
2298                         $$->u.enumerator.id = $1;
2299                 }
2300         |       IDENTIFIER CTF_EQUAL unary_expression_or_range
2301                 {
2302                         $$ = make_node(scanner, NODE_ENUMERATOR);
2303                         $$->u.enumerator.id = $1;
2304                         bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2305                 }
2306         |       ID_TYPE CTF_EQUAL unary_expression_or_range
2307                 {
2308                         $$ = make_node(scanner, NODE_ENUMERATOR);
2309                         $$->u.enumerator.id = $1;
2310                         bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2311                 }
2312         |       keywords CTF_EQUAL unary_expression_or_range
2313                 {
2314                         $$ = make_node(scanner, NODE_ENUMERATOR);
2315                         $$->u.enumerator.id = $1;
2316                         bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2317                 }
2318         |       CTF_STRING_LITERAL CTF_EQUAL unary_expression_or_range
2319                 {
2320                         $$ = make_node(scanner, NODE_ENUMERATOR);
2321                         $$->u.enumerator.id = $1;
2322                         bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
2323                 }
2324         ;
2325
2326 abstract_declarator_list:
2327                 abstract_declarator
2328                 {       $$ = $1;        }
2329         |       abstract_declarator_list CTF_COMMA abstract_declarator
2330                 {
2331                         $$ = $1;
2332                         bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2333                 }
2334         ;
2335
2336 abstract_declarator:
2337                 direct_abstract_declarator
2338                 {       $$ = $1;        }
2339         |       pointer direct_abstract_declarator
2340                 {
2341                         $$ = $2;
2342                         bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2343                 }
2344         ;
2345
2346 direct_abstract_declarator:
2347                 /* empty */
2348                 {
2349                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2350                         $$->u.field_class_declarator.type = TYPEDEC_ID;
2351                         /* id is NULL */
2352                 }
2353         |       IDENTIFIER
2354                 {
2355                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2356                         $$->u.field_class_declarator.type = TYPEDEC_ID;
2357                         $$->u.field_class_declarator.u.id = $1;
2358                 }
2359         |       CTF_LPAREN abstract_declarator CTF_RPAREN
2360                 {
2361                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2362                         $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2363                         $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2364                 }
2365         |       direct_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2366                 {
2367                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2368                         $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2369                         $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2370                         BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2371                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2372                 }
2373         |       direct_abstract_declarator CTF_LSBRAC CTF_RSBRAC
2374                 {
2375                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2376                         $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2377                         $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2378                         $$->u.field_class_declarator.u.nested.abstract_array = 1;
2379                 }
2380         ;
2381
2382 alias_abstract_declarator_list:
2383                 alias_abstract_declarator
2384                 {       $$ = $1;        }
2385         |       alias_abstract_declarator_list CTF_COMMA alias_abstract_declarator
2386                 {
2387                         $$ = $1;
2388                         bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
2389                 }
2390         ;
2391
2392 alias_abstract_declarator:
2393                 direct_alias_abstract_declarator
2394                 {       $$ = $1;        }
2395         |       pointer direct_alias_abstract_declarator
2396                 {
2397                         $$ = $2;
2398                         bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2399                 }
2400         ;
2401
2402 direct_alias_abstract_declarator:
2403                 /* empty */
2404                 {
2405                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2406                         $$->u.field_class_declarator.type = TYPEDEC_ID;
2407                         /* id is NULL */
2408                 }
2409         |       CTF_LPAREN alias_abstract_declarator CTF_RPAREN
2410                 {
2411                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2412                         $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2413                         $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2414                 }
2415         |       direct_alias_abstract_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2416                 {
2417                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2418                         $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2419                         $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2420                         BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2421                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2422                 }
2423         |       direct_alias_abstract_declarator CTF_LSBRAC CTF_RSBRAC
2424                 {
2425                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2426                         $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2427                         $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2428                         $$->u.field_class_declarator.u.nested.abstract_array = 1;
2429                 }
2430         ;
2431
2432 declarator:
2433                 direct_declarator
2434                 {       $$ = $1;        }
2435         |       pointer direct_declarator
2436                 {
2437                         $$ = $2;
2438                         bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2439                 }
2440         ;
2441
2442 direct_declarator:
2443                 IDENTIFIER
2444                 {
2445                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2446                         $$->u.field_class_declarator.type = TYPEDEC_ID;
2447                         $$->u.field_class_declarator.u.id = $1;
2448                 }
2449         |       CTF_LPAREN declarator CTF_RPAREN
2450                 {
2451                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2452                         $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2453                         $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2454                 }
2455         |       direct_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2456                 {
2457                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2458                         $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2459                         $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2460                         BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2461                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2462                 }
2463         ;
2464
2465 field_class_declarator:
2466                 direct_field_class_declarator
2467                 {       $$ = $1;        }
2468         |       pointer direct_field_class_declarator
2469                 {
2470                         $$ = $2;
2471                         bt_list_splice(&($1)->tmp_head, &($$)->u.field_class_declarator.pointers);
2472                 }
2473         ;
2474
2475 direct_field_class_declarator:
2476                 IDENTIFIER
2477                 {
2478                         add_type(scanner, $1);
2479                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2480                         $$->u.field_class_declarator.type = TYPEDEC_ID;
2481                         $$->u.field_class_declarator.u.id = $1;
2482                 }
2483         |       CTF_LPAREN field_class_declarator CTF_RPAREN
2484                 {
2485                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2486                         $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2487                         $$->u.field_class_declarator.u.nested.field_class_declarator = $2;
2488                 }
2489         |       direct_field_class_declarator CTF_LSBRAC unary_expression CTF_RSBRAC
2490                 {
2491                         $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
2492                         $$->u.field_class_declarator.type = TYPEDEC_NESTED;
2493                         $$->u.field_class_declarator.u.nested.field_class_declarator = $1;
2494                         BT_INIT_LIST_HEAD(&($$)->u.field_class_declarator.u.nested.length);
2495                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_declarator.u.nested.length);
2496                 }
2497         ;
2498
2499 pointer:
2500                 CTF_STAR
2501                 {
2502                         $$ = make_node(scanner, NODE_POINTER);
2503                 }
2504         |       CTF_STAR pointer
2505                 {
2506                         $$ = make_node(scanner, NODE_POINTER);
2507                         bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
2508                 }
2509         |       CTF_STAR type_qualifier_list pointer
2510                 {
2511                         $$ = make_node(scanner, NODE_POINTER);
2512                         $$->u.pointer.const_qualifier = 1;
2513                         bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
2514                 }
2515         ;
2516
2517 type_qualifier_list:
2518                 /* pointer assumes only const type qualifier */
2519                 CTF_CONST
2520         |       type_qualifier_list CTF_CONST
2521         ;
2522
2523 /* 2.3: CTF-specific declarations */
2524
2525 ctf_assignment_expression_list:
2526                 ctf_assignment_expression CTF_SEMICOLON
2527                 {       $$ = $1;        }
2528         |       ctf_assignment_expression_list ctf_assignment_expression CTF_SEMICOLON
2529                 {
2530                         $$ = $1;
2531                         bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
2532                 }
2533         ;
2534
2535 ctf_assignment_expression:
2536                 unary_expression CTF_EQUAL unary_expression
2537                 {
2538                         /*
2539                          * Because we have left and right, cannot use
2540                          * set_parent_node.
2541                          */
2542                         $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2543                         _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2544                         if ($1->u.unary_expression.type != UNARY_STRING)
2545                                 reparent_error(scanner, "ctf_assignment_expression left expects string");
2546                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
2547                 }
2548         |       unary_expression CTF_TYPEASSIGN declaration_specifiers  /* Only allow struct */
2549                 {
2550                         /*
2551                          * Because we have left and right, cannot use
2552                          * set_parent_node.
2553                          */
2554                         $$ = make_node(scanner, NODE_CTF_EXPRESSION);
2555                         _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
2556                         if ($1->u.unary_expression.type != UNARY_STRING)
2557                                 reparent_error(scanner, "ctf_assignment_expression left expects string");
2558                         bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
2559                 }
2560         |       declaration_specifiers CTF_TYPEDEF declaration_specifiers field_class_declarator_list
2561                 {
2562                         struct ctf_node *list;
2563
2564                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2565                         _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2566                         _bt_list_splice_tail(&($3)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2567                         $$ = make_node(scanner, NODE_TYPEDEF);
2568                         ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2569                         _bt_list_splice_tail(&($4)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2570                 }
2571         |       CTF_TYPEDEF declaration_specifiers field_class_declarator_list
2572                 {
2573                         struct ctf_node *list;
2574
2575                         $$ = make_node(scanner, NODE_TYPEDEF);
2576                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2577                         $$->u.field_class_def.field_class_specifier_list = list;
2578                         _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2579                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2580                 }
2581         |       declaration_specifiers CTF_TYPEDEF field_class_declarator_list
2582                 {
2583                         struct ctf_node *list;
2584
2585                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2586                         _bt_list_splice_tail(&($1)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2587                         $$ = make_node(scanner, NODE_TYPEDEF);
2588                         ($$)->u.struct_or_variant_declaration.field_class_specifier_list = list;
2589                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_def.field_class_declarators);
2590                 }
2591         |       CTF_TYPEALIAS declaration_specifiers abstract_declarator_list CTF_TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
2592                 {
2593                         struct ctf_node *list;
2594
2595                         $$ = make_node(scanner, NODE_TYPEALIAS);
2596                         $$->u.field_class_alias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
2597                         $$->u.field_class_alias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
2598
2599                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2600                         $$->u.field_class_alias.target->u.field_class_alias_target.field_class_specifier_list = list;
2601                         _bt_list_splice_tail(&($2)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2602                         _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.field_class_alias.target->u.field_class_alias_target.field_class_declarators);
2603
2604                         list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
2605                         $$->u.field_class_alias.alias->u.field_class_alias_name.field_class_specifier_list = list;
2606                         _bt_list_splice_tail(&($5)->u.field_class_specifier_list.head, &list->u.field_class_specifier_list.head);
2607                         _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.field_class_alias.alias->u.field_class_alias_name.field_class_declarators);
2608                 }
2609         ;