ctf visitor generate I/O struct: Compile fixes, part 1

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>

diff --git a/formats/ctf/metadata/ctf-visitor-generate-io-struct.c b/formats/ctf/metadata/ctf-visitor-generate-io-struct.c
index 2eb522cfa35d152ab9e0aba00b1d8316eaeb9289..d9b8d77481fd791b81186a8b486a2305b18d1675 100644 (file)
--- a/formats/ctf/metadata/ctf-visitor-generate-io-struct.c
+++ b/formats/ctf/metadata/ctf-visitor-generate-io-struct.c
@@ -26,6 +26,8 @@
 #include <endian.h>
 #include <errno.h>
 #include <babeltrace/list.h>
 #include <endian.h>
 #include <errno.h>
 #include <babeltrace/list.h>

+#include <babeltrace/types.h>
+#include <babeltrace/ctf/metadata.h>

 #include <uuid/uuid.h>
 #include "ctf-scanner.h"
 #include "ctf-parser.h"
 #include <uuid/uuid.h>
 #include "ctf-scanner.h"
 #include "ctf-parser.h"


@@ -52,26 +54,28 @@ char *concatenate_unary_strings(struct cds_list_head *head)
        GString *str;
        int i = 0;
 
        GString *str;
        int i = 0;
 

-       str = g_string_new();
+       str = g_string_new("");

        cds_list_for_each_entry(node, head, siblings) {
                char *src_string;
 
                assert(node->type == NODE_UNARY_EXPRESSION);
                assert(node->u.unary_expression.type == UNARY_STRING);
                assert((node->u.unary_expression.link == UNARY_LINK_UNKNOWN)
        cds_list_for_each_entry(node, head, siblings) {
                char *src_string;
 
                assert(node->type == NODE_UNARY_EXPRESSION);
                assert(node->u.unary_expression.type == UNARY_STRING);
                assert((node->u.unary_expression.link == UNARY_LINK_UNKNOWN)

-                       ^ (i != 0))
+                       ^ (i != 0));

                switch (node->u.unary_expression.link) {
                case UNARY_DOTLINK:
                switch (node->u.unary_expression.link) {
                case UNARY_DOTLINK:

-                       g_string_append(str, ".")
+                       g_string_append(str, ".");

                        break;
                case UNARY_ARROWLINK:
                        break;
                case UNARY_ARROWLINK:

-                       g_string_append(str, "->")
+                       g_string_append(str, "->");

                        break;
                case UNARY_DOTDOTDOT:
                        break;
                case UNARY_DOTDOTDOT:

-                       g_string_append(str, "...")
+                       g_string_append(str, "...");
+                       break;
+               default:

                        break;
                }
                        break;
                }

-               src_string = u.unary_expression.u.string;
+               src_string = node->u.unary_expression.u.string;

                g_string_append(str, src_string);
                i++;
        }
                g_string_append(str, src_string);
                i++;
        }


@@ -89,7 +93,7 @@ int get_unary_unsigned(struct cds_list_head *head, uint64_t *value)
                assert(node->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT);
                assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
                assert(i == 0);
                assert(node->u.unary_expression.type == UNARY_UNSIGNED_CONSTANT);
                assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
                assert(i == 0);

-               *value = node->u.unary_expression.unsigned_constant
+               *value = node->u.unary_expression.u.unsigned_constant;

                i++;
        }
        return 0;
                i++;
        }
        return 0;


@@ -109,8 +113,8 @@ int get_unary_uuid(struct cds_list_head *head, uuid_t *uuid)
                assert(node->u.unary_expression.type == UNARY_STRING);
                assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
                assert(i == 0);
                assert(node->u.unary_expression.type == UNARY_STRING);
                assert(node->u.unary_expression.link == UNARY_LINK_UNKNOWN);
                assert(i == 0);

-               src_string = u.unary_expression.u.string;
-               ret = uuid_parse(u.unary_expression.u.string, *uuid);
+               src_string = node->u.unary_expression.u.string;
+               ret = uuid_parse(node->u.unary_expression.u.string, *uuid);

        }
        return ret;
 }
        }
        return ret;
 }


@@ -124,7 +128,7 @@ struct ctf_stream *trace_stream_lookup(struct ctf_trace *trace, uint64_t stream_
 }
 
 static
 }
 
 static

