Add missing permission notice in each source file

[babeltrace.git] / formats / ctf / metadata / ctf-parser.y

diff --git a/formats/ctf/metadata/ctf-parser.y b/formats/ctf/metadata/ctf-parser.y
index 6706e3dcbff0df3fa341002ce9306d76d1640792..e7dfd80cf847aeea3bcd9ff14d21219984023a3d 100644 (file)
--- a/formats/ctf/metadata/ctf-parser.y
+++ b/formats/ctf/metadata/ctf-parser.y
@@ -15,6 +15,14 @@
  *
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
  */
 
 #include <stdio.h>
@@ -22,16 +30,21 @@
 #include <string.h>
 #include <stdlib.h>
 #include <assert.h>
-#include <helpers/list.h>
 #include <glib.h>
 #include <errno.h>
+#include <inttypes.h>
+#include <babeltrace/list.h>
+#include <babeltrace/babeltrace-internal.h>
 #include "ctf-scanner.h"
 #include "ctf-parser.h"
 #include "ctf-ast.h"
 
+__attribute__((visibility("hidden")))
+int yydebug;
+
 /* Join two lists, put "add" at the end of "head".  */
 static inline void
-_cds_list_splice_tail (struct cds_list_head *add, struct cds_list_head *head)
+_bt_list_splice_tail (struct bt_list_head *add, struct bt_list_head *head)
 {
        /* Do nothing if the list which gets added is empty.  */
        if (add != add->next) {
@@ -42,22 +55,61 @@ _cds_list_splice_tail (struct cds_list_head *add, struct cds_list_head *head)
        }
 }
 
-#define printf_dbg(fmt, args...)       fprintf(stderr, "%s: " fmt, __func__, ## args)
-
+__attribute__((visibility("hidden")))
 int yyparse(struct ctf_scanner *scanner);
+__attribute__((visibility("hidden")))
 int yylex(union YYSTYPE *yyval, struct ctf_scanner *scanner);
+__attribute__((visibility("hidden")))
 int yylex_init_extra(struct ctf_scanner *scanner, yyscan_t * ptr_yy_globals);
-int yylex_destroy(yyscan_t yyscanner) ;
-void yyset_in(FILE * in_str, yyscan_t scanner);
-
-int yydebug;
+__attribute__((visibility("hidden")))
+int yylex_destroy(yyscan_t yyscanner);
+__attribute__((visibility("hidden")))
+void yyrestart(FILE * in_str, yyscan_t scanner);
 
 struct gc_string {
-       struct cds_list_head gc;
+       struct bt_list_head gc;
        size_t alloclen;
        char s[];
 };
 
+static const char *node_type_to_str[] = {
+       [ NODE_UNKNOWN ] = "NODE_UNKNOWN",
+       [ NODE_ROOT ] = "NODE_ROOT",
+       [ NODE_EVENT ] = "NODE_EVENT",
+       [ NODE_ENV ] = "NODE_ENV",
+       [ NODE_STREAM ] = "NODE_STREAM",
+       [ NODE_TRACE ] = "NODE_TRACE",
+       [ NODE_CLOCK ] = "NODE_CLOCK",
+       [ NODE_CALLSITE ] = "NODE_CALLSITE",
+       [ NODE_CTF_EXPRESSION ] = "NODE_CTF_EXPRESSION",
+       [ NODE_UNARY_EXPRESSION ] = "NODE_UNARY_EXPRESSION",
+       [ NODE_TYPEDEF ] = "NODE_TYPEDEF",
+       [ NODE_TYPEALIAS_TARGET ] = "NODE_TYPEALIAS_TARGET",
+       [ NODE_TYPEALIAS_ALIAS ] = "NODE_TYPEALIAS_ALIAS",
+       [ NODE_TYPEALIAS ] = "NODE_TYPEALIAS",
+       [ NODE_TYPE_SPECIFIER ] = "NODE_TYPE_SPECIFIER",
+       [ NODE_TYPE_SPECIFIER_LIST ] = "NODE_TYPE_SPECIFIER_LIST",
+       [ NODE_POINTER ] = "NODE_POINTER",
+       [ NODE_TYPE_DECLARATOR ] = "NODE_TYPE_DECLARATOR",
+       [ NODE_FLOATING_POINT ] = "NODE_FLOATING_POINT",
+       [ NODE_INTEGER ] = "NODE_INTEGER",
+       [ NODE_STRING ] = "NODE_STRING",
+       [ NODE_ENUMERATOR ] = "NODE_ENUMERATOR",
+       [ NODE_ENUM ] = "NODE_ENUM",
+       [ NODE_STRUCT_OR_VARIANT_DECLARATION ] = "NODE_STRUCT_OR_VARIANT_DECLARATION",
+       [ NODE_VARIANT ] = "NODE_VARIANT",
+       [ NODE_STRUCT ] = "NODE_STRUCT",
+};
+
+__attribute__((visibility("hidden")))
+const char *node_type(struct ctf_node *node)
+{
+       if (node->type < NR_NODE_TYPES)
+               return node_type_to_str[node->type];
+       else
+               return NULL;
+}
+
 static struct gc_string *gc_string_alloc(struct ctf_scanner *scanner,
                                         size_t len)
 {
@@ -70,7 +122,7 @@ static struct gc_string *gc_string_alloc(struct ctf_scanner *scanner,
             alloclen *= 2);
 
        gstr = malloc(alloclen);
-       cds_list_add(&gstr->gc, &scanner->allocated_strings);
+       bt_list_add(&gstr->gc, &scanner->allocated_strings);
        gstr->alloclen = alloclen;
        return gstr;
 }
@@ -80,6 +132,7 @@ static struct gc_string *gc_string_alloc(struct ctf_scanner *scanner,
  * gsrc will be garbage collected immediately, and gstr might be.
  * Should only be used to append characters to a string literal or constant.
  */
+__attribute__((visibility("hidden")))
 struct gc_string *gc_string_append(struct ctf_scanner *scanner,
                                   struct gc_string *gstr,
                                   struct gc_string *gsrc)
@@ -98,13 +151,13 @@ struct gc_string *gc_string_append(struct ctf_scanner *scanner,
                newgstr = gc_string_alloc(scanner, newlen);
                strcpy(newgstr->s, gstr->s);
                strcat(newgstr->s, gsrc->s);
-               cds_list_del(&gstr->gc);
+               bt_list_del(&gstr->gc);
                free(gstr);
                gstr = newgstr;
        } else {
                strcat(gstr->s, gsrc->s);
        }
-       cds_list_del(&gsrc->gc);
+       bt_list_del(&gsrc->gc);
        free(gsrc);
        return gstr;
 }
