formats/ctf/metadata/ctf-parser.y

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