projects / babeltrace.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Export the list header with a new namespace
[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 697f942c7cb4f3d2a937e0d7a6effbb22ae49812..84735941a45f07b0482156f6cacabf133bd4c03c 100644 (file)
--- a/formats/ctf/metadata/ctf-parser.y
+++ b/formats/ctf/metadata/ctf-parser.y
@@ -26,20 +26,16 @@
 #include <errno.h>
 #include <inttypes.h>
 #include <babeltrace/list.h>
-#include <babeltrace/babeltrace.h>
+#include <babeltrace/babeltrace-internal.h>
 #include "ctf-scanner.h"
 #include "ctf-parser.h"
 #include "ctf-ast.h"
 
 int yydebug;
 
-/*
- * TODO: support enum, variant and struct declarations in scopes.
- */
-
 /* 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) {
@@ -59,7 +55,7 @@ void yyrestart(FILE * in_str, yyscan_t scanner);
 int yydebug;
 
 struct gc_string {
-       struct cds_list_head gc;
+       struct bt_list_head gc;
        size_t alloclen;
        char s[];
 };
@@ -68,8 +64,10 @@ 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_CTF_EXPRESSION ] = "NODE_CTF_EXPRESSION",
        [ NODE_UNARY_EXPRESSION ] = "NODE_UNARY_EXPRESSION",
        [ NODE_TYPEDEF ] = "NODE_TYPEDEF",
@@ -110,7 +108,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;
 }
@@ -138,13 +136,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;
 }
@@ -232,9 +230,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);
-       cds_list_add(&node->siblings, &node->tmp_head);
+       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:
@@ -242,30 +240,36 @@ 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_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.type_declarators);
+               BT_INIT_LIST_HEAD(&node->u._typedef.type_declarators);
                break;
        case NODE_TYPEALIAS_TARGET:
-               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.type_declarators);
+               BT_INIT_LIST_HEAD(&node->u.typealias_alias.type_declarators);
                break;
        case NODE_TYPEALIAS:
                break;
@@ -273,38 +277,38 @@ static struct ctf_node *make_node(struct ctf_scanner *scanner,
        case NODE_TYPE_SPECIFIER:
                break;
        case NODE_TYPE_SPECIFIER_LIST:
-               CDS_INIT_LIST_HEAD(&node->u.type_specifier_list.head);
+               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.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);
-               CDS_INIT_LIST_HEAD(&node->u._struct.min_align);
+               BT_INIT_LIST_HEAD(&node->u._struct.declaration_list);
+               BT_INIT_LIST_HEAD(&node->u._struct.min_align);
                break;
 
        case NODE_UNKNOWN:
@@ -322,22 +326,28 @@ 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_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:
@@ -371,22 +381,28 @@ 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.declaration_list);
+               _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_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:
@@ -420,22 +436,28 @@ 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.declaration_list);
+               _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_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:
@@ -470,13 +492,15 @@ static int reparent_type_specifier(struct ctf_node *node,
 {
        switch (parent->type) {
        case NODE_TYPE_SPECIFIER_LIST:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.type_specifier_list.head);
+               _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_VARIANT:
        case NODE_STRUCT:
        case NODE_TYPEDEF:
@@ -509,22 +533,28 @@ static int reparent_type_specifier_list(struct ctf_node *node,
 {
        switch (parent->type) {
        case NODE_ROOT:
-               cds_list_add_tail(&node->siblings, &parent->u.root.declaration_list);
+               bt_list_add_tail(&node->siblings, &parent->u.root.declaration_list);
                break;
        case NODE_EVENT:
-               cds_list_add_tail(&node->siblings, &parent->u.event.declaration_list);
+               bt_list_add_tail(&node->siblings, &parent->u.event.declaration_list);
                break;
        case NODE_STREAM:
-               cds_list_add_tail(&node->siblings, &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_add_tail(&node->siblings, &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_VARIANT:
-               cds_list_add_tail(&node->siblings, &parent->u.variant.declaration_list);
+               bt_list_add_tail(&node->siblings, &parent->u.variant.declaration_list);
                break;
        case NODE_STRUCT:
-               cds_list_add_tail(&node->siblings, &parent->u._struct.declaration_list);
+               bt_list_add_tail(&node->siblings, &parent->u._struct.declaration_list);
                break;
        case NODE_TYPEDEF:
                parent->u._typedef.type_specifier_list = node;
@@ -571,22 +601,24 @@ 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_VARIANT:
        case NODE_STRUCT:
        case NODE_TYPEALIAS:
@@ -633,21 +665,35 @@ 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);
+                       _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);
+                       _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);
+                       _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;
                }
@@ -679,7 +725,7 @@ 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;
@@ -702,7 +748,7 @@ static int set_parent_node(struct ctf_node *node,
 
        case NODE_ENUMERATOR:
                if (parent->type == NODE_ENUM) {
-                       _cds_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
+                       _bt_list_splice_tail(&node->tmp_head, &parent->u._enum.enumerator_list);
                } else {
                        return -EPERM;
                }
@@ -710,10 +756,10 @@ static int set_parent_node(struct ctf_node *node,
        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;
@@ -745,11 +791,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);
 }
 
@@ -761,13 +807,15 @@ 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.declaration_list);
-       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);
        return ast;
 }
 
@@ -775,7 +823,7 @@ 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);
 }
 
@@ -809,7 +857,7 @@ struct ctf_scanner *ctf_scanner_alloc(FILE *input)
                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",
@@ -856,7 +904,7 @@ void ctf_scanner_free(struct ctf_scanner *scanner)
  */
 %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 TOK_ALIGN
+%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 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
@@ -875,7 +923,9 @@ 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> integer_declaration_specifiers
 %type <n> declaration_specifiers
 %type <n> alias_declaration_specifiers
@@ -966,8 +1016,12 @@ keywords:
                {       $$ = yylval.gs;         }
        |       STREAM
                {       $$ = yylval.gs;         }
+       |       ENV
+               {       $$ = yylval.gs;         }
        |       TRACE
                {       $$ = yylval.gs;         }
+       |       CLOCK
+               {       $$ = yylval.gs;         }
        |       TOK_ALIGN
                {       $$ = yylval.gs;         }
        ;
@@ -1079,8 +1133,8 @@ postfix_expression:
                        $$ = 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
                {
@@ -1088,8 +1142,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
                {
@@ -1097,8 +1151,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
                {
@@ -1106,8 +1160,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
                {
@@ -1115,8 +1169,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);
                }
        ;
 
@@ -1147,7 +1201,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
@@ -1163,8 +1217,12 @@ declaration:
                {       $$ = $1;        }
        |       stream_declaration
                {       $$ = $1;        }
+       |       env_declaration
+               {       $$ = $1;        }
        |       trace_declaration
                {       $$ = $1;        }
+       |       clock_declaration
+               {       $$ = $1;        }
        |       declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
                {
                        struct ctf_node *list;
@@ -1172,9 +1230,9 @@ declaration:
                        $$ = make_node(scanner, NODE_TYPEDEF);
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        $$->u._typedef.type_specifier_list = list;
-                       _cds_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _cds_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _cds_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
+                       _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
                {
@@ -1183,8 +1241,8 @@ declaration:
                        $$ = make_node(scanner, NODE_TYPEDEF);
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        $$->u._typedef.type_specifier_list = list;
-                       _cds_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       _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
                {
@@ -1193,8 +1251,8 @@ declaration:
                        $$ = make_node(scanner, NODE_TYPEDEF);
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        $$->u._typedef.type_specifier_list = list;
-                       _cds_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       _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 TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
                {
@@ -1206,13 +1264,13 @@ declaration:
 
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
-                       _cds_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
+                       _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;
-                       _cds_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _cds_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
+                       _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);
                }
        ;
 
@@ -1263,6 +1321,28 @@ 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
@@ -1287,6 +1367,29 @@ 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);     }
+       ;
+
 integer_declaration_specifiers:
                CONST
                {
@@ -1295,7 +1398,7 @@ integer_declaration_specifiers:
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
                        node->u.type_specifier.type = TYPESPEC_CONST;
-                       cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        |       integer_type_specifier
                {
@@ -1303,7 +1406,7 @@ integer_declaration_specifiers:
 
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        node = $1;
-                       cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        |       integer_declaration_specifiers CONST
                {
@@ -1312,12 +1415,12 @@ integer_declaration_specifiers:
                        $$ = $1;
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
                        node->u.type_specifier.type = TYPESPEC_CONST;
-                       cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        |       integer_declaration_specifiers integer_type_specifier
                {
                        $$ = $1;
-                       cds_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
                }
        ;
 
@@ -1329,7 +1432,7 @@ declaration_specifiers:
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
                        node->u.type_specifier.type = TYPESPEC_CONST;
-                       cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        |       type_specifier
                {
@@ -1337,7 +1440,7 @@ declaration_specifiers:
 
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        node = $1;
-                       cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        |       declaration_specifiers CONST
                {
@@ -1346,12 +1449,12 @@ declaration_specifiers:
                        $$ = $1;
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
                        node->u.type_specifier.type = TYPESPEC_CONST;
-                       cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        |       declaration_specifiers type_specifier
                {
                        $$ = $1;
-                       cds_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
                }
        ;
 
@@ -1361,7 +1464,7 @@ type_declarator_list:
        |       type_declarator_list COMMA type_declarator
                {
                        $$ = $1;
-                       cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+                       bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
                }
        ;
 
@@ -1598,7 +1701,7 @@ struct_type_specifier:
                {
                        $$ = make_node(scanner, NODE_STRUCT);
                        $$->u._struct.has_body = 1;
-                       cds_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
+                       bt_list_add_tail(&($6)->siblings, &$$->u._struct.min_align);
                        if ($2 && set_parent_node($2, $$))
                                reparent_error(scanner, "struct reparent error");
                }
@@ -1607,7 +1710,7 @@ struct_type_specifier:
                        $$ = make_node(scanner, NODE_STRUCT);
                        $$->u._struct.has_body = 1;
                        $$->u._struct.name = $1->s;
-                       cds_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
+                       bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
                        if ($3 && set_parent_node($3, $$))
                                reparent_error(scanner, "struct reparent error");
                }
@@ -1616,7 +1719,7 @@ struct_type_specifier:
                        $$ = make_node(scanner, NODE_STRUCT);
                        $$->u._struct.has_body = 1;
                        $$->u._struct.name = $1->s;
-                       cds_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
+                       bt_list_add_tail(&($7)->siblings, &$$->u._struct.min_align);
                        if ($3 && set_parent_node($3, $$))
                                reparent_error(scanner, "struct reparent error");
                }
@@ -1753,21 +1856,21 @@ enum_type_specifier:
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
-                       _cds_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
+                       _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
                }
        |       COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
                        ($$)->u._enum.container_type = $2;
-                       _cds_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
+                       _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 COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
                {
@@ -1775,14 +1878,14 @@ enum_type_specifier:
                        $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1->s;
                        ($$)->u._enum.container_type = $3;
-                       _cds_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
+                       _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 COLON integer_declaration_specifiers LBRAC enumerator_list RBRAC
                {
@@ -1790,27 +1893,27 @@ enum_type_specifier:
                        $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1->s;
                        ($$)->u._enum.container_type = $3;
-                       _cds_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
+                       _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
                }
        |       LBRAC enumerator_list COMMA RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
-                       _cds_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
+                       _bt_list_splice_tail(&($2)->tmp_head, &($$)->u._enum.enumerator_list);
                }
        |       COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
                {
                        $$ = make_node(scanner, NODE_ENUM);
                        $$->u._enum.has_body = 1;
                        ($$)->u._enum.container_type = $2;
-                       _cds_list_splice_tail(&($4)->tmp_head, &($$)->u._enum.enumerator_list);
+                       _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 COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
                {
@@ -1818,7 +1921,7 @@ enum_type_specifier:
                        $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1->s;
                        ($$)->u._enum.container_type = $3;
-                       _cds_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
+                       _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
                }
        |       IDENTIFIER
                {
@@ -1831,7 +1934,7 @@ enum_type_specifier:
                        $$ = 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 COLON integer_declaration_specifiers LBRAC enumerator_list COMMA RBRAC
                {
@@ -1839,7 +1942,7 @@ enum_type_specifier:
                        $$->u._enum.has_body = 1;
                        $$->u._enum.enum_id = $1->s;
                        ($$)->u._enum.container_type = $3;
-                       _cds_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
+                       _bt_list_splice_tail(&($5)->tmp_head, &($$)->u._enum.enumerator_list);
                }
        |       ID_TYPE
                {
@@ -1856,10 +1959,10 @@ 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);
                        }
                }
        ;
@@ -1870,10 +1973,10 @@ struct_or_variant_declaration:
                        struct ctf_node *list;
 
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       _cds_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
                        $$ = make_node(scanner, NODE_STRUCT_OR_VARIANT_DECLARATION);
                        ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
-                       _cds_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
+                       _bt_list_splice_tail(&($2)->tmp_head, &($$)->u.struct_or_variant_declaration.type_declarators);
                }
        |       declaration_specifiers TYPEDEF declaration_specifiers type_declarator_list SEMICOLON
                {
@@ -1882,9 +1985,9 @@ struct_or_variant_declaration:
                        $$ = make_node(scanner, NODE_TYPEDEF);
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        $$->u._typedef.type_specifier_list = list;
-                       _cds_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _cds_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _cds_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
+                       _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
                {
@@ -1893,18 +1996,18 @@ struct_or_variant_declaration:
                        $$ = make_node(scanner, NODE_TYPEDEF);
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        $$->u._typedef.type_specifier_list = list;
-                       _cds_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       _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;
 
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
-                       _cds_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
                        $$ = make_node(scanner, NODE_TYPEDEF);
                        ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
                }
        |       TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list SEMICOLON
                {
@@ -1916,13 +2019,13 @@ struct_or_variant_declaration:
 
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
-                       _cds_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
+                       _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;
-                       _cds_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _cds_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
+                       _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);
                }
        ;
 
@@ -1934,7 +2037,7 @@ alias_declaration_specifiers:
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
                        node->u.type_specifier.type = TYPESPEC_CONST;
-                       cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        |       type_specifier
                {
@@ -1942,7 +2045,7 @@ alias_declaration_specifiers:
 
                        $$ = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        node = $1;
-                       cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        |       IDENTIFIER
                {
@@ -1953,7 +2056,7 @@ alias_declaration_specifiers:
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
                        node->u.type_specifier.type = TYPESPEC_ID_TYPE;
                        node->u.type_specifier.id_type = yylval.gs->s;
-                       cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        |       alias_declaration_specifiers CONST
                {
@@ -1962,12 +2065,12 @@ alias_declaration_specifiers:
                        $$ = $1;
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
                        node->u.type_specifier.type = TYPESPEC_CONST;
-                       cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        |       alias_declaration_specifiers type_specifier
                {
                        $$ = $1;
-                       cds_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&($2)->siblings, &($$)->u.type_specifier_list.head);
                }
        |       alias_declaration_specifiers IDENTIFIER
                {
@@ -1978,7 +2081,7 @@ alias_declaration_specifiers:
                        node = make_node(scanner, NODE_TYPE_SPECIFIER);
                        node->u.type_specifier.type = TYPESPEC_ID_TYPE;
                        node->u.type_specifier.id_type = yylval.gs->s;
-                       cds_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
+                       bt_list_add_tail(&node->siblings, &($$)->u.type_specifier_list.head);
                }
        ;
 
@@ -1988,7 +2091,7 @@ struct_or_variant_declarator_list:
        |       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);
                }
        ;
 
@@ -2011,7 +2114,7 @@ enumerator_list:
        |       enumerator_list COMMA enumerator
                {
                        $$ = $1;
-                       cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+                       bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
                }
        ;
 
@@ -2045,31 +2148,31 @@ 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);
                }
        ;
 
@@ -2079,7 +2182,7 @@ abstract_declarator_list:
        |       abstract_declarator_list COMMA abstract_declarator
                {
                        $$ = $1;
-                       cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+                       bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
                }
        ;
 
@@ -2089,7 +2192,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);
                }
        ;
 
