formats/ctf/metadata/ctf-parser.y

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