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