@@ -132,7 +185,7 @@ static void push_scope(struct ctf_scanner *scanner)
 {
        struct ctf_scanner_scope *ns;
 
-       printf_dbg("push scope\n");
+       printf_debug("push scope\n");
        ns = malloc(sizeof(struct ctf_scanner_scope));
        init_scope(ns, scanner->cs);
        scanner->cs = ns;
@@ -142,7 +195,7 @@ static void pop_scope(struct ctf_scanner *scanner)
 {
        struct ctf_scanner_scope *os;
 
-       printf_dbg("pop scope\n");
+       printf_debug("pop scope\n");
        os = scanner->cs;
        scanner->cs = os->parent;
        finalize_scope(os);
@@ -153,11 +206,12 @@ static int lookup_type(struct ctf_scanner_scope *s, const char *id)
 {
        int ret;
 
-       ret = (int) g_hash_table_lookup(s->types, id);
-       printf_dbg("lookup %p %s %d\n", s, id, ret);
+       ret = (int) (long) g_hash_table_lookup(s->types, id);
+       printf_debug("lookup %p %s %d\n", s, id, ret);
        return ret;
 }
 
+__attribute__((visibility("hidden")))
 int is_type(struct ctf_scanner *scanner, const char *id)
 {
        struct ctf_scanner_scope *it;
@@ -169,13 +223,13 @@ int is_type(struct ctf_scanner *scanner, const char *id)
                        break;
                }
        }
-       printf_dbg("is type %s %d\n", id, ret);
+       printf_debug("is type %s %d\n", id, ret);
        return ret;
 }
 
 static void add_type(struct ctf_scanner *scanner, struct gc_string *id)
 {
-       printf_dbg("add type %s\n", id->s);
+       printf_debug("add type %s\n", id->s);
        if (lookup_type(scanner->cs, id->s))
                return;
        g_hash_table_insert(scanner->cs->types, id->s, id->s);
@@ -192,8 +246,9 @@ static struct ctf_node *make_node(struct ctf_scanner *scanner,
                return NULL;
        memset(node, 0, sizeof(*node));
        node->type = type;
-       CDS_INIT_LIST_HEAD(&node->tmp_head);
-       cds_list_add(&node->gc, &ast->allocated_nodes);
+       BT_INIT_LIST_HEAD(&node->tmp_head);
+       bt_list_add(&node->gc, &ast->allocated_nodes);
+       bt_list_add(&node->siblings, &node->tmp_head);
 
        switch (type) {
        case NODE_ROOT:
@@ -201,69 +256,78 @@ static struct ctf_node *make_node(struct ctf_scanner *scanner,
                break;
 
        case NODE_EVENT:
-               CDS_INIT_LIST_HEAD(&node->u.event.declaration_list);
+               BT_INIT_LIST_HEAD(&node->u.event.declaration_list);
                break;
        case NODE_STREAM:
-               CDS_INIT_LIST_HEAD(&node->u.stream.declaration_list);
+               BT_INIT_LIST_HEAD(&node->u.stream.declaration_list);
+               break;
+       case NODE_ENV:
+               BT_INIT_LIST_HEAD(&node->u.env.declaration_list);
                break;
        case NODE_TRACE:
-               CDS_INIT_LIST_HEAD(&node->u.trace.declaration_list);
+               BT_INIT_LIST_HEAD(&node->u.trace.declaration_list);
+               break;
+       case NODE_CLOCK:
+               BT_INIT_LIST_HEAD(&node->u.clock.declaration_list);
+               break;
+       case NODE_CALLSITE:
+               BT_INIT_LIST_HEAD(&node->u.callsite.declaration_list);
                break;
 
        case NODE_CTF_EXPRESSION:
-               CDS_INIT_LIST_HEAD(&node->u.ctf_expression.left);
-               CDS_INIT_LIST_HEAD(&node->u.ctf_expression.right);
+               BT_INIT_LIST_HEAD(&node->u.ctf_expression.left);
+               BT_INIT_LIST_HEAD(&node->u.ctf_expression.right);
                break;
        case NODE_UNARY_EXPRESSION:
                break;
 
        case NODE_TYPEDEF:
-               CDS_INIT_LIST_HEAD(&node->u._typedef.declaration_specifier);
-               CDS_INIT_LIST_HEAD(&node->u._typedef.type_declarators);
+               BT_INIT_LIST_HEAD(&node->u._typedef.type_declarators);
                break;
        case NODE_TYPEALIAS_TARGET:
-               CDS_INIT_LIST_HEAD(&node->u.typealias_target.declaration_specifier);
-               CDS_INIT_LIST_HEAD(&node->u.typealias_target.type_declarators);
+               BT_INIT_LIST_HEAD(&node->u.typealias_target.type_declarators);
                break;
        case NODE_TYPEALIAS_ALIAS:
-               CDS_INIT_LIST_HEAD(&node->u.typealias_alias.declaration_specifier);
-               CDS_INIT_LIST_HEAD(&node->u.typealias_alias.type_declarators);
+               BT_INIT_LIST_HEAD(&node->u.typealias_alias.type_declarators);
                break;
        case NODE_TYPEALIAS:
                break;
 
        case NODE_TYPE_SPECIFIER:
                break;
+       case NODE_TYPE_SPECIFIER_LIST:
+               BT_INIT_LIST_HEAD(&node->u.type_specifier_list.head);
+               break;
        case NODE_POINTER:
                break;
        case NODE_TYPE_DECLARATOR:
-               CDS_INIT_LIST_HEAD(&node->u.type_declarator.pointers);
+               BT_INIT_LIST_HEAD(&node->u.type_declarator.pointers);
                break;
 
        case NODE_FLOATING_POINT:
-               CDS_INIT_LIST_HEAD(&node->u.floating_point.expressions);
+               BT_INIT_LIST_HEAD(&node->u.floating_point.expressions);
                break;
        case NODE_INTEGER:
-               CDS_INIT_LIST_HEAD(&node->u.integer.expressions);
+               BT_INIT_LIST_HEAD(&node->u.integer.expressions);
                break;
        case NODE_STRING:
-               CDS_INIT_LIST_HEAD(&node->u.string.expressions);
+               BT_INIT_LIST_HEAD(&node->u.string.expressions);
                break;
        case NODE_ENUMERATOR:
-               CDS_INIT_LIST_HEAD(&node->u.enumerator.values);
+               BT_INIT_LIST_HEAD(&node->u.enumerator.values);
                break;
        case NODE_ENUM:
-               CDS_INIT_LIST_HEAD(&node->u._enum.enumerator_list);
+               BT_INIT_LIST_HEAD(&node->u._enum.enumerator_list);
                break;
        case NODE_STRUCT_OR_VARIANT_DECLARATION:
-               CDS_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.declaration_specifier);
-               CDS_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.type_declarators);
+               BT_INIT_LIST_HEAD(&node->u.struct_or_variant_declaration.type_declarators);
                break;
        case NODE_VARIANT:
-               CDS_INIT_LIST_HEAD(&node->u.variant.declaration_list);
+               BT_INIT_LIST_HEAD(&node->u.variant.declaration_list);
                break;
        case NODE_STRUCT:
-               CDS_INIT_LIST_HEAD(&node->u._struct.declaration_list);
+               BT_INIT_LIST_HEAD(&node->u._struct.declaration_list);
+               BT_INIT_LIST_HEAD(&node->u._struct.min_align);
                break;
 
        case NODE_UNKNOWN:
@@ -281,22 +345,31 @@ static int reparent_ctf_expression(struct ctf_node *node,
 {
        switch (parent->type) {
        case NODE_EVENT:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
                break;
        case NODE_STREAM:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
+               break;
+       case NODE_ENV:
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
                break;
        case NODE_TRACE:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
+               break;
+       case NODE_CLOCK:
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
+               break;
+       case NODE_CALLSITE:
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
                break;
        case NODE_FLOATING_POINT:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.floating_point.expressions);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.floating_point.expressions);
                break;
        case NODE_INTEGER:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.integer.expressions);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.integer.expressions);
                break;
        case NODE_STRING:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.string.expressions);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.string.expressions);
                break;
 
        case NODE_ROOT:
@@ -306,6 +379,7 @@ static int reparent_ctf_expression(struct ctf_node *node,
        case NODE_TYPEALIAS_ALIAS:
        case NODE_TYPEALIAS:
        case NODE_TYPE_SPECIFIER:
+       case NODE_TYPE_SPECIFIER_LIST:
        case NODE_POINTER:
        case NODE_TYPE_DECLARATOR:
        case NODE_ENUMERATOR:
@@ -329,22 +403,31 @@ static int reparent_typedef(struct ctf_node *node, struct ctf_node *parent)
 {
        switch (parent->type) {
        case NODE_ROOT:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.root._typedef);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
                break;
        case NODE_EVENT:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
                break;
        case NODE_STREAM:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
+               break;
+       case NODE_ENV:
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
                break;
        case NODE_TRACE:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
+               break;
+       case NODE_CLOCK:
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
+               break;
+       case NODE_CALLSITE:
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
                break;
        case NODE_VARIANT:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
                break;
        case NODE_STRUCT:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
                break;
 
        case NODE_FLOATING_POINT:
@@ -356,6 +439,7 @@ static int reparent_typedef(struct ctf_node *node, struct ctf_node *parent)
        case NODE_TYPEALIAS_ALIAS:
        case NODE_TYPEALIAS:
        case NODE_TYPE_SPECIFIER:
+       case NODE_TYPE_SPECIFIER_LIST:
        case NODE_POINTER:
        case NODE_TYPE_DECLARATOR:
        case NODE_ENUMERATOR:
@@ -377,22 +461,31 @@ static int reparent_typealias(struct ctf_node *node, struct ctf_node *parent)
 {
        switch (parent->type) {
        case NODE_ROOT:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.root.typealias);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_list);
                break;
        case NODE_EVENT:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
                break;
        case NODE_STREAM:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
+               break;
+       case NODE_ENV:
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
                break;
        case NODE_TRACE:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
+               break;
+       case NODE_CLOCK:
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
+               break;
+       case NODE_CALLSITE:
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.callsite.declaration_list);
                break;
        case NODE_VARIANT:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
                break;
        case NODE_STRUCT:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
                break;
 
        case NODE_FLOATING_POINT:
@@ -404,6 +497,7 @@ static int reparent_typealias(struct ctf_node *node, struct ctf_node *parent)
        case NODE_TYPEALIAS_ALIAS:
        case NODE_TYPEALIAS:
        case NODE_TYPE_SPECIFIER:
+       case NODE_TYPE_SPECIFIER_LIST:
        case NODE_POINTER:
        case NODE_TYPE_DECLARATOR:
        case NODE_ENUMERATOR:
@@ -423,51 +517,99 @@ static int reparent_typealias(struct ctf_node *node, struct ctf_node *parent)
 
 static int reparent_type_specifier(struct ctf_node *node,
                                   struct ctf_node *parent)
+{
+       switch (parent->type) {
+       case NODE_TYPE_SPECIFIER_LIST:
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.type_specifier_list.head);
+               break;
+
+       case NODE_TYPE_SPECIFIER:
+       case NODE_EVENT:
+       case NODE_STREAM:
+       case NODE_ENV:
+       case NODE_TRACE:
+       case NODE_CLOCK:
+       case NODE_CALLSITE:
+       case NODE_VARIANT:
+       case NODE_STRUCT:
+       case NODE_TYPEDEF:
+       case NODE_TYPEALIAS_TARGET:
+       case NODE_TYPEALIAS_ALIAS:
+       case NODE_TYPE_DECLARATOR:
+       case NODE_ENUM:
+       case NODE_STRUCT_OR_VARIANT_DECLARATION:
+       case NODE_TYPEALIAS:
+       case NODE_FLOATING_POINT:
+       case NODE_INTEGER:
+       case NODE_STRING:
+       case NODE_CTF_EXPRESSION:
+       case NODE_POINTER:
+       case NODE_ENUMERATOR:
+       case NODE_UNARY_EXPRESSION:
+               return -EPERM;
+
+       case NODE_UNKNOWN:
+       default:
+               fprintf(stderr, "[error] %s: unknown node type %d\n", __func__,
+                       (int) parent->type);
+               return -EINVAL;
+       }
+       return 0;
+}
+
+static int reparent_type_specifier_list(struct ctf_node *node,
+                                       struct ctf_node *parent)
 {
        switch (parent->type) {
        case NODE_ROOT:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.root.declaration_specifier);
+               bt_list_add_tail(&node->siblings, &parent->u.root.declaration_list);
                break;
        case NODE_EVENT:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.event.declaration_list);
+               bt_list_add_tail(&node->siblings, &parent->u.event.declaration_list);
                break;
        case NODE_STREAM:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.stream.declaration_list);
+               bt_list_add_tail(&node->siblings, &parent->u.stream.declaration_list);
+               break;
+       case NODE_ENV:
+               bt_list_add_tail(&node->siblings, &parent->u.env.declaration_list);
                break;
        case NODE_TRACE:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.trace.declaration_list);
+               bt_list_add_tail(&node->siblings, &parent->u.trace.declaration_list);
+               break;
+       case NODE_CLOCK:
+               bt_list_add_tail(&node->siblings, &parent->u.clock.declaration_list);
+               break;
+       case NODE_CALLSITE:
+               bt_list_add_tail(&node->siblings, &parent->u.callsite.declaration_list);
                break;
        case NODE_VARIANT:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
+               bt_list_add_tail(&node->siblings, &parent->u.variant.declaration_list);
                break;
        case NODE_STRUCT:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
