projects / babeltrace.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
cleanup: protected -> hidden: cleanup symbol table
[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 2c90ab483f165a4b33ff7193b356d87aed10efa0..28b7bebe60309e2420c45dc5d0ffb8e1cace28b1 100644 (file)
--- a/formats/ctf/metadata/ctf-parser.y
+++ b/formats/ctf/metadata/ctf-parser.y
@@ -31,11 +31,12 @@
 #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) {
@@ -46,16 +47,19 @@ _cds_list_splice_tail (struct cds_list_head *add, struct cds_list_head *head)
        }
 }
 
+__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);
+__attribute__((visibility("hidden")))
 int yylex_destroy(yyscan_t yyscanner);
+__attribute__((visibility("hidden")))
 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[];
 };
@@ -88,6 +92,7 @@ static const char *node_type_to_str[] = {
        [ NODE_STRUCT ] = "NODE_STRUCT",
 };
 
+__attribute__((visibility("hidden")))
 const char *node_type(struct ctf_node *node)
 {
        if (node->type < NR_NODE_TYPES)
@@ -108,7 +113,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;
 }
@@ -118,6 +123,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)
@@ -136,13 +142,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;
 }
@@ -196,6 +202,7 @@ static int lookup_type(struct ctf_scanner_scope *s, const char *id)
        return ret;
 }
 
+__attribute__((visibility("hidden")))
 int is_type(struct ctf_scanner *scanner, const char *id)
 {
        struct ctf_scanner_scope *it;
@@ -230,9 +237,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:
@@ -240,36 +247,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:
-               CDS_INIT_LIST_HEAD(&node->u.env.declaration_list);
+               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:
-               CDS_INIT_LIST_HEAD(&node->u.clock.declaration_list);
+               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;
@@ -277,38 +284,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:
@@ -326,28 +333,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:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
+               _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:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
+               _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:
@@ -381,28 +388,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:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
+               _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:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
+               _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:
@@ -436,28 +443,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:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.env.declaration_list);
+               _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:
-               _cds_list_splice_tail(&node->tmp_head, &parent->u.clock.declaration_list);
+               _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:
@@ -492,7 +499,7 @@ 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:
@@ -533,28 +540,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:
-               cds_list_add_tail(&node->siblings, &parent->u.env.declaration_list);
+               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:
-               cds_list_add_tail(&node->siblings, &parent->u.clock.declaration_list);
+               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;
@@ -601,16 +608,16 @@ 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:
@@ -665,35 +672,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) {
-                       _cds_list_splice_tail(&node->tmp_head, &parent->u.root.env);
+                       _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) {
-                       _cds_list_splice_tail(&node->tmp_head, &parent->u.root.clock);
+                       _bt_list_splice_tail(&node->tmp_head, &parent->u.root.clock);
                } else {
                        return -EPERM;
                }
@@ -725,7 +732,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;
@@ -748,7 +755,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;
                }
@@ -756,10 +763,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;
@@ -775,11 +782,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;
@@ -791,11 +800,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);
 }
 
@@ -807,15 +816,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.env);
-       CDS_INIT_LIST_HEAD(&ast->root.u.root.stream);
-       CDS_INIT_LIST_HEAD(&ast->root.u.root.event);
-       CDS_INIT_LIST_HEAD(&ast->root.u.root.clock);
+       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;
 }
 
@@ -823,7 +832,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);
 }
 
@@ -857,7 +866,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",
@@ -1016,6 +1025,8 @@ keywords:
                {       $$ = yylval.gs;         }
        |       STREAM
                {       $$ = yylval.gs;         }
+       |       ENV
+               {       $$ = yylval.gs;         }
        |       TRACE
                {       $$ = yylval.gs;         }
        |       CLOCK
@@ -1131,8 +1142,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
                {
@@ -1140,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 DOT ID_TYPE
                {
@@ -1149,8 +1160,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
                {
@@ -1158,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);
                }
        |       postfix_expression RARROW ID_TYPE
                {
@@ -1167,8 +1178,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);
                }
        ;
 
@@ -1199,7 +1210,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
@@ -1228,9 +1239,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
                {
@@ -1239,8 +1250,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
                {
@@ -1249,8 +1260,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
                {
@@ -1262,13 +1273,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);
                }
        ;
 
@@ -1396,7 +1407,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
                {
@@ -1404,7 +1415,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
                {
@@ -1413,12 +1424,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);
                }
        ;
 
@@ -1430,7 +1441,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
                {
@@ -1438,7 +1449,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
                {
@@ -1447,12 +1458,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);
                }
        ;
 
@@ -1462,7 +1473,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);
                }
        ;
 
@@ -1699,7 +1710,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");
                }
@@ -1708,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");
                }
@@ -1717,7 +1728,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");
                }
@@ -1854,21 +1865,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
                {
@@ -1876,14 +1887,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
                {
@@ -1891,27 +1902,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
                {
@@ -1919,7 +1930,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
                {
@@ -1932,7 +1943,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
                {
@@ -1940,7 +1951,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
                {
@@ -1957,10 +1968,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);
                        }
                }
        ;
@@ -1971,10 +1982,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
                {
@@ -1983,9 +1994,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
                {
@@ -1994,18 +2005,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
                {
@@ -2017,13 +2028,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);
                }
        ;
 
@@ -2035,7 +2046,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
                {
@@ -2043,7 +2054,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
                {
@@ -2054,7 +2065,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
                {
@@ -2063,12 +2074,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
                {
@@ -2079,7 +2090,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);
                }
        ;
 
@@ -2089,7 +2100,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);
                }
        ;
 
@@ -2112,7 +2123,7 @@ enumerator_list:
        |       enumerator_list COMMA enumerator
                {
                        $$ = $1;
-                       cds_list_add_tail(&($3)->siblings, &($$)->tmp_head);
+                       bt_list_add_tail(&($3)->siblings, &($$)->tmp_head);
                }
        ;
 
@@ -2146,31 +2157,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);
                }
        ;
 
@@ -2180,7 +2191,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);
                }
        ;
 
@@ -2190,7 +2201,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);
                }
        ;
 
@@ -2218,8 +2229,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
                {
@@ -2236,7 +2247,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);
                }
        ;
 
@@ -2246,7 +2257,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);
                }
        ;
 
@@ -2268,8 +2279,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
                {
@@ -2286,7 +2297,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);
                }
        ;
 
@@ -2308,8 +2319,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);
                }
        ;
 
@@ -2319,7 +2330,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);
                }
        ;
 
@@ -2342,8 +2353,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);
                }
        ;
 
@@ -2355,13 +2366,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);
                }
        ;
 
@@ -2379,7 +2390,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);
                }
        ;
 
@@ -2391,10 +2402,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 */
                {
@@ -2403,21 +2414,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
                {
@@ -2426,18 +2437,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
                {
@@ -2449,12 +2460,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.04858 seconds and 4 git commands to generate.