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