-void visit_declaration_specifier(struct cds_list_head *declaration_specifier, GString *str)
+int visit_declaration_specifier(struct cds_list_head *declaration_specifier, GString *str)

 {
        struct ctf_node *iter;
        int alias_item_nr = 0;
 {
        struct ctf_node *iter;
        int alias_item_nr = 0;


@@ -230,12 +234,13 @@ GQuark create_typealias_identifier(FILE *fd, int depth,
        struct cds_list_head *declaration_specifier,
        struct ctf_node *node_type_declarator)
 {
        struct cds_list_head *declaration_specifier,
        struct ctf_node *node_type_declarator)
 {

+       struct ctf_node *iter;

        GString *str;
        GString *str;

-       const char *str_c;
+       char *str_c;

        GQuark alias_q;
        int ret;
 
        GQuark alias_q;
        int ret;
 

-       str = g_string_new();
+       str = g_string_new("");

        ret = visit_declaration_specifier(declaration_specifier, str);
        if (ret) {
                g_string_free(str, TRUE);
        ret = visit_declaration_specifier(declaration_specifier, str);
        if (ret) {
                g_string_free(str, TRUE);


@@ -309,51 +314,55 @@ struct declaration *ctf_type_declarator_visit(FILE *fd, int depth,
                return nested_declaration;
        } else {
                struct declaration *declaration;
                return nested_declaration;
        } else {
                struct declaration *declaration;

-               struct node *length;
+               struct cds_list_head *length;
+               struct ctf_node *first;

 
                /* TYPEDEC_NESTED */
 
                /* create array/sequence, pass nested_declaration as child. */
 
                /* TYPEDEC_NESTED */
 
                /* create array/sequence, pass nested_declaration as child. */

-               length = node_type_declarator->u.type_declarator.u.nested.length;
-               if (length) {
-                       switch (length->type) {
-                       case NODE_UNARY_EXPRESSION:
-                       {
-                               struct declaration_array *array_declaration;
-                               size_t len;
-
-                               if (length->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT) {
-                                       fprintf(stderr, "[error] %s: array: unexpected unary expression.\n", __func__);
-                                       return NULL;
-                               }
-                               len = length->u.unary_expression.u.unsigned_constant;
-                               array_declaration = array_declaration_new(len, nested_declaration,
-                                                       declaration_scope);
-                               declaration = &array_declaration->p;
-                               break;
-                       }
-                       case NODE_INTEGER:
-                       case NODE_TYPE_SPECIFIER:
-                       {
-                               struct declaration_sequence *sequence_declaration;
-                               struct declaration_integer *integer_declaration;
-                               GQuark dummy_id;
-
-                               declaration = ctf_type_declarator_visit(fd, depth,
-                                                       length,
-                                                       &dummy_id, NULL,
-                                                       declaration_scope,
-                                                       NULL, trace);
-                               assert(declaration->id == CTF_TYPE_INTEGER);
-                               integer_declaration = container_of(declaration, struct declaration_integer, p);
-                               declaration_sequence = sequence_declaration_new(integer_declaration,
-                                               nested_declaration, declaration_scope);
-                               declaration = &declaration_sequence->p;
-                               break;
-                       }
-                       default:
-                               assert(0);
+               length = &node_type_declarator->u.type_declarator.u.nested.length;
+               if (cds_list_empty(length)) {
+                       fprintf(stderr, "[error] %s: expecting length type or value.\n", __func__);
+                       return NULL;
+               }
+               first = _cds_list_first_entry(length, struct ctf_node, siblings);
+               switch (first->type) {
+               case NODE_UNARY_EXPRESSION:
+               {
+                       struct declaration_array *array_declaration;
+                       size_t len;
+
+                       if (first->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT) {
+                               fprintf(stderr, "[error] %s: array: unexpected unary expression.\n", __func__);
+                               return NULL;

                        }
                        }

+                       len = first->u.unary_expression.u.unsigned_constant;
+                       array_declaration = array_declaration_new(len, nested_declaration,
+                                               declaration_scope);
+                       declaration = &array_declaration->p;
+                       break;
+               }
+               case NODE_INTEGER:
+               case NODE_TYPE_SPECIFIER:
+               {
+                       struct declaration_sequence *sequence_declaration;
+                       struct declaration_integer *integer_declaration;
+                       GQuark dummy_id;
+
+                       declaration = ctf_type_declarator_visit(fd, depth,
+                                               length,
+                                               &dummy_id, NULL,
+                                               declaration_scope,
+                                               NULL, trace);
+                       assert(declaration->id == CTF_TYPE_INTEGER);
+                       integer_declaration = container_of(declaration, struct declaration_integer, p);
+                       sequence_declaration = sequence_declaration_new(integer_declaration,
+                                       nested_declaration, declaration_scope);
+                       declaration = &sequence_declaration->p;
+                       break;
+               }
+               default:
+                       assert(0);

                }
 
                /* Pass it as content of outer container */
                }
 
                /* Pass it as content of outer container */


@@ -393,7 +402,7 @@ int ctf_struct_type_declarators_visit(FILE *fd, int depth,
 
 static
 int ctf_variant_type_declarators_visit(FILE *fd, int depth,
 
 static
 int ctf_variant_type_declarators_visit(FILE *fd, int depth,

-       struct declaration_variant *variant_declaration,
+       struct declaration_untagged_variant *untagged_variant_declaration,

        struct cds_list_head *declaration_specifier,
        struct cds_list_head *type_declarators,
        struct declaration_scope *declaration_scope,
        struct cds_list_head *declaration_specifier,
        struct cds_list_head *type_declarators,
        struct declaration_scope *declaration_scope,


@@ -408,9 +417,9 @@ int ctf_variant_type_declarators_visit(FILE *fd, int depth,
                field_declaration = ctf_type_declarator_visit(fd, depth,
                                                declaration_specifier,
                                                &field_name, iter,
                field_declaration = ctf_type_declarator_visit(fd, depth,
                                                declaration_specifier,
                                                &field_name, iter,

-                                               variant_declaration->scope,
+                                               untagged_variant_declaration->scope,

                                                NULL, trace);
                                                NULL, trace);

-               variant_declaration_add_field(variant_declaration,
+               untagged_variant_declaration_add_field(untagged_variant_declaration,

                                              g_quark_to_string(field_name),
                                              field_declaration);
        }
                                              g_quark_to_string(field_name),
                                              field_declaration);
        }


@@ -449,9 +458,10 @@ int ctf_typealias_visit(FILE *fd, int depth, struct declaration_scope *scope,
                struct ctf_trace *trace)
 {
        struct declaration *type_declaration;
                struct ctf_trace *trace)
 {
        struct declaration *type_declaration;

-       struct ctf_node *iter, *node;
+       struct ctf_node *node;

        GQuark dummy_id;
        GQuark alias_q;
        GQuark dummy_id;
        GQuark alias_q;

+       int err;

 
        /* See ctf_visitor_type_declarator() in the semantic validator. */
 
 
        /* See ctf_visitor_type_declarator() in the semantic validator. */
 


@@ -459,9 +469,14 @@ int ctf_typealias_visit(FILE *fd, int depth, struct declaration_scope *scope,
         * Create target type declaration.
         */
 
         * Create target type declaration.
         */
 

+       if (cds_list_empty(&alias->u.typealias_target.type_declarators))
+               node = NULL;
+       else
+               node = _cds_list_first_entry(&alias->u.typealias_target.type_declarators,
+                               struct ctf_node, siblings);

        type_declaration = ctf_type_declarator_visit(fd, depth,
                &target->u.typealias_target.declaration_specifier,
        type_declaration = ctf_type_declarator_visit(fd, depth,
                &target->u.typealias_target.declaration_specifier,

-               &dummy_id, &target->u.typealias_target.type_declarators,
+               &dummy_id, node,

                scope, NULL, trace);
        if (!type_declaration) {
                fprintf(stderr, "[error] %s: problem creating type declaration\n", __func__);
                scope, NULL, trace);
        if (!type_declaration) {
                fprintf(stderr, "[error] %s: problem creating type declaration\n", __func__);


@@ -482,17 +497,17 @@ int ctf_typealias_visit(FILE *fd, int depth, struct declaration_scope *scope,
         */
 
        node = _cds_list_first_entry(&alias->u.typealias_alias.type_declarators,
         */
 
        node = _cds_list_first_entry(&alias->u.typealias_alias.type_declarators,

-                               struct node, siblings);
+                               struct ctf_node, siblings);

        alias_q = create_typealias_identifier(fd, depth,
                        &alias->u.typealias_alias.declaration_specifier, node);
        alias_q = create_typealias_identifier(fd, depth,
                        &alias->u.typealias_alias.declaration_specifier, node);

-       ret = register_declaration(alias_q, type_declaration, scope);
-       if (ret)
+       err = register_declaration(alias_q, type_declaration, scope);
+       if (err)

                goto error;
        return 0;
 
 error:
        type_declaration->declaration_free(type_declaration);
                goto error;
        return 0;
 
 error:
        type_declaration->declaration_free(type_declaration);

-       return ret;
+       return err;

 }
 
 static
 }
 
 static


@@ -500,7 +515,6 @@ int ctf_struct_declaration_list_visit(FILE *fd, int depth,
        struct ctf_node *iter, struct declaration_struct *struct_declaration,
        struct ctf_trace *trace)
 {
        struct ctf_node *iter, struct declaration_struct *struct_declaration,
        struct ctf_trace *trace)
 {

-       struct declaration *declaration;

        int ret;
 
        switch (iter->type) {
        int ret;
 
        switch (iter->type) {


@@ -527,7 +541,8 @@ int ctf_struct_declaration_list_visit(FILE *fd, int depth,
                ret = ctf_struct_type_declarators_visit(fd, depth,
                                struct_declaration,
                                &iter->u.struct_or_variant_declaration.declaration_specifier,
                ret = ctf_struct_type_declarators_visit(fd, depth,
                                struct_declaration,
                                &iter->u.struct_or_variant_declaration.declaration_specifier,

-                               &iter->u.struct_or_variant_declaration.type_declarators, trace);
+                               &iter->u.struct_or_variant_declaration.type_declarators,
+                               struct_declaration->scope, trace);

                if (ret)
                        return ret;
                break;
                if (ret)
                        return ret;
                break;


@@ -540,17 +555,17 @@ int ctf_struct_declaration_list_visit(FILE *fd, int depth,
 
 static
 int ctf_variant_declaration_list_visit(FILE *fd, int depth,
 
 static
 int ctf_variant_declaration_list_visit(FILE *fd, int depth,

-       struct ctf_node *iter, struct declaration_variant *variant_declaration,
+       struct ctf_node *iter,
+       struct declaration_untagged_variant *untagged_variant_declaration,

        struct ctf_trace *trace)
 {
        struct ctf_trace *trace)
 {

-       struct declaration *declaration;

        int ret;
 
        switch (iter->type) {
        case NODE_TYPEDEF:
                /* For each declarator, declare type and add type to variant declaration scope */
                ret = ctf_typedef_visit(fd, depth,
        int ret;
 
        switch (iter->type) {
        case NODE_TYPEDEF:
                /* For each declarator, declare type and add type to variant declaration scope */
                ret = ctf_typedef_visit(fd, depth,

-                       variant_declaration->scope,
+                       untagged_variant_declaration->scope,

                        &iter->u._typedef.declaration_specifier,
                        &iter->u._typedef.type_declarators, trace);
                if (ret)
                        &iter->u._typedef.declaration_specifier,
                        &iter->u._typedef.type_declarators, trace);
                if (ret)


@@ -559,7 +574,7 @@ int ctf_variant_declaration_list_visit(FILE *fd, int depth,
        case NODE_TYPEALIAS:
                /* Declare type with declarator and add type to variant declaration scope */
                ret = ctf_typealias_visit(fd, depth,
        case NODE_TYPEALIAS:
                /* Declare type with declarator and add type to variant declaration scope */
                ret = ctf_typealias_visit(fd, depth,

-                       variant_declaration->scope,
+                       untagged_variant_declaration->scope,

                        iter->u.typealias.target,
                        iter->u.typealias.alias, trace);
                if (ret)
                        iter->u.typealias.target,
                        iter->u.typealias.alias, trace);
                if (ret)


@@ -568,9 +583,10 @@ int ctf_variant_declaration_list_visit(FILE *fd, int depth,
        case NODE_STRUCT_OR_VARIANT_DECLARATION:
                /* Add field to structure declaration */
                ret = ctf_variant_type_declarators_visit(fd, depth,
        case NODE_STRUCT_OR_VARIANT_DECLARATION:
                /* Add field to structure declaration */
                ret = ctf_variant_type_declarators_visit(fd, depth,

-                               variant_declaration,
+                               untagged_variant_declaration,

                                &iter->u.struct_or_variant_declaration.declaration_specifier,
                                &iter->u.struct_or_variant_declaration.declaration_specifier,

-                               &iter->u.struct_or_variant_declaration.type_declarators, trace);
+                               &iter->u.struct_or_variant_declaration.type_declarators,
+                               untagged_variant_declaration->scope, trace);

                if (ret)
                        return ret;
                break;
                if (ret)
                        return ret;
                break;


@@ -582,14 +598,14 @@ int ctf_variant_declaration_list_visit(FILE *fd, int depth,
 }
 
 static
 }
 
 static

-struct declaration_struct *ctf_declaration_struct_visit(FILE *fd,
+struct declaration *ctf_declaration_struct_visit(FILE *fd,

        int depth, const char *name, struct cds_list_head *declaration_list,
        int has_body, struct declaration_scope *declaration_scope,
        struct ctf_trace *trace)
 {
        int depth, const char *name, struct cds_list_head *declaration_list,
        int has_body, struct declaration_scope *declaration_scope,
        struct ctf_trace *trace)
 {

-       struct declaration *declaration;

        struct declaration_struct *struct_declaration;
        struct ctf_node *iter;
        struct declaration_struct *struct_declaration;
        struct ctf_node *iter;

+       int ret;

 
        /*
         * For named struct (without body), lookup in
 
        /*
         * For named struct (without body), lookup in


@@ -601,7 +617,7 @@ struct declaration_struct *ctf_declaration_struct_visit(FILE *fd,
                struct_declaration =
                        lookup_struct_declaration(g_quark_from_string(name),
                                                  declaration_scope);
                struct_declaration =
                        lookup_struct_declaration(g_quark_from_string(name),
                                                  declaration_scope);

-               return struct_declaration;
+               return &struct_declaration->p;

        } else {
                /* For unnamed struct, create type */
                /* For named struct (with body), create type and add to declaration scope */
        } else {
                /* For unnamed struct, create type */
                /* For named struct (with body), create type and add to declaration scope */


@@ -613,7 +629,7 @@ struct declaration_struct *ctf_declaration_struct_visit(FILE *fd,
                                return NULL;
                        }
                }
                                return NULL;
                        }
                }

-               struct_declaration = struct_declaration_new(name, declaration_scope);
+               struct_declaration = struct_declaration_new(declaration_scope);

                cds_list_for_each_entry(iter, declaration_list, siblings) {
                        ret = ctf_struct_declaration_list_visit(fd, depth + 1, iter,
                                struct_declaration, trace);
                cds_list_for_each_entry(iter, declaration_list, siblings) {
                        ret = ctf_struct_declaration_list_visit(fd, depth + 1, iter,
                                struct_declaration, trace);


@@ -626,7 +642,7 @@ struct declaration_struct *ctf_declaration_struct_visit(FILE *fd,
                                        declaration_scope);
                        assert(!ret);
                }
                                        declaration_scope);
                        assert(!ret);
                }

-               return struct_declaration;
+               return &struct_declaration->p;

        }
 error:
        struct_declaration->p.declaration_free(&struct_declaration->p);
        }
 error:
        struct_declaration->p.declaration_free(&struct_declaration->p);


@@ -634,14 +650,16 @@ error:
 }
 
 static
 }
 
 static

-struct declaration_variant *ctf_declaration_variant_visit(FILE *fd,
-       int depth, const char *name, struct cds_list_head *declaration_list,
+struct declaration *ctf_declaration_variant_visit(FILE *fd,
+       int depth, const char *name, const char *choice,
+       struct cds_list_head *declaration_list,

        int has_body, struct declaration_scope *declaration_scope,
        struct ctf_trace *trace)
 {
        int has_body, struct declaration_scope *declaration_scope,
        struct ctf_trace *trace)
 {

-       struct declaration *declaration;
+       struct declaration_untagged_variant *untagged_variant_declaration;

        struct declaration_variant *variant_declaration;
        struct ctf_node *iter;
        struct declaration_variant *variant_declaration;
        struct ctf_node *iter;

+       int ret;

 
        /*
         * For named variant (without body), lookup in
 
        /*
         * For named variant (without body), lookup in


@@ -650,10 +668,9 @@ struct declaration_variant *ctf_declaration_variant_visit(FILE *fd,
         */
        if (!has_body) {
                assert(name);
         */
        if (!has_body) {
                assert(name);

-               variant_declaration =
+               untagged_variant_declaration =

                        lookup_variant_declaration(g_quark_from_string(name),
                                                   declaration_scope);
                        lookup_variant_declaration(g_quark_from_string(name),
                                                   declaration_scope);

-               return variant_declaration;

        } else {
                /* For unnamed variant, create type */
                /* For named variant (with body), create type and add to declaration scope */
        } else {
                /* For unnamed variant, create type */
                /* For named variant (with body), create type and add to declaration scope */


@@ -665,23 +682,35 @@ struct declaration_variant *ctf_declaration_variant_visit(FILE *fd,
                                return NULL;
                        }
                }
                                return NULL;
                        }
                }

-               variant_declaration = variant_declaration_new(name, declaration_scope);
+               untagged_variant_declaration = untagged_variant_declaration_new(declaration_scope);

                cds_list_for_each_entry(iter, declaration_list, siblings) {
                        ret = ctf_variant_declaration_list_visit(fd, depth + 1, iter,
                cds_list_for_each_entry(iter, declaration_list, siblings) {
                        ret = ctf_variant_declaration_list_visit(fd, depth + 1, iter,

-                               variant_declaration, trace);
+                               untagged_variant_declaration, trace);

                        if (ret)
                                goto error;
                }
                if (name) {
                        ret = register_variant_declaration(g_quark_from_string(name),
                        if (ret)
                                goto error;
                }
                if (name) {
                        ret = register_variant_declaration(g_quark_from_string(name),

-                                       variant_declaration,
+                                       untagged_variant_declaration,

                                        declaration_scope);
                        assert(!ret);
                }
                                        declaration_scope);
                        assert(!ret);
                }

-               return variant_declaration;
+       }
+       /*
+        * if tagged, create tagged variant and return. else return
+        * untagged variant.
+        */
+       if (!choice) {
+               return &untagged_variant_declaration->p;
+       } else {
+               variant_declaration = variant_declaration_new(untagged_variant_declaration, choice);
+               if (!variant_declaration)
+                       goto error;
+               declaration_unref(&untagged_variant_declaration->p);
+               return &variant_declaration->p;

        }
 error:
        }
 error:

-       variant_declaration->p.declaration_free(&variant_declaration->p);
+       untagged_variant_declaration->p.declaration_free(&variant_declaration->p);

        return NULL;
 }
 
        return NULL;
 }
 


@@ -694,11 +723,11 @@ int ctf_enumerator_list_visit(FILE *fd, int depth,
        struct ctf_node *iter;
 
        q = g_quark_from_string(enumerator->u.enumerator.id);
        struct ctf_node *iter;
 
        q = g_quark_from_string(enumerator->u.enumerator.id);

-       if (enum_declaration->integer->signedness) {
+       if (enum_declaration->integer_declaration->signedness) {

                int64_t start, end;
                int nr_vals = 0;
 
                int64_t start, end;
                int nr_vals = 0;
 

-               cds_list_for_each_entry(iter, enumerator->u.enumerator.values, siblings) {
+               cds_list_for_each_entry(iter, &enumerator->u.enumerator.values, siblings) {

                        int64_t *target;
 
                        assert(iter->type == NODE_UNARY_EXPRESSION);
                        int64_t *target;
 
                        assert(iter->type == NODE_UNARY_EXPRESSION);


@@ -727,12 +756,12 @@ int ctf_enumerator_list_visit(FILE *fd, int depth,
                if (nr_vals == 1)
                        end = start;
                enum_signed_insert(enum_declaration, start, end, q);
                if (nr_vals == 1)
                        end = start;
                enum_signed_insert(enum_declaration, start, end, q);

-       } else
+       } else {

                uint64_t start, end;
                int nr_vals = 0;
 
                uint64_t start, end;
                int nr_vals = 0;
 

-               cds_list_for_each_entry(iter, enumerator->u.enumerator.values, siblings) {
-                       int64_t *target;
+               cds_list_for_each_entry(iter, &enumerator->u.enumerator.values, siblings) {
+                       uint64_t *target;

 
                        assert(iter->type == NODE_UNARY_EXPRESSION);
                        if (nr_vals == 0)
 
                        assert(iter->type == NODE_UNARY_EXPRESSION);
                        if (nr_vals == 0)


@@ -782,6 +811,7 @@ struct declaration *ctf_declaration_enum_visit(FILE *fd, int depth,
        struct declaration_integer *integer_declaration;
        struct ctf_node *iter, *first;
        GQuark dummy_id;
        struct declaration_integer *integer_declaration;
        struct ctf_node *iter, *first;
        GQuark dummy_id;

+       int ret;

 
        /*
         * For named enum (without body), lookup in
 
        /*
         * For named enum (without body), lookup in


@@ -793,7 +823,7 @@ struct declaration *ctf_declaration_enum_visit(FILE *fd, int depth,
                enum_declaration =
                        lookup_enum_declaration(g_quark_from_string(name),
                                                declaration_scope);
                enum_declaration =
                        lookup_enum_declaration(g_quark_from_string(name),
                                                declaration_scope);

-               return enum_declaration;
+               return &enum_declaration->p;

        } else {
                /* For unnamed enum, create type */
                /* For named enum (with body), create type and add to declaration scope */
        } else {
                /* For unnamed enum, create type */
                /* For named enum (with body), create type and add to declaration scope */


@@ -806,11 +836,11 @@ struct declaration *ctf_declaration_enum_visit(FILE *fd, int depth,
                        }
                }
                if (cds_list_empty(container_type)) {
                        }
                }
                if (cds_list_empty(container_type)) {

-                               fprintf(stderr, "[error] %s: missing container type for enumeration\n", __func__, name);
+                               fprintf(stderr, "[error] %s: missing container type for enumeration\n", __func__);

                                return NULL;
                        
                }
                                return NULL;
                        
                }

-               first = _cds_list_first_entry(container_type, struct node, siblings);
+               first = _cds_list_first_entry(container_type, struct ctf_node, siblings);

                switch (first->type) {
                case NODE_INTEGER:
                case NODE_TYPE_SPECIFIER:
                switch (first->type) {
                case NODE_INTEGER:
                case NODE_TYPE_SPECIFIER:


@@ -822,11 +852,10 @@ struct declaration *ctf_declaration_enum_visit(FILE *fd, int depth,
                        assert(declaration->id == CTF_TYPE_INTEGER);
                        integer_declaration = container_of(declaration, struct declaration_integer, p);
                        break;
                        assert(declaration->id == CTF_TYPE_INTEGER);
                        integer_declaration = container_of(declaration, struct declaration_integer, p);
                        break;

-               }

                default:
                        assert(0);
                }
                default:
                        assert(0);
                }

-               enum_declaration = enum_declaration_new(name, integer_declaration);
+               enum_declaration = enum_declaration_new(integer_declaration);

                declaration_unref(&integer_declaration->p);     /* leave ref to enum */
                cds_list_for_each_entry(iter, enumerator_list, siblings) {
                        ret = ctf_enumerator_list_visit(fd, depth + 1, iter, enum_declaration);
                declaration_unref(&integer_declaration->p);     /* leave ref to enum */
                cds_list_for_each_entry(iter, enumerator_list, siblings) {
                        ret = ctf_enumerator_list_visit(fd, depth + 1, iter, enum_declaration);


@@ -839,7 +868,7 @@ struct declaration *ctf_declaration_enum_visit(FILE *fd, int depth,
                                        declaration_scope);
                        assert(!ret);
                }
                                        declaration_scope);
                        assert(!ret);
                }

-               return enum_declaration;
+               return &enum_declaration->p;

        }
 error:
        enum_declaration->p.declaration_free(&enum_declaration->p);
        }
 error:
        enum_declaration->p.declaration_free(&enum_declaration->p);


@@ -853,9 +882,11 @@ struct declaration *ctf_declaration_type_specifier_visit(FILE *fd, int depth,
 {
        GString *str;
        struct declaration *declaration;
 {
        GString *str;
        struct declaration *declaration;

-       const char *str_c;
+       char *str_c;
+       int ret;
+       GQuark id_q;

 
 

-       str = g_string_new();
+       str = g_string_new("");

        ret = visit_declaration_specifier(declaration_specifier, str);
        if (ret)
                return NULL;
        ret = visit_declaration_specifier(declaration_specifier, str);
        if (ret)
                return NULL;


@@ -870,7 +901,7 @@ struct declaration *ctf_declaration_type_specifier_visit(FILE *fd, int depth,
  * Returns 0/1 boolean, or < 0 on error.
  */
 static
  * Returns 0/1 boolean, or < 0 on error.
  */
 static

-int get_boolean(FILE *fd, int depth, struct node *unary_expression)
+int get_boolean(FILE *fd, int depth, struct ctf_node *unary_expression)

 {
        if (unary_expression->type != NODE_UNARY_EXPRESSION) {
                fprintf(stderr, "[error] %s: expecting unary expression\n",
 {
        if (unary_expression->type != NODE_UNARY_EXPRESSION) {
                fprintf(stderr, "[error] %s: expecting unary expression\n",


@@ -912,7 +943,8 @@ int get_boolean(FILE *fd, int depth, struct node *unary_expression)
 }
 
 static
 }
 
 static

-int get_byte_order(FILE *fd, int depth, struct node *unary_expression)
+int get_byte_order(FILE *fd, int depth, struct ctf_node *unary_expression,
+               struct ctf_trace *trace)

 {
        int byte_order;
 
 {
        int byte_order;
 


@@ -931,7 +963,7 @@ int get_byte_order(FILE *fd, int depth, struct node *unary_expression)
                byte_order = LITTLE_ENDIAN;
        else {
                fprintf(stderr, "[error] %s: unexpected string \"%s\". Should be \"native\", \"network\", \"be\" or \"le\".\n",
                byte_order = LITTLE_ENDIAN;
        else {
                fprintf(stderr, "[error] %s: unexpected string \"%s\". Should be \"native\", \"network\", \"be\" or \"le\".\n",

-                       __func__, right->u.unary_expression.u.string);
+                       __func__, unary_expression->u.unary_expression.u.string);

                return -EINVAL;
        }
        return byte_order;
                return -EINVAL;
        }
        return byte_order;


@@ -942,7 +974,7 @@ struct declaration *ctf_declaration_integer_visit(FILE *fd, int depth,
                struct cds_list_head *expressions,
                struct ctf_trace *trace)
 {
                struct cds_list_head *expressions,
                struct ctf_trace *trace)
 {

-       struct node *expression;
+       struct ctf_node *expression;

        uint64_t alignment, size;
        int byte_order = trace->byte_order;
        int signedness = 0;
        uint64_t alignment, size;
        int byte_order = trace->byte_order;
        int signedness = 0;


@@ -950,17 +982,17 @@ struct declaration *ctf_declaration_integer_visit(FILE *fd, int depth,
        struct declaration_integer *integer_declaration;
 
        cds_list_for_each_entry(expression, expressions, siblings) {
        struct declaration_integer *integer_declaration;
 
        cds_list_for_each_entry(expression, expressions, siblings) {

-               struct node *left, *right;
+               struct ctf_node *left, *right;

 
 

-               left = expression->u.ctf_expression.left;
-               right = expression->u.ctf_expression.right;
+               left = _cds_list_first_entry(&expression->u.ctf_expression.left, struct ctf_node, siblings);
+               right = _cds_list_first_entry(&expression->u.ctf_expression.right, struct ctf_node, siblings);

                assert(left->u.unary_expression.type == UNARY_STRING);
                if (!strcmp(left->u.unary_expression.u.string, "signed")) {
                        signedness = get_boolean(fd, depth, right);
                        if (signedness < 0)
                                return NULL;
                } else if (!strcmp(left->u.unary_expression.u.string, "byte_order")) {
                assert(left->u.unary_expression.type == UNARY_STRING);
                if (!strcmp(left->u.unary_expression.u.string, "signed")) {
                        signedness = get_boolean(fd, depth, right);
                        if (signedness < 0)
                                return NULL;
                } else if (!strcmp(left->u.unary_expression.u.string, "byte_order")) {

-                       byte_order = get_byte_order(fd, depth, right);
+                       byte_order = get_byte_order(fd, depth, right, trace);

                        if (byte_order < 0)
                                return NULL;
                } else if (!strcmp(left->u.unary_expression.u.string, "size")) {
                        if (byte_order < 0)
                                return NULL;
                } else if (!strcmp(left->u.unary_expression.u.string, "size")) {


@@ -1008,19 +1040,19 @@ struct declaration *ctf_declaration_floating_point_visit(FILE *fd, int depth,
                struct cds_list_head *expressions,
                struct ctf_trace *trace)
 {
                struct cds_list_head *expressions,
                struct ctf_trace *trace)
 {

-       struct node *expression;
+       struct ctf_node *expression;

        uint64_t alignment, exp_dig, mant_dig, byte_order = trace->byte_order;
        int has_alignment = 0, has_exp_dig = 0, has_mant_dig = 0;
        struct declaration_float *float_declaration;
 
        cds_list_for_each_entry(expression, expressions, siblings) {
        uint64_t alignment, exp_dig, mant_dig, byte_order = trace->byte_order;
        int has_alignment = 0, has_exp_dig = 0, has_mant_dig = 0;
        struct declaration_float *float_declaration;
 
        cds_list_for_each_entry(expression, expressions, siblings) {

-               struct node *left, *right;
+               struct ctf_node *left, *right;

 
 

-               left = expression->u.ctf_expression.left;
-               right = expression->u.ctf_expression.right;
+               left = _cds_list_first_entry(&expression->u.ctf_expression.left, struct ctf_node, siblings);
+               right = _cds_list_first_entry(&expression->u.ctf_expression.right, struct ctf_node, siblings);

                assert(left->u.unary_expression.type == UNARY_STRING);
                if (!strcmp(left->u.unary_expression.u.string, "byte_order")) {
                assert(left->u.unary_expression.type == UNARY_STRING);
                if (!strcmp(left->u.unary_expression.u.string, "byte_order")) {

-                       byte_order = get_byte_order(fd, depth, right);
+                       byte_order = get_byte_order(fd, depth, right, trace);

                        if (byte_order < 0)
                                return NULL;
                } else if (!strcmp(left->u.unary_expression.u.string, "exp_dig")) {
                        if (byte_order < 0)
                                return NULL;
                } else if (!strcmp(left->u.unary_expression.u.string, "exp_dig")) {


@@ -1080,19 +1112,19 @@ struct declaration *ctf_declaration_string_visit(FILE *fd, int depth,
                struct cds_list_head *expressions,
                struct ctf_trace *trace)
 {
                struct cds_list_head *expressions,
                struct ctf_trace *trace)
 {

-       struct node *expression;
+       struct ctf_node *expression;

        const char *encoding_c = NULL;
        enum ctf_string_encoding encoding = CTF_STRING_UTF8;
        struct declaration_string *string_declaration;
 
        cds_list_for_each_entry(expression, expressions, siblings) {
        const char *encoding_c = NULL;
        enum ctf_string_encoding encoding = CTF_STRING_UTF8;
        struct declaration_string *string_declaration;
 
        cds_list_for_each_entry(expression, expressions, siblings) {

-               struct node *left, *right;
+               struct ctf_node *left, *right;

 
 

-               left = expression->u.ctf_expression.left;
-               right = expression->u.ctf_expression.right;
+               left = _cds_list_first_entry(&expression->u.ctf_expression.left, struct ctf_node, siblings);
+               right = _cds_list_first_entry(&expression->u.ctf_expression.right, struct ctf_node, siblings);

                assert(left->u.unary_expression.type == UNARY_STRING);
                if (!strcmp(left->u.unary_expression.u.string, "encoding")) {
                assert(left->u.unary_expression.type == UNARY_STRING);
                if (!strcmp(left->u.unary_expression.u.string, "encoding")) {

-                       if (right->u.unary_expression.type != UNARY_UNSIGNED_STRING) {
+                       if (right->u.unary_expression.type != UNARY_STRING) {

                                fprintf(stderr, "[error] %s: encoding: expecting string\n",
                                        __func__);
                                return NULL;
                                fprintf(stderr, "[error] %s: encoding: expecting string\n",
                                        __func__);
                                return NULL;


@@ -1113,6 +1145,7 @@ struct declaration *ctf_declaration_string_visit(FILE *fd, int depth,
 
 /*
  * Also add named variant, struct or enum to the current declaration scope.
 
 /*
  * Also add named variant, struct or enum to the current declaration scope.

+ * FIXME: we are only taking the first one. check for root declaration specifiers list.

  */
 static
 struct declaration *ctf_declaration_specifier_visit(FILE *fd,
  */
 static
 struct declaration *ctf_declaration_specifier_visit(FILE *fd,


@@ -1120,10 +1153,9 @@ struct declaration *ctf_declaration_specifier_visit(FILE *fd,
                struct declaration_scope *declaration_scope,
                struct ctf_trace *trace)
 {
                struct declaration_scope *declaration_scope,
                struct ctf_trace *trace)
 {

-       struct declaration *declaration;
-       struct node *first;
+       struct ctf_node *first;

 
 

-       first = _cds_list_first_entry(head, struct node, siblings);
+       first = _cds_list_first_entry(head, struct ctf_node, siblings);

 
        switch (first->type) {
        case NODE_STRUCT:
 
        switch (first->type) {
        case NODE_STRUCT:


@@ -1136,6 +1168,7 @@ struct declaration *ctf_declaration_specifier_visit(FILE *fd,
        case NODE_VARIANT:
                return ctf_declaration_variant_visit(fd, depth,
                        first->u.variant.name,
        case NODE_VARIANT:
                return ctf_declaration_variant_visit(fd, depth,
                        first->u.variant.name,

+                       first->u.variant.choice,

                        &first->u.variant.declaration_list,
                        first->u.variant.has_body,
                        declaration_scope,
                        &first->u.variant.declaration_list,
                        first->u.variant.has_body,
                        declaration_scope,


@@ -1159,7 +1192,10 @@ struct declaration *ctf_declaration_specifier_visit(FILE *fd,
                        &first->u.string.expressions, trace);
        case NODE_TYPE_SPECIFIER:
                return ctf_declaration_type_specifier_visit(fd, depth,
                        &first->u.string.expressions, trace);
        case NODE_TYPE_SPECIFIER:
                return ctf_declaration_type_specifier_visit(fd, depth,

-                               head, declaration_scope, trace);
+                               head, declaration_scope);
+       default:
+               fprintf(stderr, "[error] %s: unexpected node type %d\n", __func__, (int) first->type);
+               return NULL;

        }
 }
 
        }
 }
 


@@ -1171,16 +1207,18 @@ int ctf_event_declaration_visit(FILE *fd, int depth, struct ctf_node *node, stru
        switch (node->type) {
        case NODE_TYPEDEF:
                ret = ctf_typedef_visit(fd, depth + 1,
        switch (node->type) {
        case NODE_TYPEDEF:
                ret = ctf_typedef_visit(fd, depth + 1,

+                                       event->declaration_scope,

                                        &node->u._typedef.declaration_specifier,
                                        &node->u._typedef.type_declarators,
                                        &node->u._typedef.declaration_specifier,
                                        &node->u._typedef.type_declarators,

-                                       event->declaration_scope);
+                                       trace);

                if (ret)
                        return ret;
                break;
        case NODE_TYPEALIAS:
                ret = ctf_typealias_visit(fd, depth + 1,
                if (ret)
                        return ret;
                break;
        case NODE_TYPEALIAS:
                ret = ctf_typealias_visit(fd, depth + 1,

-                               &node->u.typealias.target, &node->u.typealias.alias
-                               event->declaration_scope);
+                               event->declaration_scope,
+                               node->u.typealias.target, node->u.typealias.alias,
+                               trace);

                if (ret)
                        return ret;
                break;
                if (ret)
                        return ret;
                break;


@@ -1228,27 +1266,23 @@ int ctf_event_declaration_visit(FILE *fd, int depth, struct ctf_node *node, stru
                } else if (!strcmp(left, "context")) {
                        struct declaration *declaration;
 
                } else if (!strcmp(left, "context")) {
                        struct declaration *declaration;
 

-                       if (!event->definition_scope)
-                               return -EPERM;

                        declaration = ctf_declaration_specifier_visit(fd, depth,
                                        &node->u.ctf_expression.right,
                                        event->declaration_scope, trace);
                        if (!declaration)
                                return -EPERM;
                        declaration = ctf_declaration_specifier_visit(fd, depth,
                                        &node->u.ctf_expression.right,
                                        event->declaration_scope, trace);
                        if (!declaration)
                                return -EPERM;

-                       if (declaration->type->id != CTF_TYPE_STRUCT)
+                       if (declaration->id != CTF_TYPE_STRUCT)

                                return -EPERM;
                        event->context_decl = container_of(declaration, struct declaration_struct, p);
                } else if (!strcmp(left, "fields")) {
                        struct declaration *declaration;
 
                                return -EPERM;
                        event->context_decl = container_of(declaration, struct declaration_struct, p);
                } else if (!strcmp(left, "fields")) {
                        struct declaration *declaration;
 

-                       if (!event->definition_scope)
-                               return -EPERM;

                        declaration = ctf_declaration_specifier_visit(fd, depth,
                                        &node->u.ctf_expression.right,
                                        event->declaration_scope, trace);
                        if (!declaration)
                                return -EPERM;
                        declaration = ctf_declaration_specifier_visit(fd, depth,
                                        &node->u.ctf_expression.right,
                                        event->declaration_scope, trace);
                        if (!declaration)
                                return -EPERM;

-                       if (declaration->type->id != CTF_TYPE_STRUCT)
+                       if (declaration->id != CTF_TYPE_STRUCT)

                                return -EPERM;
                        event->fields_decl = container_of(declaration, struct declaration_struct, p);
                }
                                return -EPERM;
                        event->fields_decl = container_of(declaration, struct declaration_struct, p);
                }


@@ -1297,33 +1331,36 @@ int ctf_event_visit(FILE *fd, int depth, struct ctf_node *node,
        g_hash_table_insert(event->stream->event_quark_to_id,
                            (gpointer)(unsigned long) event->name,
                            &event->id);
        g_hash_table_insert(event->stream->event_quark_to_id,
                            (gpointer)(unsigned long) event->name,
                            &event->id);

-       parent_def_scope = stream->definition_scope;
+       parent_def_scope = event->stream->definition_scope;

        if (event->context_decl) {
                event->context =
        if (event->context_decl) {
                event->context =

-                       event->context_decl->definition_new(event->context_decl,
-                               parent_def_scope, 0, 0);
+                       container_of(
+                       event->context_decl->p.definition_new(&event->context_decl->p,
+                               parent_def_scope, 0, 0),
+                       struct definition_struct, p);

                set_dynamic_definition_scope(&event->context->p,
                                             event->context->scope,
                                             "event.context");
                parent_def_scope = event->context->scope;
                set_dynamic_definition_scope(&event->context->p,
                                             event->context->scope,
                                             "event.context");
                parent_def_scope = event->context->scope;

-               declaration_unref(event->context_decl);
+               declaration_unref(&event->context_decl->p);

        }
        if (event->fields_decl) {
                event->fields =
        }
        if (event->fields_decl) {
                event->fields =

-                       event->fields_decl->definition_new(event->fields_decl,
-                               parent_def_scope, 0, 0);
+                       container_of(
+                       event->fields_decl->p.definition_new(&event->fields_decl->p,
+                               parent_def_scope, 0, 0),
+                       struct definition_struct, p);

                set_dynamic_definition_scope(&event->fields->p,
                                             event->fields->scope,
                                             "event.fields");
                parent_def_scope = event->fields->scope;
                set_dynamic_definition_scope(&event->fields->p,
                                             event->fields->scope,
                                             "event.fields");
                parent_def_scope = event->fields->scope;

-               declaration_unref(event->fields_decl);
+               declaration_unref(&event->fields_decl->p);

        }
        return 0;
 
 error:
        }
        return 0;
 
 error:

-       declaration_unref(event->fields_decl);
-       declaration_unref(event->context_decl);
-       free_definition_scope(event->definition_scope);
+       declaration_unref(&event->fields_decl->p);
+       declaration_unref(&event->context_decl->p);

        free_declaration_scope(event->declaration_scope);
        g_free(event);
        return ret;
        free_declaration_scope(event->declaration_scope);
        g_free(event);
        return ret;


@@ -1338,16 +1375,18 @@ int ctf_stream_declaration_visit(FILE *fd, int depth, struct ctf_node *node, str
        switch (node->type) {
        case NODE_TYPEDEF:
                ret = ctf_typedef_visit(fd, depth + 1,
        switch (node->type) {
        case NODE_TYPEDEF:
                ret = ctf_typedef_visit(fd, depth + 1,

+                                       stream->declaration_scope,

                                        &node->u._typedef.declaration_specifier,
                                        &node->u._typedef.type_declarators,
                                        &node->u._typedef.declaration_specifier,
                                        &node->u._typedef.type_declarators,

-                                       stream->declaration_scope);
+                                       trace);

                if (ret)
                        return ret;
                break;
        case NODE_TYPEALIAS:
                ret = ctf_typealias_visit(fd, depth + 1,
                if (ret)
                        return ret;
                break;
        case NODE_TYPEALIAS:
                ret = ctf_typealias_visit(fd, depth + 1,

-                               &node->u.typealias.target, &node->u.typealias.alias
-                               stream->declaration_scope);
+                               stream->declaration_scope,
+                               node->u.typealias.target, node->u.typealias.alias,
+                               trace);

                if (ret)
                        return ret;
                break;
                if (ret)
                        return ret;
                break;


@@ -1357,23 +1396,23 @@ int ctf_stream_declaration_visit(FILE *fd, int depth, struct ctf_node *node, str
 
                left = concatenate_unary_strings(&node->u.ctf_expression.left);
                if (!strcmp(left, "stream_id")) {
 
                left = concatenate_unary_strings(&node->u.ctf_expression.left);
                if (!strcmp(left, "stream_id")) {

-                       if (CTF_EVENT_FIELD_IS_SET(event, stream_id))
+                       if (CTF_STREAM_FIELD_IS_SET(stream, stream_id))

                                return -EPERM;
                                return -EPERM;

-                       ret = get_unary_unsigned(&node->u.ctf_expression.right, &event->stream_id);
+                       ret = get_unary_unsigned(&node->u.ctf_expression.right, &stream->stream_id);

                        if (ret) {
                                fprintf(stderr, "[error] %s: unexpected unary expression for event stream_id\n", __func__);
                                return -EINVAL;
                        }
                        if (ret) {
                                fprintf(stderr, "[error] %s: unexpected unary expression for event stream_id\n", __func__);
                                return -EINVAL;
                        }

-                       CTF_EVENT_SET_FIELD(event, stream_id);
+                       CTF_STREAM_SET_FIELD(stream, stream_id);

                } else if (!strcmp(left, "event.header")) {
                        struct declaration *declaration;
 
                        declaration = ctf_declaration_specifier_visit(fd, depth,
                                        &node->u.ctf_expression.right,
                } else if (!strcmp(left, "event.header")) {
                        struct declaration *declaration;
 
                        declaration = ctf_declaration_specifier_visit(fd, depth,
                                        &node->u.ctf_expression.right,

-                                       stream->declaration_scope, stream->definition_scope, trace);
+                                       stream->declaration_scope, trace);

                        if (!declaration)
                                return -EPERM;
                        if (!declaration)
                                return -EPERM;

-                       if (declaration->type->id != CTF_TYPE_STRUCT)
+                       if (declaration->id != CTF_TYPE_STRUCT)

                                return -EPERM;
                        stream->event_header_decl = container_of(declaration, struct declaration_struct, p);
                } else if (!strcmp(left, "event.context")) {
                                return -EPERM;
                        stream->event_header_decl = container_of(declaration, struct declaration_struct, p);
                } else if (!strcmp(left, "event.context")) {


@@ -1384,7 +1423,7 @@ int ctf_stream_declaration_visit(FILE *fd, int depth, struct ctf_node *node, str
                                        stream->declaration_scope, trace);
                        if (!declaration)
                                return -EPERM;
                                        stream->declaration_scope, trace);
                        if (!declaration)
                                return -EPERM;

-                       if (declaration->type->id != CTF_TYPE_STRUCT)
+                       if (declaration->id != CTF_TYPE_STRUCT)

                                return -EPERM;
                        stream->event_context_decl = container_of(declaration, struct declaration_struct, p);
                } else if (!strcmp(left, "packet.context")) {
                                return -EPERM;
                        stream->event_context_decl = container_of(declaration, struct declaration_struct, p);
                } else if (!strcmp(left, "packet.context")) {


@@ -1395,7 +1434,7 @@ int ctf_stream_declaration_visit(FILE *fd, int depth, struct ctf_node *node, str
                                        stream->declaration_scope, trace);
                        if (!declaration)
                                return -EPERM;
                                        stream->declaration_scope, trace);
                        if (!declaration)
                                return -EPERM;

-                       if (declaration->type->id != CTF_TYPE_STRUCT)
+                       if (declaration->id != CTF_TYPE_STRUCT)

                                return -EPERM;
                        stream->packet_context_decl = container_of(declaration, struct declaration_struct, p);
                }
                                return -EPERM;
                        stream->packet_context_decl = container_of(declaration, struct declaration_struct, p);
                }


@@ -1428,7 +1467,7 @@ int ctf_stream_visit(FILE *fd, int depth, struct ctf_node *node,
                if (ret)
                        goto error;
        }
                if (ret)
                        goto error;
        }

-       if (!CTF_EVENT_FIELD_IS_SET(stream, stream_id)) {
+       if (!CTF_STREAM_FIELD_IS_SET(stream, stream_id)) {

                ret = -EPERM;
                goto error;
        }
                ret = -EPERM;
                goto error;
        }


@@ -1439,45 +1478,50 @@ int ctf_stream_visit(FILE *fd, int depth, struct ctf_node *node,
        parent_def_scope = NULL;
        if (stream->packet_context_decl) {
                stream->packet_context =
        parent_def_scope = NULL;
        if (stream->packet_context_decl) {
                stream->packet_context =

-                       stream->packet_context_decl->definition_new(stream->packet_context_decl,
-                               parent_def_scope, 0, 0);
+                       container_of(
+                       stream->packet_context_decl->p.definition_new(&stream->packet_context_decl->p,
+                               parent_def_scope, 0, 0),
+                       struct definition_struct, p);

                set_dynamic_definition_scope(&stream->packet_context->p,
                                             stream->packet_context->scope,
                                             "stream.packet.context");
                parent_def_scope = stream->packet_context->scope;
                set_dynamic_definition_scope(&stream->packet_context->p,
                                             stream->packet_context->scope,
                                             "stream.packet.context");
                parent_def_scope = stream->packet_context->scope;

-               declaration_unref(stream->packet_context_decl);
+               declaration_unref(&stream->packet_context_decl->p);

        }
        if (stream->event_header_decl) {
                stream->event_header =
        }
        if (stream->event_header_decl) {
                stream->event_header =

-                       stream->event_header_decl->definition_new(stream->event_header_decl,
-                               parent_def_scope, 0, 0);
+                       container_of(
+                       stream->event_header_decl->p.definition_new(&stream->event_header_decl->p,
+                               parent_def_scope, 0, 0),
+                       struct definition_struct, p);

                set_dynamic_definition_scope(&stream->event_header->p,
                                             stream->event_header->scope,
                                             "stream.event.header");
                parent_def_scope = stream->event_header->scope;
                set_dynamic_definition_scope(&stream->event_header->p,
                                             stream->event_header->scope,
                                             "stream.event.header");
                parent_def_scope = stream->event_header->scope;

-               declaration_unref(stream->event_header_decl);
+               declaration_unref(&stream->event_header_decl->p);

        }
        if (stream->event_context_decl) {
                stream->event_context =
        }
        if (stream->event_context_decl) {
                stream->event_context =

-                       stream->event_context_decl->definition_new(stream->event_context_decl,
-                               parent_def_scope, 0, 0);
+                       container_of(
+                       stream->event_context_decl->p.definition_new(&stream->event_context_decl->p,
+                               parent_def_scope, 0, 0),
+                       struct definition_struct, p);

                set_dynamic_definition_scope(&stream->event_context->p,
                                             stream->event_context->scope,
                                             "stream.event.context");
                parent_def_scope = stream->event_context->scope;
                set_dynamic_definition_scope(&stream->event_context->p,
                                             stream->event_context->scope,
                                             "stream.event.context");
                parent_def_scope = stream->event_context->scope;

-               declaration_unref(stream->event_context_decl);
+               declaration_unref(&stream->event_context_decl->p);

        }
        stream->definition_scope = parent_def_scope;
 
        return 0;
 
 error:
        }
        stream->definition_scope = parent_def_scope;
 
        return 0;
 
 error:

-       declaration_unref(stream->event_header);
-       declaration_unref(stream->event_context);
-       declaration_unref(stream->packet_context);
+       declaration_unref(&stream->event_header_decl->p);
+       declaration_unref(&stream->event_context_decl->p);
+       declaration_unref(&stream->packet_context_decl->p);

        g_ptr_array_free(stream->events_by_id, TRUE);
        g_ptr_array_free(stream->events_by_id, TRUE);

-       g_hash_table_free(stream->event_quark_to_id);
-       free_definition_scope(stream->definition_scope);
+       g_hash_table_destroy(stream->event_quark_to_id);

        free_declaration_scope(stream->declaration_scope);
        g_free(stream);
        return ret;
        free_declaration_scope(stream->declaration_scope);
        g_free(stream);
        return ret;


@@ -1491,16 +1535,18 @@ int ctf_trace_declaration_visit(FILE *fd, int depth, struct ctf_node *node, stru
        switch (node->type) {
        case NODE_TYPEDEF:
                ret = ctf_typedef_visit(fd, depth + 1,
        switch (node->type) {
        case NODE_TYPEDEF:
                ret = ctf_typedef_visit(fd, depth + 1,

+                                       trace->declaration_scope,

                                        &node->u._typedef.declaration_specifier,
                                        &node->u._typedef.type_declarators,
                                        &node->u._typedef.declaration_specifier,
                                        &node->u._typedef.type_declarators,

-                                       trace->declaration_scope);
+                                       trace);

                if (ret)
                        return ret;
                break;
        case NODE_TYPEALIAS:
                ret = ctf_typealias_visit(fd, depth + 1,
                if (ret)
                        return ret;
                break;
        case NODE_TYPEALIAS:
                ret = ctf_typealias_visit(fd, depth + 1,

-                               &node->u.typealias.target, &node->u.typealias.alias
-                               trace->declaration_scope);
+                               trace->declaration_scope,
+                               node->u.typealias.target, node->u.typealias.alias,
+                               trace);

                if (ret)
                        return ret;
                break;
                if (ret)
                        return ret;
                break;


@@ -1510,41 +1556,41 @@ int ctf_trace_declaration_visit(FILE *fd, int depth, struct ctf_node *node, stru
 
                left = concatenate_unary_strings(&node->u.ctf_expression.left);
                if (!strcmp(left, "major")) {
 
                left = concatenate_unary_strings(&node->u.ctf_expression.left);
                if (!strcmp(left, "major")) {

-                       if (CTF_EVENT_FIELD_IS_SET(trace, major))
+                       if (CTF_TRACE_FIELD_IS_SET(trace, major))

                                return -EPERM;
                        ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->major);
                        if (ret) {
                                fprintf(stderr, "[error] %s: unexpected unary expression for trace major number\n", __func__);
                                return -EINVAL;
                        }
                                return -EPERM;
                        ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->major);
                        if (ret) {
                                fprintf(stderr, "[error] %s: unexpected unary expression for trace major number\n", __func__);
                                return -EINVAL;
                        }

-                       CTF_EVENT_SET_FIELD(trace, major);
+                       CTF_TRACE_SET_FIELD(trace, major);

                } else if (!strcmp(left, "minor")) {
                } else if (!strcmp(left, "minor")) {

-                       if (CTF_EVENT_FIELD_IS_SET(trace, minor))
+                       if (CTF_TRACE_FIELD_IS_SET(trace, minor))

                                return -EPERM;
                        ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->minor);
                        if (ret) {
                                fprintf(stderr, "[error] %s: unexpected unary expression for trace minor number\n", __func__);
                                return -EINVAL;
                        }
                                return -EPERM;
                        ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->minor);
                        if (ret) {
                                fprintf(stderr, "[error] %s: unexpected unary expression for trace minor number\n", __func__);
                                return -EINVAL;
                        }

-                       CTF_EVENT_SET_FIELD(trace, minor);
+                       CTF_TRACE_SET_FIELD(trace, minor);

                } else if (!strcmp(left, "word_size")) {
                } else if (!strcmp(left, "word_size")) {

-                       if (CTF_EVENT_FIELD_IS_SET(trace, word_size))
+                       if (CTF_TRACE_FIELD_IS_SET(trace, word_size))

                                return -EPERM;
                        ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->word_size);
                        if (ret) {
                                fprintf(stderr, "[error] %s: unexpected unary expression for trace word_size\n", __func__);
                                return -EINVAL;
                        }
                                return -EPERM;
                        ret = get_unary_unsigned(&node->u.ctf_expression.right, &trace->word_size);
                        if (ret) {
                                fprintf(stderr, "[error] %s: unexpected unary expression for trace word_size\n", __func__);
                                return -EINVAL;
                        }

-                       CTF_EVENT_SET_FIELD(trace, word_size);
+                       CTF_TRACE_SET_FIELD(trace, word_size);

                } else if (!strcmp(left, "uuid")) {
                } else if (!strcmp(left, "uuid")) {

-                       if (CTF_EVENT_FIELD_IS_SET(trace, uuid))
+                       if (CTF_TRACE_FIELD_IS_SET(trace, uuid))

                                return -EPERM;
                        ret = get_unary_uuid(&node->u.ctf_expression.right, &trace->uuid);
                        if (ret) {
                                fprintf(stderr, "[error] %s: unexpected unary expression for trace uuid\n", __func__);
                                return -EINVAL;
                        }
                                return -EPERM;
                        ret = get_unary_uuid(&node->u.ctf_expression.right, &trace->uuid);
                        if (ret) {
                                fprintf(stderr, "[error] %s: unexpected unary expression for trace uuid\n", __func__);
                                return -EINVAL;
                        }

-                       CTF_EVENT_SET_FIELD(trace, uuid);
+                       CTF_TRACE_SET_FIELD(trace, uuid);

                }
                g_free(left);
                break;
                }
                g_free(left);
                break;


@@ -1566,26 +1612,25 @@ int ctf_trace_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace
        if (trace->declaration_scope)
                return -EEXIST;
        trace->declaration_scope = new_declaration_scope(trace->root_declaration_scope);
        if (trace->declaration_scope)
                return -EEXIST;
        trace->declaration_scope = new_declaration_scope(trace->root_declaration_scope);

-       trace->definition_scope = new_dynamic_definition_scope(trace->root_definition_scope);

        trace->streams = g_ptr_array_new();
        cds_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
                ret = ctf_trace_declaration_visit(fd, depth + 1, iter, trace);
                if (ret)
                        goto error;
        }
        trace->streams = g_ptr_array_new();
        cds_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
                ret = ctf_trace_declaration_visit(fd, depth + 1, iter, trace);
                if (ret)
                        goto error;
        }

-       if (!CTF_EVENT_FIELD_IS_SET(trace, major)) {
+       if (!CTF_TRACE_FIELD_IS_SET(trace, major)) {

                ret = -EPERM;
                goto error;
        }
                ret = -EPERM;
                goto error;
        }

-       if (!CTF_EVENT_FIELD_IS_SET(trace, minor)) {
+       if (!CTF_TRACE_FIELD_IS_SET(trace, minor)) {

                ret = -EPERM;
                goto error;
        }
                ret = -EPERM;
                goto error;
        }

-       if (!CTF_EVENT_FIELD_IS_SET(trace, uuid)) {
+       if (!CTF_TRACE_FIELD_IS_SET(trace, uuid)) {

                ret = -EPERM;
                goto error;
        }
                ret = -EPERM;
                goto error;
        }

-       if (!CTF_EVENT_FIELD_IS_SET(trace, word_size)) {
+       if (!CTF_TRACE_FIELD_IS_SET(trace, word_size)) {

                ret = -EPERM;
                goto error;
        }
                ret = -EPERM;
                goto error;
        }


@@ -1593,8 +1638,7 @@ int ctf_trace_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace
 
 error:
        g_ptr_array_free(trace->streams, TRUE);
 
 error:
        g_ptr_array_free(trace->streams, TRUE);

-       free_definition_scope(stream->definition_scope);
-       free_declaration_scope(stream->declaration_scope);
+       free_declaration_scope(trace->declaration_scope);

        return ret;
 }
 
        return ret;
 }
 


@@ -1611,17 +1655,19 @@ int ctf_visitor_construct_metadata(FILE *fd, int depth, struct ctf_node *node,
                cds_list_for_each_entry(iter, &node->u.root._typedef,
                                        siblings) {
                        ret = ctf_typedef_visit(fd, depth + 1,
                cds_list_for_each_entry(iter, &node->u.root._typedef,
                                        siblings) {
                        ret = ctf_typedef_visit(fd, depth + 1,

+                                               trace->root_declaration_scope,

                                                &iter->u._typedef.declaration_specifier,
                                                &iter->u._typedef.type_declarators,
                                                &iter->u._typedef.declaration_specifier,
                                                &iter->u._typedef.type_declarators,

-                                               trace->root_declaration_scope);
+                                               trace);

                        if (ret)
                                return ret;
                }
                cds_list_for_each_entry(iter, &node->u.root.typealias,
                                        siblings) {
                        ret = ctf_typealias_visit(fd, depth + 1,
                        if (ret)
                                return ret;
                }
                cds_list_for_each_entry(iter, &node->u.root.typealias,
                                        siblings) {
                        ret = ctf_typealias_visit(fd, depth + 1,

-                                       &iter->u.typealias.target, &iter->u.typealias.alias
-                                       trace->root_declaration_scope);
+                                       trace->root_declaration_scope,
+                                       iter->u.typealias.target, iter->u.typealias.alias,
+                                       trace);

                        if (ret)
                                return ret;
                }
                        if (ret)
                                return ret;
                }

diff --git a/include/babeltrace/ctf/metadata.h b/include/babeltrace/ctf/metadata.h
index 6c17b4102ad046424490d92e3534ec38841d648b..bb6dc6cb1042e2bc49d5b7327deb21d96d95473c 100644 (file)
--- a/include/babeltrace/ctf/metadata.h
+++ b/include/babeltrace/ctf/metadata.h
@@ -28,9 +28,8 @@ struct ctf_trace;
 struct ctf_stream;
 struct ctf_event;
 
 struct ctf_stream;
 struct ctf_event;
 

-#define CTF_TRACE_SET_FIELD(ctf_trace, field, value)                   \
+#define CTF_TRACE_SET_FIELD(ctf_trace, field)                          \

        do {                                                            \
        do {                                                            \

-               (ctf_trace)->(field) = (value);                         \

                (ctf_trace)->field_mask |= CTF_TRACE_ ## field;         \
        } while (0)
 
                (ctf_trace)->field_mask |= CTF_TRACE_ ## field;         \
        } while (0)
 


@@ -65,9 +64,8 @@ struct ctf_trace {
        } field_mask;
 };
 
        } field_mask;
 };
 

-#define CTF_STREAM_SET_FIELD(ctf_stream, field, value)                 \
+#define CTF_STREAM_SET_FIELD(ctf_stream, field)                                \

        do {                                                            \
        do {                                                            \

-               (ctf_stream)->(field) = (value);                        \

                (ctf_stream)->field_mask |= CTF_STREAM_ ## field;       \
        } while (0)
 
                (ctf_stream)->field_mask |= CTF_STREAM_ ## field;       \
        } while (0)
 

diff --git a/include/babeltrace/types.h b/include/babeltrace/types.h
index 19022e194e39d9cefb05b446e38fde6e35d34b9a..012391df67fd086264da607bca22869697b6e976 100644 (file)
--- a/include/babeltrace/types.h
+++ b/include/babeltrace/types.h
@@ -364,9 +364,9 @@ struct declaration_struct *
        lookup_struct_declaration(GQuark struct_name,
                                  struct declaration_scope *scope);
 int register_variant_declaration(GQuark variant_name,
        lookup_struct_declaration(GQuark struct_name,
                                  struct declaration_scope *scope);
 int register_variant_declaration(GQuark variant_name,

-                         struct declaration_variant *variant_declaration,
+                         struct declaration_untagged_variant *untagged_variant_declaration,

                          struct declaration_scope *scope);
                          struct declaration_scope *scope);

-struct declaration_variant *lookup_variant_declaration(GQuark variant_name,
+struct declaration_untagged_variant *lookup_variant_declaration(GQuark variant_name,

                                         struct declaration_scope *scope);
 int register_enum_declaration(GQuark enum_name,
                              struct declaration_enum *enum_declaration,
                                         struct declaration_scope *scope);
 int register_enum_declaration(GQuark enum_name,
                              struct declaration_enum *enum_declaration,

diff --git a/types/types.c b/types/types.c
index a8ead299d2cad665135671a6bc9110c262c4a06e..327ddbb3a1102976ebcb3733affd547eba7cf660 100644 (file)
--- a/types/types.c
+++ b/types/types.c
@@ -329,7 +329,7 @@ int register_struct_declaration(GQuark struct_name,
 }
 
 static
 }
 
 static

-struct declaration_variant *
+struct declaration_untagged_variant *

        lookup_variant_declaration_scope(GQuark variant_name,
                struct declaration_scope *scope)
 {
        lookup_variant_declaration_scope(GQuark variant_name,
                struct declaration_scope *scope)
 {


@@ -337,11 +337,11 @@ struct declaration_variant *
                                   (gconstpointer) (unsigned long) variant_name);
 }
 
                                   (gconstpointer) (unsigned long) variant_name);
 }
 

-struct declaration_variant *
+struct declaration_untagged_variant *

        lookup_variant_declaration(GQuark variant_name,
                struct declaration_scope *scope)
 {
        lookup_variant_declaration(GQuark variant_name,
                struct declaration_scope *scope)
 {

-       struct declaration_variant *declaration;
+       struct declaration_untagged_variant *declaration;

 
        while (scope) {
                declaration = lookup_variant_declaration_scope(variant_name, scope);
 
        while (scope) {
                declaration = lookup_variant_declaration_scope(variant_name, scope);


@@ -353,7 +353,7 @@ struct declaration_variant *
 }
 
 int register_variant_declaration(GQuark variant_name,
 }
 
 int register_variant_declaration(GQuark variant_name,

-               struct declaration_variant *variant_declaration,
+               struct declaration_untagged_variant *untagged_variant_declaration,

                struct declaration_scope *scope)
 {
        if (!variant_name)
                struct declaration_scope *scope)
 {
        if (!variant_name)


@@ -365,8 +365,8 @@ int register_variant_declaration(GQuark variant_name,
 
        g_hash_table_insert(scope->variant_declarations,
                            (gpointer) (unsigned long) variant_name,
 
        g_hash_table_insert(scope->variant_declarations,
                            (gpointer) (unsigned long) variant_name,

-                           variant_declaration);
-       declaration_ref(&variant_declaration->p);
+                           untagged_variant_declaration);
+       declaration_ref(&untagged_variant_declaration->p);

        return 0;
 }
 
        return 0;
 }