+               bt_list_add_tail(&node->siblings, &parent->u._struct.declaration_list);
                break;
        case NODE_TYPEDEF:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u._typedef.declaration_specifier);
+               parent->u._typedef.type_specifier_list = node;
                break;
        case NODE_TYPEALIAS_TARGET:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.typealias_target.declaration_specifier);
+               parent->u.typealias_target.type_specifier_list = node;
                break;
        case NODE_TYPEALIAS_ALIAS:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.typealias_alias.declaration_specifier);
-               break;
-       case NODE_TYPE_DECLARATOR:
-               parent->u.type_declarator.type = TYPEDEC_NESTED;
-               parent->u.type_declarator.u.nested.length = node;
+               parent->u.typealias_alias.type_specifier_list = node;
                break;
        case NODE_ENUM:
                parent->u._enum.container_type = node;
                break;
        case NODE_STRUCT_OR_VARIANT_DECLARATION:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.declaration_specifier);
+               parent->u.struct_or_variant_declaration.type_specifier_list = node;
                break;
+       case NODE_TYPE_DECLARATOR:
+       case NODE_TYPE_SPECIFIER:
        case NODE_TYPEALIAS:
        case NODE_FLOATING_POINT:
        case NODE_INTEGER:
        case NODE_STRING:
        case NODE_CTF_EXPRESSION:
-       case NODE_TYPE_SPECIFIER:
        case NODE_POINTER:
        case NODE_ENUMERATOR:
        case NODE_UNARY_EXPRESSION:
@@ -491,22 +633,25 @@ static int reparent_type_declarator(struct ctf_node *node,
                parent->u.type_declarator.u.nested.type_declarator = node;
                break;
        case NODE_STRUCT_OR_VARIANT_DECLARATION:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.type_declarators);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.struct_or_variant_declaration.type_declarators);
                break;
        case NODE_TYPEDEF:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u._typedef.type_declarators);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u._typedef.type_declarators);
                break;
        case NODE_TYPEALIAS_TARGET:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.typealias_target.type_declarators);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_target.type_declarators);
                break;
        case NODE_TYPEALIAS_ALIAS:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.typealias_alias.type_declarators);
+               _bt_list_splice_tail(&node->tmp_head, &parent->u.typealias_alias.type_declarators);
                break;
 
        case NODE_ROOT:
        case NODE_EVENT:
        case NODE_STREAM:
+       case NODE_ENV:
        case NODE_TRACE:
+       case NODE_CLOCK:
+       case NODE_CALLSITE:
        case NODE_VARIANT:
        case NODE_STRUCT:
        case NODE_TYPEALIAS:
@@ -516,6 +661,7 @@ static int reparent_type_declarator(struct ctf_node *node,
        case NODE_STRING:
        case NODE_CTF_EXPRESSION:
        case NODE_TYPE_SPECIFIER:
+       case NODE_TYPE_SPECIFIER_LIST:
        case NODE_POINTER:
        case NODE_ENUMERATOR:
        case NODE_UNARY_EXPRESSION:
@@ -552,21 +698,45 @@ static int set_parent_node(struct ctf_node *node,
 
        case NODE_EVENT:
                if (parent->type == NODE_ROOT) {
-                       _cds_list_splice_tail(&node->tmp_head, &parent->u.root.event);
-               } else
+                       _bt_list_splice_tail(&node->tmp_head, &parent->u.root.event);
+               } else {
                        return -EPERM;
+               }
                break;
        case NODE_STREAM:
                if (parent->type == NODE_ROOT) {
-                       _cds_list_splice_tail(&node->tmp_head, &parent->u.root.stream);
-               } else
+                       _bt_list_splice_tail(&node->tmp_head, &parent->u.root.stream);
+               } else {
                        return -EPERM;
+               }
+               break;
+       case NODE_ENV:
+               if (parent->type == NODE_ROOT) {
+                       _bt_list_splice_tail(&node->tmp_head, &parent->u.root.env);
+               } else {
+                       return -EPERM;
+               }
                break;
        case NODE_TRACE:
                if (parent->type == NODE_ROOT) {
-                       _cds_list_splice_tail(&node->tmp_head, &parent->u.root.trace);
-               } else
+                       _bt_list_splice_tail(&node->tmp_head, &parent->u.root.trace);
+               } else {
+                       return -EPERM;
+               }
+               break;
+       case NODE_CLOCK:
+               if (parent->type == NODE_ROOT) {
+                       _bt_list_splice_tail(&node->tmp_head, &parent->u.root.clock);
+               } else {
                        return -EPERM;
+               }
+               break;
+       case NODE_CALLSITE:
+               if (parent->type == NODE_ROOT) {
+                       _bt_list_splice_tail(&node->tmp_head, &parent->u.root.callsite);
+               } else {
+                       return -EPERM;
+               }
                break;
 
        case NODE_CTF_EXPRESSION:
@@ -595,35 +765,41 @@ static int set_parent_node(struct ctf_node *node,
 
        case NODE_POINTER:
                if (parent->type == NODE_TYPE_DECLARATOR) {
-                       _cds_list_splice_tail(&node->tmp_head, &parent->u.type_declarator.pointers);
+                       _bt_list_splice_tail(&node->tmp_head, &parent->u.type_declarator.pointers);
                } else
                        return -EPERM;
                break;
        case NODE_TYPE_DECLARATOR:
                return reparent_type_declarator(node, parent);
 
+       case NODE_TYPE_SPECIFIER_LIST:
+               return reparent_type_specifier_list(node, parent);
+
        case NODE_TYPE_SPECIFIER:
+               return reparent_type_specifier(node, parent);
+
        case NODE_FLOATING_POINT:
        case NODE_INTEGER:
        case NODE_STRING:
        case NODE_ENUM:
        case NODE_VARIANT:
        case NODE_STRUCT:
-               return reparent_type_specifier(node, parent);
+               return -EINVAL; /* Dealt with internally within grammar */
 
        case NODE_ENUMERATOR:
                if (parent->type == NODE_ENUM) {
-                       _cds_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
-               } else
+                       _bt_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
+               } else {
                        return -EPERM;
+               }
                break;
        case NODE_STRUCT_OR_VARIANT_DECLARATION:
                switch (parent->type) {
                case NODE_STRUCT:
-                       _cds_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
+                       _bt_list_splice_tail(&node->tmp_head, &parent->u._struct.declaration_list);
                        break;
                case NODE_VARIANT:
-                       _cds_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
+                       _bt_list_splice_tail(&node->tmp_head, &parent->u.variant.declaration_list);
                        break;
                default:
                        return -EINVAL;
@@ -639,11 +815,13 @@ static int set_parent_node(struct ctf_node *node,
        return 0;
 }
 
+__attribute__((visibility("hidden")))
 void yyerror(struct ctf_scanner *scanner, const char *str)
 {
        fprintf(stderr, "error %s\n", str);
 }
  
+__attribute__((visibility("hidden")))
 int yywrap(void)
 {
        return 1;
@@ -655,11 +833,11 @@ do {                                                              \
        YYERROR;                                                \
 } while (0)
 
-static void free_strings(struct cds_list_head *list)
+static void free_strings(struct bt_list_head *list)
 {
        struct gc_string *gstr, *tmp;
 
-       cds_list_for_each_entry_safe(gstr, tmp, list, gc)
+       bt_list_for_each_entry_safe(gstr, tmp, list, gc)
                free(gstr);
 }
 
@@ -671,15 +849,16 @@ static struct ctf_ast *ctf_ast_alloc(void)
        if (!ast)
                return NULL;
        memset(ast, 0, sizeof(*ast));
-       CDS_INIT_LIST_HEAD(&ast->allocated_nodes);
+       BT_INIT_LIST_HEAD(&ast->allocated_nodes);
        ast->root.type = NODE_ROOT;
-       CDS_INIT_LIST_HEAD(&ast->root.tmp_head);
-       CDS_INIT_LIST_HEAD(&ast->root.u.root._typedef);
-       CDS_INIT_LIST_HEAD(&ast->root.u.root.typealias);
-       CDS_INIT_LIST_HEAD(&ast->root.u.root.declaration_specifier);
-       CDS_INIT_LIST_HEAD(&ast->root.u.root.trace);
-       CDS_INIT_LIST_HEAD(&ast->root.u.root.stream);
-       CDS_INIT_LIST_HEAD(&ast->root.u.root.event);
+       BT_INIT_LIST_HEAD(&ast->root.tmp_head);
+       BT_INIT_LIST_HEAD(&ast->root.u.root.declaration_list);
+       BT_INIT_LIST_HEAD(&ast->root.u.root.trace);
+       BT_INIT_LIST_HEAD(&ast->root.u.root.env);
+       BT_INIT_LIST_HEAD(&ast->root.u.root.stream);
+       BT_INIT_LIST_HEAD(&ast->root.u.root.event);
+       BT_INIT_LIST_HEAD(&ast->root.u.root.clock);
+       BT_INIT_LIST_HEAD(&ast->root.u.root.callsite);
        return ast;
 }
 
@@ -687,8 +866,9 @@ static void ctf_ast_free(struct ctf_ast *ast)
 {
        struct ctf_node *node, *tmp;
 
-       cds_list_for_each_entry_safe(node, tmp, &ast->allocated_nodes, gc)
+       bt_list_for_each_entry_safe(node, tmp, &ast->allocated_nodes, gc)
                free(node);
+       free(ast);
 }
 
 int ctf_scanner_append_ast(struct ctf_scanner *scanner)
@@ -701,6 +881,8 @@ struct ctf_scanner *ctf_scanner_alloc(FILE *input)
        struct ctf_scanner *scanner;
        int ret;
 
+       yydebug = babeltrace_debug;
+
        scanner = malloc(sizeof(*scanner));
        if (!scanner)
                return NULL;
@@ -711,14 +893,20 @@ struct ctf_scanner *ctf_scanner_alloc(FILE *input)
                fprintf(stderr, "yylex_init error\n");
                goto cleanup_scanner;
        }
