formats/ctf/metadata/ctf-parser.y

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