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