-       yyset_in(input, scanner);
+       /* Start processing new stream */
+       yyrestart(input, scanner->scanner);
 
        scanner->ast = ctf_ast_alloc();
        if (!scanner->ast)
                goto cleanup_lexer;
        init_scope(&scanner->root_scope, NULL);
        scanner->cs = &scanner->root_scope;
-       CDS_INIT_LIST_HEAD(&scanner->allocated_strings);
+       BT_INIT_LIST_HEAD(&scanner->allocated_strings);
+
+       if (yydebug)
+               fprintf(stdout, "Scanner input is a%s.\n",
+                       isatty(fileno(input)) ? "n interactive tty" :
+                                               " noninteractive file");
 
        return scanner;
 
@@ -750,8 +938,17 @@ void ctf_scanner_free(struct ctf_scanner *scanner)
        /* %locations */
 %parse-param {struct ctf_scanner *scanner}
 %lex-param {struct ctf_scanner *scanner}
+/*
+ * Expect two shift-reduce conflicts. Caused by enum name-opt : type {}
+ * vs struct { int :value; } (unnamed bit-field). The default is to
+ * shift, so whenever we encounter an enumeration, we are doing the
+ * proper thing (shift). It is illegal to declare an enumeration
+ * "bit-field", so it is OK if this situation ends up in a parsing
+ * error.
+ */
+%expect 2
 %start file
-%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
+%token CHARACTER_CONSTANT_START SQUOTE STRING_LITERAL_START DQUOTE ESCSEQ CHAR_STRING_TOKEN LSBRAC RSBRAC LPAREN RPAREN LBRAC RBRAC RARROW STAR PLUS MINUS LT GT TYPEASSIGN COLON SEMICOLON DOTDOTDOT DOT EQUAL COMMA CONST CHAR DOUBLE ENUM ENV EVENT FLOATING_POINT FLOAT INTEGER INT LONG SHORT SIGNED STREAM STRING STRUCT TRACE CALLSITE CLOCK TYPEALIAS TYPEDEF UNSIGNED VARIANT VOID _BOOL _COMPLEX _IMAGINARY DECIMAL_CONSTANT OCTAL_CONSTANT HEXADECIMAL_CONSTANT TOK_ALIGN
 %token <gs> IDENTIFIER ID_TYPE
 %token ERROR
 %union
@@ -770,19 +967,22 @@ void ctf_scanner_free(struct ctf_scanner *scanner)
 %type <n> declaration
 %type <n> event_declaration
 %type <n> stream_declaration
+%type <n> env_declaration
 %type <n> trace_declaration
+%type <n> clock_declaration
+%type <n> callsite_declaration
+%type <n> integer_declaration_specifiers
 %type <n> declaration_specifiers
+%type <n> alias_declaration_specifiers
 
 %type <n> type_declarator_list
-%type <n> abstract_type_declarator_list
+%type <n> integer_type_specifier
 %type <n> type_specifier
 %type <n> struct_type_specifier
 %type <n> variant_type_specifier
-%type <n> type_specifier_or_integer_constant
 %type <n> enum_type_specifier
 %type <n> struct_or_variant_declaration_list
 %type <n> struct_or_variant_declaration
-%type <n> specifier_qualifier_list
 %type <n> struct_or_variant_declarator_list
 %type <n> struct_or_variant_declarator
 %type <n> enumerator_list
@@ -790,12 +990,13 @@ void ctf_scanner_free(struct ctf_scanner *scanner)
 %type <n> abstract_declarator_list
 %type <n> abstract_declarator
 %type <n> direct_abstract_declarator
+%type <n> alias_abstract_declarator_list
+%type <n> alias_abstract_declarator
+%type <n> direct_alias_abstract_declarator
 %type <n> declarator
 %type <n> direct_declarator
 %type <n> type_declarator
 %type <n> direct_type_declarator
-%type <n> abstract_type_declarator
-%type <n> direct_abstract_type_declarator
 %type <n> pointer      
 %type <n> ctf_assignment_expression_list
 %type <n> ctf_assignment_expression
@@ -838,6 +1039,8 @@ keywords:
                {       $$ = yylval.gs;         }
        |       _COMPLEX
                {       $$ = yylval.gs;         }
+       |       _IMAGINARY
+               {       $$ = yylval.gs;         }
        |       FLOATING_POINT
                {       $$ = yylval.gs;         }
        |       INTEGER
@@ -858,8 +1061,16 @@ keywords:
                {       $$ = yylval.gs;         }
        |       STREAM
                {       $$ = yylval.gs;         }
+       |       ENV
+               {       $$ = yylval.gs;         }
        |       TRACE
                {       $$ = yylval.gs;         }
+       |       CLOCK
+               {       $$ = yylval.gs;         }
+       |       CALLSITE
+               {       $$ = yylval.gs;         }
+       |       TOK_ALIGN
+               {       $$ = yylval.gs;         }
        ;
 
 /* 1.5 Constants */
@@ -906,82 +1117,71 @@ postfix_expression:
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_STRING;
                        $$->u.unary_expression.u.string = yylval.gs->s;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                }
        |       ID_TYPE
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_STRING;
                        $$->u.unary_expression.u.string = yylval.gs->s;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                }
        |       keywords
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_STRING;
                        $$->u.unary_expression.u.string = yylval.gs->s;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                }
-
        |       DECIMAL_CONSTANT
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
-                       sscanf(yylval.gs->s, "%llu",
+                       sscanf(yylval.gs->s, "%" PRIu64,
                               &$$->u.unary_expression.u.unsigned_constant);
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                }
        |       OCTAL_CONSTANT
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
-                       sscanf(yylval.gs->s, "0%llo",
+                       sscanf(yylval.gs->s, "0%" PRIo64,
                               &$$->u.unary_expression.u.unsigned_constant);
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                }
        |       HEXADECIMAL_CONSTANT
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
-                       sscanf(yylval.gs->s, "0x%llx",
+                       sscanf(yylval.gs->s, "0x%" PRIx64,
                               &$$->u.unary_expression.u.unsigned_constant);
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                }
        |       STRING_LITERAL_START DQUOTE
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_STRING;
                        $$->u.unary_expression.u.string = "";
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                }
        |       STRING_LITERAL_START s_char_sequence DQUOTE
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_STRING;
                        $$->u.unary_expression.u.string = $2->s;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                }
        |       CHARACTER_CONSTANT_START c_char_sequence SQUOTE
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_STRING;
                        $$->u.unary_expression.u.string = $2->s;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                }
        |       LPAREN unary_expression RPAREN
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_NESTED;
                        $$->u.unary_expression.u.nested_exp = $2;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                }
        |       postfix_expression LSBRAC unary_expression RSBRAC
                {
                        $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
                        $$->u.unary_expression.type = UNARY_SBRAC;
                        $$->u.unary_expression.u.sbrac_exp = $3;
-                       cds_list_splice(&($1)->tmp_head, &($$)->tmp_head);
-                       cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
+                       bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
+                       bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
                }
        |       postfix_expression DOT IDENTIFIER
                {
@@ -989,8 +1189,8 @@ postfix_expression:
                        $$->u.unary_expression.type = UNARY_STRING;
                        $$->u.unary_expression.u.string = yylval.gs->s;
                        $$->u.unary_expression.link = UNARY_DOTLINK;
-                       cds_list_splice(&($1)->tmp_head, &($$)->tmp_head);
-                       cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
+                       bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
+                       bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
                }
        |       postfix_expression DOT ID_TYPE
                {
@@ -998,8 +1198,8 @@ postfix_expression:
                        $$->u.unary_expression.type = UNARY_STRING;
                        $$->u.unary_expression.u.string = yylval.gs->s;
                        $$->u.unary_expression.link = UNARY_DOTLINK;
-                       cds_list_splice(&($1)->tmp_head, &($$)->tmp_head);
-                       cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
+                       bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
+                       bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
                }
        |       postfix_expression RARROW IDENTIFIER
                {
@@ -1007,8 +1207,8 @@ postfix_expression:
                        $$->u.unary_expression.type = UNARY_STRING;
                        $$->u.unary_expression.u.string = yylval.gs->s;
                        $$->u.unary_expression.link = UNARY_ARROWLINK;
-                       cds_list_splice(&($1)->tmp_head, &($$)->tmp_head);
-                       cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
+                       bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
+                       bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
                }
        |       postfix_expression RARROW ID_TYPE
                {
@@ -1016,8 +1216,8 @@ postfix_expression:
                        $$->u.unary_expression.type = UNARY_STRING;
                        $$->u.unary_expression.u.string = yylval.gs->s;
                        $$->u.unary_expression.link = UNARY_ARROWLINK;
-                       cds_list_splice(&($1)->tmp_head, &($$)->tmp_head);
-                       cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
+                       bt_list_splice(&($1)->tmp_head, &($$)->tmp_head);
+                       bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
                }
        ;
 
@@ -1048,7 +1248,7 @@ unary_expression_or_range:
                unary_expression DOTDOTDOT unary_expression
                {
                        $$ = $1;
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->tmp_head);
                        $3->u.unary_expression.link = UNARY_DOTDOTDOT;
                }
        |       unary_expression
@@ -1064,45 +1264,62 @@ declaration:
                {       $$ = $1;        }
        |       stream_declaration
                {       $$ = $1;        }
+       |       env_declaration
+               {       $$ = $1;        }
        |       trace_declaration
                {       $$ = $1;        }
+       |       clock_declaration
+               {       $$ = $1;        }
+       |       callsite_declaration
+               {       $$ = $1;        }
        |       declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
                {
+                       struct ctf_node *list;
+
                        $$ = make_node(scanner, NODE_TYPEDEF);
-                       _cds_list_splice_tail(&($1)->tmp_head, &($$)->u._typedef.declaration_specifier);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.declaration_specifier);
-                       _cds_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       $$->u._typedef.type_specifier_list = list;
+                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
                }
        |       TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
                {
+                       struct ctf_node *list;
+
                        $$ = make_node(scanner, NODE_TYPEDEF);
-                       _cds_list_splice_tail(&($2)->tmp_head, &($$)->u._typedef.declaration_specifier);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       $$->u._typedef.type_specifier_list = list;
+                       _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
                }
        |       declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
                {
+                       struct ctf_node *list;
+
                        $$ = make_node(scanner, NODE_TYPEDEF);
-                       _cds_list_splice_tail(&($1)->tmp_head, &($$)->u._typedef.declaration_specifier);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       $$->u._typedef.type_specifier_list = list;
+                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
                }