@@ -2117,8 +2220,8 @@ direct_abstract_declarator:
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
                        $$->u.type_declarator.type = TYPEDEC_NESTED;
                        $$->u.type_declarator.u.nested.type_declarator = $1;
-                       CDS_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
+                       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
                {
@@ -2135,7 +2238,7 @@ alias_abstract_declarator_list:
        |       alias_abstract_declarator_list COMMA alias_abstract_declarator
                {
                        $$ = $1;
-                       cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+                       bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
                }
        ;
 
@@ -2145,7 +2248,7 @@ alias_abstract_declarator:
        |       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);
                }
        ;
 
@@ -2167,8 +2270,8 @@ direct_alias_abstract_declarator:
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
                        $$->u.type_declarator.type = TYPEDEC_NESTED;
                        $$->u.type_declarator.u.nested.type_declarator = $1;
-                       CDS_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
+                       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
                {
@@ -2185,7 +2288,7 @@ 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);
                }
        ;
 
@@ -2207,8 +2310,8 @@ direct_declarator:
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
                        $$->u.type_declarator.type = TYPEDEC_NESTED;
                        $$->u.type_declarator.u.nested.type_declarator = $1;
-                       CDS_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
+                       BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
                }
        ;
 
@@ -2218,7 +2321,7 @@ 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);
                }
        ;
 