-       |       TYPEALIAS declaration_specifiers abstract_declarator_list COLON declaration_specifiers abstract_type_declarator_list SEMICOLON
-               {
-                       $$ = make_node(scanner, NODE_TYPEALIAS);
-                       $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
-                       $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
-                       _cds_list_splice_tail(&($2)->tmp_head, &($$)->u.typealias.target->u.typealias_target.declaration_specifier);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
-                       _cds_list_splice_tail(&($5)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.declaration_specifier);
-                       _cds_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
-               }
-       |       TYPEALIAS declaration_specifiers abstract_declarator_list COLON type_declarator_list SEMICOLON
+       |       TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
                {
+                       struct ctf_node *list;
+
                        $$ = make_node(scanner, NODE_TYPEALIAS);
                        $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
                        $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
-                       _cds_list_splice_tail(&($2)->tmp_head, &($$)->u.typealias.target->u.typealias_target.declaration_specifier);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.declaration_specifier);
-                       _cds_list_splice_tail(&($5)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
+
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
+                       _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
+
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
+                       _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
                }
        ;
 
@@ -1110,12 +1327,10 @@ event_declaration:
                event_declaration_begin event_declaration_end
                {
                        $$ = make_node(scanner, NODE_EVENT);
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                }
        |       event_declaration_begin ctf_assignment_expression_list event_declaration_end
                {
                        $$ = make_node(scanner, NODE_EVENT);
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                        if (set_parent_node($2, $$))
                                reparent_error(scanner, "event_declaration");
                }
@@ -1136,12 +1351,10 @@ stream_declaration:
                stream_declaration_begin stream_declaration_end
                {
                        $$ = make_node(scanner, NODE_STREAM);
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                }
        |       stream_declaration_begin ctf_assignment_expression_list stream_declaration_end
                {
                        $$ = make_node(scanner, NODE_STREAM);
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                        if (set_parent_node($2, $$))
                                reparent_error(scanner, "stream_declaration");
                }
@@ -1157,17 +1370,37 @@ stream_declaration_end:
                {       pop_scope(scanner);     }
        ;
 
+env_declaration:
+               env_declaration_begin env_declaration_end
+               {
+                       $$ = make_node(scanner, NODE_ENV);
+               }
+       |       env_declaration_begin ctf_assignment_expression_list env_declaration_end
+               {
+                       $$ = make_node(scanner, NODE_ENV);
+                       if (set_parent_node($2, $$))
+                               reparent_error(scanner, "env declaration");
+               }
+       ;
+
+env_declaration_begin:
+               ENV LBRAC
+               {       push_scope(scanner);    }
+       ;
+
+env_declaration_end:
+               RBRAC SEMICOLON
+               {       pop_scope(scanner);     }
+       ;
 
 trace_declaration:
                trace_declaration_begin trace_declaration_end
                {
                        $$ = make_node(scanner, NODE_TRACE);
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                }
        |       trace_declaration_begin ctf_assignment_expression_list trace_declaration_end
                {
                        $$ = make_node(scanner, NODE_TRACE);
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                        if (set_parent_node($2, $$))
                                reparent_error(scanner, "trace_declaration");
                }
@@ -1183,17 +1416,103 @@ trace_declaration_end:
                {       pop_scope(scanner);     }
        ;
 
+clock_declaration:
+               CLOCK clock_declaration_begin clock_declaration_end
+               {
+                       $$ = make_node(scanner, NODE_CLOCK);
+               }
+       |       CLOCK clock_declaration_begin ctf_assignment_expression_list clock_declaration_end
+               {
+                       $$ = make_node(scanner, NODE_CLOCK);
+                       if (set_parent_node($3, $$))
+                               reparent_error(scanner, "trace_declaration");
+               }
+       ;
+
+clock_declaration_begin:
+               LBRAC
+               {       push_scope(scanner);    }
+       ;
+
+clock_declaration_end:
+               RBRAC SEMICOLON
+               {       pop_scope(scanner);     }
+       ;
+
+callsite_declaration:
+               CALLSITE callsite_declaration_begin callsite_declaration_end
+               {
+                       $$ = make_node(scanner, NODE_CALLSITE);
+               }
+       |       CALLSITE callsite_declaration_begin ctf_assignment_expression_list callsite_declaration_end
+               {
+                       $$ = make_node(scanner, NODE_CALLSITE);
+                       if (set_parent_node($3, $$))
+                               reparent_error(scanner, "trace_declaration");
+               }
+       ;
+
+callsite_declaration_begin:
+               LBRAC
+               {       push_scope(scanner);    }
+       ;
+
+callsite_declaration_end:
+               RBRAC SEMICOLON
+               {       pop_scope(scanner);     }
+       ;
+
+integer_declaration_specifiers:
+               CONST
+               {
+                       struct ctf_node *node;
+
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       node = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       node->u.type_specifier.type = TYPESPEC_CONST;
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+               }
+       |       integer_type_specifier
+               {
+                       struct ctf_node *node;
+
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       node = $1;
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+               }
+       |       integer_declaration_specifiers CONST
+               {
+                       struct ctf_node *node;
+
+                       $$ = $1;
+                       node = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       node->u.type_specifier.type = TYPESPEC_CONST;
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+               }
+       |       integer_declaration_specifiers integer_type_specifier
+               {
+                       $$ = $1;
+                       bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
+               }
+       ;
+
 declaration_specifiers:
                CONST
                {
-                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_CONST;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
+                       struct ctf_node *node;
+
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       node = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       node->u.type_specifier.type = TYPESPEC_CONST;
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        |       type_specifier
                {
-                       $$ = $1;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
+                       struct ctf_node *node;
+
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       node = $1;
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        |       declaration_specifiers CONST
                {
@@ -1202,38 +1521,80 @@ declaration_specifiers:
                        $$ = $1;
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
                        node->u.type_specifier.type = TYPESPEC_CONST;
-                       cds_list_add_tail(&node->siblings, &($$)->tmp_head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        |       declaration_specifiers type_specifier
                {
                        $$ = $1;
-                       cds_list_add_tail(&($2)->siblings, &($$)->tmp_head);
+                       bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
                }
        ;
 
 type_declarator_list:
                type_declarator
-               {
-                       $$ = $1;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
-               }
+               {       $$ = $1;        }
        |       type_declarator_list COMMA type_declarator
                {
                        $$ = $1;
-                       cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+                       bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
                }
        ;
 
-abstract_type_declarator_list:
-               abstract_type_declarator
+integer_type_specifier:
+               CHAR
                {
-                       $$ = $1;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_CHAR;
                }
-       |       abstract_type_declarator_list COMMA abstract_type_declarator
+       |       SHORT
                {
-                       $$ = $1;
-                       cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_SHORT;
+               }
+       |       INT
+               {
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_INT;
+               }
+       |       LONG
+               {
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_LONG;
+               }
+       |       SIGNED
+               {
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_SIGNED;
+               }
+       |       UNSIGNED
+               {
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_UNSIGNED;
+               }
+       |       _BOOL
+               {
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_BOOL;
+               }
+       |       ID_TYPE
+               {
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_ID_TYPE;
+                       $$->u.type_specifier.id_type = yylval.gs->s;
+               }
+       |       INTEGER LBRAC RBRAC
+               {
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_INTEGER;
+                       $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
+               }
+       |       INTEGER LBRAC ctf_assignment_expression_list RBRAC
+               {
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_INTEGER;
+                       $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
+                       if (set_parent_node($3, $$->u.type_specifier.node))
+                               reparent_error(scanner, "integer reparent error");
                }
        ;
 
@@ -1293,6 +1654,11 @@ type_specifier:
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
                        $$->u.type_specifier.type = TYPESPEC_COMPLEX;
                }
+       |       _IMAGINARY
+               {
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_IMAGINARY;
+               }
        |       ID_TYPE
                {
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
@@ -1301,73 +1667,134 @@ type_specifier:
                }
        |       FLOATING_POINT LBRAC RBRAC
                {
-                       $$ = make_node(scanner, NODE_FLOATING_POINT);
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
+                       $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
                }
        |       FLOATING_POINT LBRAC ctf_assignment_expression_list RBRAC
                {
-                       $$ = make_node(scanner, NODE_FLOATING_POINT);
-                       if (set_parent_node($3, $$))
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_FLOATING_POINT;
+                       $$->u.type_specifier.node = make_node(scanner, NODE_FLOATING_POINT);
+                       if (set_parent_node($3, $$->u.type_specifier.node))
                                reparent_error(scanner, "floating point reparent error");
                }
        |       INTEGER LBRAC RBRAC
                {
-                       $$ = make_node(scanner, NODE_INTEGER);
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_INTEGER;
+                       $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
                }
        |       INTEGER LBRAC ctf_assignment_expression_list RBRAC
                {
-                       $$ = make_node(scanner, NODE_INTEGER);
-                       if (set_parent_node($3, $$))
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_INTEGER;
+                       $$->u.type_specifier.node = make_node(scanner, NODE_INTEGER);
+                       if (set_parent_node($3, $$->u.type_specifier.node))
                                reparent_error(scanner, "integer reparent error");
                }
+       |       STRING
+               {
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_STRING;
+                       $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
+               }
        |       STRING LBRAC RBRAC
                {
-                       $$ = make_node(scanner, NODE_STRING);
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_STRING;
+                       $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
                }
        |       STRING LBRAC ctf_assignment_expression_list RBRAC
                {
-                       $$ = make_node(scanner, NODE_STRING);
-                       if (set_parent_node($3, $$))
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_STRING;
+                       $$->u.type_specifier.node = make_node(scanner, NODE_STRING);
+                       if (set_parent_node($3, $$->u.type_specifier.node))
                                reparent_error(scanner, "string reparent error");
                }
        |       ENUM enum_type_specifier
-               {       $$ = $2;                }
+               {
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_ENUM;
+                       $$->u.type_specifier.node = $2;
+               }
        |       VARIANT variant_type_specifier
-               {       $$ = $2;                }
+               {
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_VARIANT;
+                       $$->u.type_specifier.node = $2;
+               }
        |       STRUCT struct_type_specifier
-               {       $$ = $2;                }
+               {
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       $$->u.type_specifier.type = TYPESPEC_STRUCT;
+                       $$->u.type_specifier.node = $2;
+               }
        ;
 
 struct_type_specifier:
                struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
                {
                        $$ = make_node(scanner, NODE_STRUCT);
-                       if (set_parent_node($2, $$))
+                       $$->u._struct.has_body = 1;
+                       if ($2 && set_parent_node($2, $$))
                                reparent_error(scanner, "struct reparent error");
                }
        |       IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
                {
                        $$ = make_node(scanner, NODE_STRUCT);
+                       $$->u._struct.has_body = 1;
                        $$->u._struct.name = $1->s;
-                       if (set_parent_node($3, $$))
+                       if ($3 && set_parent_node($3, $$))
                                reparent_error(scanner, "struct reparent error");
                }
        |       ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end
                {
                        $$ = make_node(scanner, NODE_STRUCT);
+                       $$->u._struct.has_body = 1;
                        $$->u._struct.name = $1->s;
-                       if (set_parent_node($3, $$))
+                       if ($3 && set_parent_node($3, $$))
                                reparent_error(scanner, "struct reparent error");
                }
        |       IDENTIFIER
                {
                        $$ = make_node(scanner, NODE_STRUCT);
+                       $$->u._struct.has_body = 0;
                        $$->u._struct.name = $1->s;
                }
        |       ID_TYPE
                {
                        $$ = make_node(scanner, NODE_STRUCT);
+                       $$->u._struct.has_body = 0;
                        $$->u._struct.name = $1->s;
                }
+       |       struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
+               {
+                       $$ = make_node(scanner, NODE_STRUCT);
+                       $$->u._struct.has_body = 1;
+                       bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
+                       if ($2 && set_parent_node($2, $$))
+                               reparent_error(scanner, "struct reparent error");
+               }
+       |       IDENTIFIER struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
+               {
+                       $$ = make_node(scanner, NODE_STRUCT);
+                       $$->u._struct.has_body = 1;
+                       $$->u._struct.name = $1->s;
+                       bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
+                       if ($3 && set_parent_node($3, $$))
+                               reparent_error(scanner, "struct reparent error");
+               }
+       |       ID_TYPE struct_declaration_begin struct_or_variant_declaration_list struct_declaration_end TOK_ALIGN LPAREN unary_expression RPAREN
+               {
+                       $$ = make_node(scanner, NODE_STRUCT);
+                       $$->u._struct.has_body = 1;
+                       $$->u._struct.name = $1->s;
+                       bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
+                       if ($3 && set_parent_node($3, $$))
+                               reparent_error(scanner, "struct reparent error");
+               }
        ;
 
 struct_declaration_begin:
@@ -1384,90 +1811,103 @@ variant_type_specifier:
                variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
-                       if (set_parent_node($2, $$))
+                       $$->u.variant.has_body = 1;
+                       if ($2 && set_parent_node($2, $$))
                                reparent_error(scanner, "variant reparent error");
                }
        |       LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
+                       $$->u.variant.has_body = 1;
                        $$->u.variant.choice = $2->s;
-                       if (set_parent_node($5, $$))
+                       if ($5 && set_parent_node($5, $$))
                                reparent_error(scanner, "variant reparent error");
                }
        |       LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
+                       $$->u.variant.has_body = 1;
                        $$->u.variant.choice = $2->s;
-                       if (set_parent_node($5, $$))
+                       if ($5 && set_parent_node($5, $$))
                                reparent_error(scanner, "variant reparent error");
                }
        |       IDENTIFIER variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
+                       $$->u.variant.has_body = 1;
                        $$->u.variant.name = $1->s;
-                       if (set_parent_node($3, $$))
+                       if ($3 && set_parent_node($3, $$))
                                reparent_error(scanner, "variant reparent error");
                }
        |       IDENTIFIER LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
+                       $$->u.variant.has_body = 1;
                        $$->u.variant.name = $1->s;
                        $$->u.variant.choice = $3->s;
-                       if (set_parent_node($6, $$))
+                       if ($6 && set_parent_node($6, $$))
                                reparent_error(scanner, "variant reparent error");
                }
        |       IDENTIFIER LT IDENTIFIER GT
                {
                        $$ = make_node(scanner, NODE_VARIANT);
+                       $$->u.variant.has_body = 0;
                        $$->u.variant.name = $1->s;
                        $$->u.variant.choice = $3->s;
                }
        |       IDENTIFIER LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
+                       $$->u.variant.has_body = 1;
                        $$->u.variant.name = $1->s;
                        $$->u.variant.choice = $3->s;
-                       if (set_parent_node($6, $$))
+                       if ($6 && set_parent_node($6, $$))
                                reparent_error(scanner, "variant reparent error");
                }
        |       IDENTIFIER LT ID_TYPE GT
                {
                        $$ = make_node(scanner, NODE_VARIANT);
+                       $$->u.variant.has_body = 0;
                        $$->u.variant.name = $1->s;
                        $$->u.variant.choice = $3->s;
                }
        |       ID_TYPE variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
+                       $$->u.variant.has_body = 1;
                        $$->u.variant.name = $1->s;
-                       if (set_parent_node($3, $$))
+                       if ($3 && set_parent_node($3, $$))
                                reparent_error(scanner, "variant reparent error");
                }
        |       ID_TYPE LT IDENTIFIER GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
+                       $$->u.variant.has_body = 1;
                        $$->u.variant.name = $1->s;
                        $$->u.variant.choice = $3->s;
-                       if (set_parent_node($6, $$))
+                       if ($6 && set_parent_node($6, $$))
                                reparent_error(scanner, "variant reparent error");
                }
        |       ID_TYPE LT IDENTIFIER GT
                {
                        $$ = make_node(scanner, NODE_VARIANT);
+                       $$->u.variant.has_body = 0;
                        $$->u.variant.name = $1->s;
                        $$->u.variant.choice = $3->s;
                }
        |       ID_TYPE LT ID_TYPE GT variant_declaration_begin struct_or_variant_declaration_list variant_declaration_end
                {
                        $$ = make_node(scanner, NODE_VARIANT);
+                       $$->u.variant.has_body = 1;
                        $$->u.variant.name = $1->s;
                        $$->u.variant.choice = $3->s;
-                       if (set_parent_node($6, $$))
+                       if ($6 && set_parent_node($6, $$))
                                reparent_error(scanner, "variant reparent error");
                }
        |       ID_TYPE LT ID_TYPE GT
                {
                        $$ = make_node(scanner, NODE_VARIANT);
+                       $$->u.variant.has_body = 0;
                        $$->u.variant.name = $1->s;
                        $$->u.variant.choice = $3->s;
                }
@@ -1483,129 +1923,105 @@ variant_declaration_end:
                {       pop_scope(scanner);     }
        ;
 
-type_specifier_or_integer_constant:
-               declaration_specifiers
-               {       $$ = $1;                }
-       |       DECIMAL_CONSTANT
-               {
-                       $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
-                       $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
-                       sscanf(yylval.gs->s, "%llu",
-                              &$$->u.unary_expression.u.unsigned_constant);
-               }
-       |       OCTAL_CONSTANT
-               {
-                       $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
-                       $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
-                       sscanf(yylval.gs->s, "0%llo",
-                              &$$->u.unary_expression.u.unsigned_constant);
-               }
-       |       HEXADECIMAL_CONSTANT
-               {
-                       $$ = make_node(scanner, NODE_UNARY_EXPRESSION);
-                       $$->u.unary_expression.type = UNARY_UNSIGNED_CONSTANT;
-                       sscanf(yylval.gs->s, "0x%llx",
-                              &$$->u.unary_expression.u.unsigned_constant);
-               }
-       ;
-
 enum_type_specifier:
                LBRAC enumerator_list RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
-                       _cds_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
+                       $$->u._enum.has_body = 1;
+                       _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       LT type_specifier_or_integer_constant GT LBRAC enumerator_list RBRAC
+       |       COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
-                       $$->u._enum.container_type = $2;
-                       _cds_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
+                       $$->u._enum.has_body = 1;
+                       ($$)->u._enum.container_type = $2;
+                       _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
                }
        |       IDENTIFIER LBRAC enumerator_list RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
+                       $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1->s;
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       IDENTIFIER LT type_specifier_or_integer_constant GT LBRAC enumerator_list RBRAC
+       |       IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
+                       $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1->s;
-                       $$->u._enum.container_type = $3;
-                       _cds_list_splice_tail(&($6)->tmp_head, &($$)->u._enum.enumerator_list);
+                       ($$)->u._enum.container_type = $3;
+                       _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
                }
        |       ID_TYPE LBRAC enumerator_list RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
+                       $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1->s;
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       ID_TYPE LT type_specifier_or_integer_constant GT LBRAC enumerator_list RBRAC
+       |       ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
+                       $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1->s;
-                       $$->u._enum.container_type = $3;
-                       _cds_list_splice_tail(&($6)->tmp_head, &($$)->u._enum.enumerator_list);
+                       ($$)->u._enum.container_type = $3;
+                       _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
                }
        |       LBRAC enumerator_list COMMA RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
-                       _cds_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
+                       $$->u._enum.has_body = 1;
+                       _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       LT type_specifier_or_integer_constant GT LBRAC enumerator_list COMMA RBRAC
+       |       COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
-                       $$->u._enum.container_type = $2;
-                       _cds_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
+                       $$->u._enum.has_body = 1;
+                       ($$)->u._enum.container_type = $2;
+                       _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
                }
        |       IDENTIFIER LBRAC enumerator_list COMMA RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