@@ -2241,8 +2344,8 @@ direct_type_declarator:
                        $$ = make_node(scanner, NODE_TYPE_DECLARATOR);
                        $$->u.type_declarator.type = TYPEDEC_NESTED;
                        $$->u.type_declarator.u.nested.type_declarator = $1;
-                       CDS_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
+                       BT_INIT_LIST_HEAD(&($$)->u.type_declarator.u.nested.length);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u.type_declarator.u.nested.length);
                }
        ;
 
@@ -2254,13 +2357,13 @@ pointer:
        |       STAR pointer
                {
                        $$ = make_node(scanner, NODE_POINTER);
-                       cds_list_splice(&($2)->tmp_head, &($$)->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);
+                       bt_list_splice(&($3)->tmp_head, &($$)->tmp_head);
                }
        ;
 
@@ -2278,7 +2381,7 @@ ctf_assignment_expression_list:
        |       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);
                }
        ;
 
@@ -2290,10 +2393,10 @@ 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 declaration_specifiers      /* Only allow struct */
                {
@@ -2302,21 +2405,21 @@ 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_add_tail(&($3)->siblings, &($$)->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);
-                       _cds_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _cds_list_splice_tail(&($3)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _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);
                        ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
-                       _cds_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
+                       _bt_list_splice_tail(&($4)->tmp_head, &($$)->u._typedef.type_declarators);
                }
        |       TYPEDEF declaration_specifiers type_declarator_list
                {
@@ -2325,18 +2428,18 @@ ctf_assignment_expression:
                        $$ = make_node(scanner, NODE_TYPEDEF);
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        $$->u._typedef.type_specifier_list = list;
-                       _cds_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       _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);
-                       _cds_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
+                       _bt_list_splice_tail(&($1)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
                        $$ = make_node(scanner, NODE_TYPEDEF);
                        ($$)->u.struct_or_variant_declaration.type_specifier_list = list;
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
+                       _bt_list_splice_tail(&($3)->tmp_head, &($$)->u._typedef.type_declarators);
                }
        |       TYPEALIAS declaration_specifiers abstract_declarator_list TYPEASSIGN alias_declaration_specifiers alias_abstract_declarator_list
                {
@@ -2348,12 +2451,12 @@ ctf_assignment_expression:
 
                        list = make_node(scanner, NODE_TYPE_SPECIFIER_LIST);
                        $$->u.typealias.target->u.typealias_target.type_specifier_list = list;
-                       _cds_list_splice_tail(&($2)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _cds_list_splice_tail(&($3)->tmp_head, &($$)->u.typealias.target->u.typealias_target.type_declarators);
+                       _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;
-                       _cds_list_splice_tail(&($5)->u.type_specifier_list.head, &list->u.type_specifier_list.head);
-                       _cds_list_splice_tail(&($6)->tmp_head, &($$)->u.typealias.alias->u.typealias_alias.type_declarators);
+                       _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);
                }
        ;
BabelTrace - Trace Format Babel Tower
This page took 0.048306 seconds and 4 git commands to generate.