+                       $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1->s;
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       IDENTIFIER LT type_specifier_or_integer_constant GT LBRAC enumerator_list COMMA RBRAC
+       |       IDENTIFIER COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
+                       $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1->s;
-                       $$->u._enum.container_type = $3;
-                       _cds_list_splice_tail(&($6)->tmp_head, &($$)->u._enum.enumerator_list);
+                       ($$)->u._enum.container_type = $3;
+                       _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
                }
        |       IDENTIFIER
                {
                        $$ = make_node(scanner, NODE_ENUM);
+                       $$->u._enum.has_body = 0;
                        $$->u._enum.enum_id = $1->s;
                }
-       |       IDENTIFIER LT type_specifier_or_integer_constant GT
-               {
-                       $$ = make_node(scanner, NODE_ENUM);
-                       $$->u._enum.enum_id = $1->s;
-                       $$->u._enum.container_type = $3;
-               }
        |       ID_TYPE LBRAC enumerator_list COMMA RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
+                       $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1->s;
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._enum.enumerator_list);
                }
-       |       ID_TYPE LT type_specifier_or_integer_constant GT LBRAC enumerator_list COMMA RBRAC
+       |       ID_TYPE COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
+                       $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1->s;
-                       $$->u._enum.container_type = $3;
-                       _cds_list_splice_tail(&($6)->tmp_head, &($$)->u._enum.enumerator_list);
+                       ($$)->u._enum.container_type = $3;
+                       _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
                }
        |       ID_TYPE
                {
                        $$ = make_node(scanner, NODE_ENUM);
+                       $$->u._enum.has_body = 0;
                        $$->u._enum.enum_id = $1->s;
                }
-       |       ID_TYPE LT type_specifier_or_integer_constant GT
-               {
-                       $$ = make_node(scanner, NODE_ENUM);
-                       $$->u._enum.enum_id = $1->s;
-                       $$->u._enum.container_type = $3;
-               }
        ;
 
 struct_or_variant_declaration_list:
@@ -1615,99 +2031,139 @@ struct_or_variant_declaration_list:
                {
                        if ($1) {
                                $$ = $1;
-                               cds_list_add_tail(&($2)->siblings, &($$)->tmp_head);
+                               bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
                        } else {
                                $$ = $2;
-                               cds_list_add_tail(&($$)->siblings, &($$)->tmp_head);
+                               bt_list_add_tail(&($$)->siblings, &($$)->tmp_head);
                        }
                }
        ;
 
 struct_or_variant_declaration:
-               specifier_qualifier_list struct_or_variant_declarator_list SEMICOLON
+               declaration_specifiers struct_or_variant_declarator_list SEMICOLON
                {
+                       struct ctf_node *list;
+
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
                        $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
-                       _cds_list_splice_tail(&($1)->tmp_head, &($$)->u.struct_or_variant_declaration.declaration_specifier);
-                       _cds_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
+                       ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
+                       _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
                }
-       |       specifier_qualifier_list TYPEDEF specifier_qualifier_list type_declarator_list SEMICOLON
+       |       declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
                {
+                       struct ctf_node *list;
+
                        $$ = make_node(scanner, NODE_TYPEDEF);
-                       _cds_list_splice_tail(&($1)->tmp_head, &($$)->u._typedef.declaration_specifier);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.declaration_specifier);
-                       _cds_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       $$->u._typedef.type_specifier_list = list;
+                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
                }
-       |       TYPEDEF specifier_qualifier_list type_declarator_list SEMICOLON
+       |       TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
                {
+                       struct ctf_node *list;
+
                        $$ = make_node(scanner, NODE_TYPEDEF);
-                       _cds_list_splice_tail(&($2)->tmp_head, &($$)->u._typedef.declaration_specifier);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       $$->u._typedef.type_specifier_list = list;
+                       _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
                }
-       |       specifier_qualifier_list TYPEDEF type_declarator_list SEMICOLON
+       |       declaration_specifiers TYPEDEF type_declarator_list SEMICOLON
                {
+                       struct ctf_node *list;
+
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
                        $$ = make_node(scanner, NODE_TYPEDEF);
-                       _cds_list_splice_tail(&($1)->tmp_head, &($$)->u._typedef.declaration_specifier);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
                }
-       |       TYPEALIAS specifier_qualifier_list abstract_declarator_list COLON specifier_qualifier_list abstract_type_declarator_list SEMICOLON
-               {
-                       $$ = make_node(scanner, NODE_TYPEALIAS);
-                       $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
-                       $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
-                       _cds_list_splice_tail(&($2)->tmp_head, &($$)->u.typealias.target->u.typealias_target.declaration_specifier);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
-                       _cds_list_splice_tail(&($5)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.declaration_specifier);
-                       _cds_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
-               }
-       |       TYPEALIAS specifier_qualifier_list abstract_declarator_list COLON type_declarator_list SEMICOLON
+       |       TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
                {
+                       struct ctf_node *list;
+
                        $$ = make_node(scanner, NODE_TYPEALIAS);
                        $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
                        $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
-                       _cds_list_splice_tail(&($2)->tmp_head, &($$)->u.typealias.target->u.typealias_target.declaration_specifier);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.declaration_specifier);
-                       _cds_list_splice_tail(&($5)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
+
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
+                       _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
+
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
+                       _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
                }
        ;
 
-specifier_qualifier_list:
+alias_declaration_specifiers:
                CONST
                {
-                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER);
-                       $$->u.type_specifier.type = TYPESPEC_CONST;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
+                       struct ctf_node *node;
+
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       node = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       node->u.type_specifier.type = TYPESPEC_CONST;
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        |       type_specifier
                {
-                       $$ = $1;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
+                       struct ctf_node *node;
+
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       node = $1;
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
-       |       specifier_qualifier_list CONST
+       |       IDENTIFIER
+               {
+                       struct ctf_node *node;
+
+                       add_type(scanner, $1);
+                       $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       node = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       node->u.type_specifier.type = TYPESPEC_ID_TYPE;
+                       node->u.type_specifier.id_type = yylval.gs->s;
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+               }
+       |       alias_declaration_specifiers CONST
                {
                        struct ctf_node *node;
 
                        $$ = $1;
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
                        node->u.type_specifier.type = TYPESPEC_CONST;
-                       cds_list_add_tail(&node->siblings, &($$)->tmp_head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+               }
+       |       alias_declaration_specifiers type_specifier
+               {
+                       $$ = $1;
+                       bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
                }
-       |       specifier_qualifier_list type_specifier
+       |       alias_declaration_specifiers IDENTIFIER
                {
+                       struct ctf_node *node;
+
+                       add_type(scanner, $2);
                        $$ = $1;
-                       cds_list_add_tail(&($2)->siblings, &($$)->tmp_head);
+                       node = make_node(scanner, NODE_TYPE_SPECIFIER);
+                       node->u.type_specifier.type = TYPESPEC_ID_TYPE;
+                       node->u.type_specifier.id_type = yylval.gs->s;
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        ;
 
 struct_or_variant_declarator_list:
                struct_or_variant_declarator
-               {
-                       $$ = $1;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
-               }
+               {       $$ = $1;        }
        |       struct_or_variant_declarator_list COMMA struct_or_variant_declarator
                {
                        $$ = $1;
-                       cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+                       bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
                }
        ;
 
@@ -1726,14 +2182,11 @@ struct_or_variant_declarator:
 
 enumerator_list:
                enumerator
-               {
-                       $$ = $1;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
-               }
+               {       $$ = $1;        }
        |       enumerator_list COMMA enumerator
                {
                        $$ = $1;
-                       cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+                       bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
                }
        ;
 
@@ -1767,44 +2220,41 @@ enumerator:
                {
                        $$ = make_node(scanner, NODE_ENUMERATOR);
                        $$->u.enumerator.id = $1->s;
-                       cds_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
+                       bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
                }
        |       ID_TYPE EQUAL unary_expression_or_range
                {
                        $$ = make_node(scanner, NODE_ENUMERATOR);
                        $$->u.enumerator.id = $1->s;
-                       cds_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
+                       bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
                }
        |       keywords EQUAL unary_expression_or_range
                {
                        $$ = make_node(scanner, NODE_ENUMERATOR);
                        $$->u.enumerator.id = $1->s;
-                       cds_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
+                       bt_list_splice(&($3)->tmp_head, &($$)->u.enumerator.values);
                }
        |       STRING_LITERAL_START DQUOTE EQUAL unary_expression_or_range
                {
                        $$ = make_node(scanner, NODE_ENUMERATOR);
                        $$->u.enumerator.id = "";
-                       cds_list_splice(&($4)->tmp_head, &($$)->u.enumerator.values);
+                       bt_list_splice(&($4)->tmp_head, &($$)->u.enumerator.values);
                }
        |       STRING_LITERAL_START s_char_sequence DQUOTE EQUAL unary_expression_or_range
                {
                        $$ = make_node(scanner, NODE_ENUMERATOR);
                        $$->u.enumerator.id = $2->s;
-                       cds_list_splice(&($5)->tmp_head, &($$)->u.enumerator.values);
+                       bt_list_splice(&($5)->tmp_head, &($$)->u.enumerator.values);
                }
        ;
 
 abstract_declarator_list:
                abstract_declarator
-               {
-                       $$ = $1;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
-               }
+               {       $$ = $1;        }
        |       abstract_declarator_list COMMA abstract_declarator
                {
                        $$ = $1;
-                       cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+                       bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
                }
        ;
 
@@ -1814,7 +2264,7 @@ abstract_declarator:
        |       pointer direct_abstract_declarator
                {
                        $$ = $2;
-                       cds_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
+                       bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
                }
        ;
 
@@ -1837,12 +2287,13 @@ direct_abstract_declarator:
                        $$->u.type_declarator.type = TYPEDEC_NESTED;
                        $$->u.type_declarator.u.nested.type_declarator = $2;
                }
-       |       direct_abstract_declarator LSBRAC type_specifier_or_integer_constant RSBRAC
+       |       direct_abstract_declarator LSBRAC unary_expression RSBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
                        $$->u.type_declarator.type = TYPEDEC_NESTED;
                        $$->u.type_declarator.u.nested.type_declarator = $1;
-                       $$->u.type_declarator.u.nested.length = $3;
+                       BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
                }
        |       direct_abstract_declarator LSBRAC RSBRAC
                {
@@ -1853,114 +2304,120 @@ direct_abstract_declarator:
                }
        ;
 
-declarator:
-               direct_declarator
+alias_abstract_declarator_list:
+               alias_abstract_declarator
                {       $$ = $1;        }
-       |       pointer direct_declarator
+       |       alias_abstract_declarator_list COMMA alias_abstract_declarator
+               {
+                       $$ = $1;
+                       bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+               }
+       ;
+
+alias_abstract_declarator:
+               direct_alias_abstract_declarator
+               {       $$ = $1;        }
+       |       pointer direct_alias_abstract_declarator
                {
                        $$ = $2;
-                       cds_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
+                       bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
                }
        ;
 
-direct_declarator:
-               IDENTIFIER
+direct_alias_abstract_declarator:
+               /* empty */
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                       $$->u.type_declarator.type = TYPEDEC_ID;
-                       $$->u.type_declarator.u.id = $1->s;
+                        $$->u.type_declarator.type = TYPEDEC_ID;
+                       /* id is NULL */
                }
-       |       LPAREN declarator RPAREN
+       |       LPAREN alias_abstract_declarator RPAREN
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
                        $$->u.type_declarator.type = TYPEDEC_NESTED;
                        $$->u.type_declarator.u.nested.type_declarator = $2;
                }
-       |       direct_declarator LSBRAC type_specifier_or_integer_constant RSBRAC
+       |       direct_alias_abstract_declarator LSBRAC unary_expression RSBRAC
+               {
+                       $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
+                       $$->u.type_declarator.type = TYPEDEC_NESTED;
+                       $$->u.type_declarator.u.nested.type_declarator = $1;
+                       BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
+               }
+       |       direct_alias_abstract_declarator LSBRAC RSBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
                        $$->u.type_declarator.type = TYPEDEC_NESTED;
                        $$->u.type_declarator.u.nested.type_declarator = $1;
-                       $$->u.type_declarator.u.nested.length = $3;
+                       $$->u.type_declarator.u.nested.abstract_array = 1;
                }
        ;
 
-type_declarator:
-               direct_type_declarator
+declarator:
+               direct_declarator
                {       $$ = $1;        }
-       |       pointer direct_type_declarator
+       |       pointer direct_declarator
                {
                        $$ = $2;
-                       cds_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
+                       bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
                }
        ;
 
-direct_type_declarator:
+direct_declarator:
                IDENTIFIER
                {
-                       add_type(scanner, $1);
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
                        $$->u.type_declarator.type = TYPEDEC_ID;
                        $$->u.type_declarator.u.id = $1->s;
                }
-       |       LPAREN type_declarator RPAREN
+       |       LPAREN declarator RPAREN
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
                        $$->u.type_declarator.type = TYPEDEC_NESTED;
                        $$->u.type_declarator.u.nested.type_declarator = $2;
                }
-       |       direct_type_declarator LSBRAC type_specifier_or_integer_constant RSBRAC
+       |       direct_declarator LSBRAC unary_expression RSBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
                        $$->u.type_declarator.type = TYPEDEC_NESTED;
                        $$->u.type_declarator.u.nested.type_declarator = $1;
-                       $$->u.type_declarator.u.nested.length = $3;
+                       BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
                }
        ;
 
-abstract_type_declarator:
-               direct_abstract_type_declarator
+type_declarator:
+               direct_type_declarator
                {       $$ = $1;        }
-       |       pointer direct_abstract_type_declarator
+       |       pointer direct_type_declarator
                {
                        $$ = $2;
-                       cds_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
+                       bt_list_splice(&($1)->tmp_head, &($$)->u.type_declarator.pointers);
                }
        ;
 
-direct_abstract_type_declarator:
-               /* empty */
-               {
-                       $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                        $$->u.type_declarator.type = TYPEDEC_ID;
-                       /* id is NULL */
-               }
-       |       IDENTIFIER
+direct_type_declarator:
+               IDENTIFIER
                {
                        add_type(scanner, $1);
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
                        $$->u.type_declarator.type = TYPEDEC_ID;
                        $$->u.type_declarator.u.id = $1->s;
                }
-       |       LPAREN abstract_type_declarator RPAREN
+       |       LPAREN type_declarator RPAREN
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
                        $$->u.type_declarator.type = TYPEDEC_NESTED;
                        $$->u.type_declarator.u.nested.type_declarator = $2;
                }
-       |       direct_abstract_type_declarator LSBRAC type_specifier_or_integer_constant RSBRAC
-               {
-                       $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
-                       $$->u.type_declarator.type = TYPEDEC_NESTED;
-                       $$->u.type_declarator.u.nested.type_declarator = $1;
-                       $$->u.type_declarator.u.nested.length = $3;
-               }
-       |       direct_abstract_type_declarator LSBRAC RSBRAC
+       |       direct_type_declarator LSBRAC unary_expression RSBRAC
                {
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
                        $$->u.type_declarator.type = TYPEDEC_NESTED;
                        $$->u.type_declarator.u.nested.type_declarator = $1;
-                       $$->u.type_declarator.u.nested.abstract_array = 1;
+                       BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
                }
        ;
 
@@ -1968,20 +2425,17 @@ pointer:
                STAR
                {
                        $$ = make_node(scanner, NODE_POINTER);
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
                }
        |       STAR pointer
                {
                        $$ = make_node(scanner, NODE_POINTER);
-                       cds_list_splice(&($2)->tmp_head, &($$)->tmp_head);
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
+                       bt_list_splice(&($2)->tmp_head, &($$)->tmp_head);
                }
        |       STAR type_qualifier_list pointer
                {
                        $$ = make_node(scanner, NODE_POINTER);
                        $$->u.pointer.const_qualifier = 1;
-                       cds_list_splice(&($3)->tmp_head, &($$)->tmp_head);
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
+                       bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
                }
        ;
 
@@ -1995,14 +2449,11 @@ type_qualifier_list:
 
 ctf_assignment_expression_list:
                ctf_assignment_expression SEMICOLON
-               {
-                       $$ = $1;
-                       cds_list_add(&($$)->siblings, &($$)->tmp_head);
-               }
+               {       $$ = $1;        }
        |       ctf_assignment_expression_list ctf_assignment_expression SEMICOLON
                {
                        $$ = $1;
-                       cds_list_add_tail(&($2)->siblings, &($$)->tmp_head);
+                       bt_list_add_tail(&($2)->siblings, &($$)->tmp_head);
                }
        ;
 
@@ -2014,60 +2465,70 @@ ctf_assignment_expression:
                         * set_parent_node.
                         */
                        $$ = make_node(scanner, NODE_CTF_EXPRESSION);
-                       _cds_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
+                       _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
                        if ($1->u.unary_expression.type != UNARY_STRING)
                                reparent_error(scanner, "ctf_assignment_expression left expects string");
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
                }
-       |       unary_expression TYPEASSIGN type_specifier
+       |       unary_expression TYPEASSIGN declaration_specifiers      /* Only allow struct */
                {
                        /*
                         * Because we have left and right, cannot use
                         * set_parent_node.
                         */
                        $$ = make_node(scanner, NODE_CTF_EXPRESSION);
-                       _cds_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
+                       _bt_list_splice_tail(&($1)->tmp_head, &($$)->u.ctf_expression.left);
                        if ($1->u.unary_expression.type != UNARY_STRING)
                                reparent_error(scanner, "ctf_assignment_expression left expects string");
-                       cds_list_add(&($3)->siblings, &($3)->tmp_head);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.ctf_expression.right);
+                       bt_list_add_tail(&($3)->siblings, &($$)->u.ctf_expression.right);
                }
        |       declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list
                {
+                       struct ctf_node *list;
+
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
                        $$ = make_node(scanner, NODE_TYPEDEF);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.declaration_specifier);
-                       _cds_list_splice_tail(&($1)->tmp_head, &($$)->u._typedef.declaration_specifier);
-                       _cds_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
+                       ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
+                       _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
                }
        |       TYPEDEF declaration_specifiers type_declarator_list
                {
+                       struct ctf_node *list;
+
                        $$ = make_node(scanner, NODE_TYPEDEF);
-                       _cds_list_splice_tail(&($2)->tmp_head, &($$)->u._typedef.declaration_specifier);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       $$->u._typedef.type_specifier_list = list;
+                       _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
                }
        |       declaration_specifiers TYPEDEF type_declarator_list
                {
+                       struct ctf_node *list;
+
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
                        $$ = make_node(scanner, NODE_TYPEDEF);
-                       _cds_list_splice_tail(&($1)->tmp_head, &($$)->u._typedef.declaration_specifier);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
                }
-       |       TYPEALIAS declaration_specifiers abstract_declarator_list COLON declaration_specifiers abstract_type_declarator_list
-               {
-                       $$ = make_node(scanner, NODE_TYPEALIAS);
-                       $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
-                       $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
-                       _cds_list_splice_tail(&($2)->tmp_head, &($$)->u.typealias.target->u.typealias_target.declaration_specifier);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
-                       _cds_list_splice_tail(&($5)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.declaration_specifier);
-                       _cds_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
-               }
-       |       TYPEALIAS declaration_specifiers abstract_declarator_list COLON type_declarator_list
+       |       TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
                {
+                       struct ctf_node *list;
+
                        $$ = make_node(scanner, NODE_TYPEALIAS);
                        $$->u.typealias.target = make_node(scanner, NODE_TYPEALIAS_TARGET);
                        $$->u.typealias.alias = make_node(scanner, NODE_TYPEALIAS_ALIAS);
-                       _cds_list_splice_tail(&($2)->tmp_head, &($$)->u.typealias.target->u.typealias_target.declaration_specifier);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.declaration_specifier);
-                       _cds_list_splice_tail(&($5)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
+
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
+                       _bt_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
+
+                       list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
+                       $$->u.typealias.alias->u.typealias_alias.type_specifier_list = list;
+                       _bt_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
                }
        ;