Rename "declaration" to "definition"

[babeltrace.git] / formats / ctf / metadata / ctf-visitor-generate-io-struct.c

diff --git a/formats/ctf/metadata/ctf-visitor-generate-io-struct.c b/formats/ctf/metadata/ctf-visitor-generate-io-struct.c
index d3ee63fa99d4788c76bde546bf38b874684c6a97..2b8b676b3c36cef3beffc87a2c2ce66df4875abd 100644 (file)
--- a/formats/ctf/metadata/ctf-visitor-generate-io-struct.c
+++ b/formats/ctf/metadata/ctf-visitor-generate-io-struct.c
@@ -210,7 +210,7 @@ static
 struct ctf_type *ctf_type_specifier_visit(FILE *fd,
                                          int depth, struct list_head *head,
                                          struct type_scope *type_scope,
-                                         struct declaration_scope *declaration_scope)
+                                         struct definition_scope *definition_scope)
 {
        struct ctf_type *type;
        struct node *first;
@@ -247,19 +247,19 @@ static
 struct ctf_declaration *ctf_declaration_specifier_visit(FILE *fd,
                                        int depth, struct list_head *head,
                                        struct type_scope *type_scope,
-                                       struct declaration_scope *declaration_scope)
+                                       struct definition_scope *definition_scope)
 {
        struct ctf_declaration *declaration;
        struct ctf_type *type;
 
        type = ctf_type_specifier_visit(fd, depth, head, type_scope,
-                                       declaration_scope);
-       declaration = type->declaration_new(type, declaration_scope);
+                                       definition_scope);
+       declaration = type->declaration_new(type, definition_scope);
        if (type->id == CTF_TYPE_VARIANT) {
                struct declaration_variant *variant =
                        container_of(declaration, struct declaration_variant, p);
                struct declaration *enum_tag =
-                       lookup_field_declaration(enum_tag_name, declaration_scope);
+                       lookup_field_declaration(enum_tag_name, definition_scope);
                if (!enum_tag) {
                        fprintf(fd, "[error]: expected enumeration tag field %s for variant\n",
                                enum_tag_name);
@@ -279,7 +279,7 @@ static
 int ctf_typedef_declarator_visit(FILE *fd, int depth,
                                struct list_head *declaration_specifier,
                                struct node *type_declarator, struct type_scope *type_scope,
-                               struct declaration_scope *declaration_scope)
+                               struct definition_scope *definition_scope)
 {
        /*
         * Build the type using declaration specifier (creating
@@ -298,14 +298,14 @@ int ctf_typedef_visit(FILE *fd, int depth,
                      struct list_head *declaration_specifier,
                      struct list_head *type_declarators,
                      struct type_scope *type_scope,
-                     struct declaration_scope *declaration_scope)
+                     struct definition_scope *definition_scope)
 {
        struct ctf_node *iter;
 
        cds_list_for_each_entry(iter, type_declarators, siblings) {
                ret = ctf_typedef_declarator_visit(fd, depth + 1,
                        &node->u._typedef.declaration_specifier, iter,
-                       type_scope, declaration_scope);
+                       type_scope, definition_scope);
                if (ret)
                        return ret;
        }
@@ -315,7 +315,7 @@ int ctf_typedef_visit(FILE *fd, int depth,
 static
 int ctf_typealias_visit(FILE *fd, int depth, struct ctf_node *target,
                        struct ctf_node *alias, struct type_scope *type_scope,
-                       struct declaration_scope *declaration_scope)
+                       struct definition_scope *definition_scope)
 {
        /* Build target type, check that it is reachable in current type scope. */
        /* Only one type declarator is allowed */
@@ -334,14 +334,14 @@ int ctf_event_declaration_visit(FILE *fd, int depth, struct ctf_node *node, stru
                ret = ctf_typedef_visit(fd, depth + 1,
                                        &node->u._typedef.declaration_specifier,
                                        &node->u._typedef.type_declarators,
-                                       event->type_scope, event->declaration_scope);
+                                       event->type_scope, event->definition_scope);
                if (ret)
                        return ret;
                break;
        case NODE_TYPEALIAS:
                ret = ctf_typealias_visit(fd, depth + 1,
                                &node->u.typealias.target, &node->u.typealias.alias
-                               event->type_scope, event->declaration_scope);
+                               event->type_scope, event->definition_scope);
                if (ret)
                        return ret;
                break;
@@ -385,8 +385,8 @@ int ctf_event_declaration_visit(FILE *fd, int depth, struct ctf_node *node, stru
                                fprintf(stderr, "[error] %s: stream id %" PRIu64 " cannot be found\n", __func__, event->stream_id);
                                return -EINVAL;
                        }
-                       event->declaration_scope = new_declaration_scope(stream->declaration_scope);
-                       if (!event->declaration_scope) {
+                       event->definition_scope = new_definition_scope(stream->definition_scope);
+                       if (!event->definition_scope) {
                                fprintf(stderr, "[error] %s: Error allocating declaration scope\n", __func__);
                                return -EPERM;
                        }
@@ -394,11 +394,11 @@ int ctf_event_declaration_visit(FILE *fd, int depth, struct ctf_node *node, stru
                } else if (!strcmp(left, "context")) {
                        struct declaration *declaration;
 
-                       if (!event->declaration_scope)
+                       if (!event->definition_scope)
                                return -EPERM;
                        declaration = ctf_declaration_specifier_visit(fd, depth,
                                        &node->u.ctf_expression.right,
-                                       event->type_scope, event->declaration_scope);
+                                       event->type_scope, event->definition_scope);
                        if (!declaration)
                                return -EPERM;
                        if (declaration->type->id != CTF_TYPE_STRUCT)
@@ -407,11 +407,11 @@ int ctf_event_declaration_visit(FILE *fd, int depth, struct ctf_node *node, stru
                } else if (!strcmp(left, "fields")) {
                        struct declaration *declaration;
 
-                       if (!event->declaration_scope)
+                       if (!event->definition_scope)
                                return -EPERM;
                        declaration = ctf_declaration_specifier_visit(fd, depth,
                                        &node->u.ctf_expression.right,
-                                       event->type_scope, event->declaration_scope);
+                                       event->type_scope, event->definition_scope);
                        if (!declaration)
                                return -EPERM;
                        if (declaration->type->id != CTF_TYPE_STRUCT)
@@ -467,7 +467,7 @@ int ctf_event_visit(FILE *fd, int depth, struct ctf_node *node,
 error:
        declaration_unref(event->fields);
        declaration_unref(event->context);
-       free_declaration_scope(event->declaration_scope);
+       free_definition_scope(event->definition_scope);
        free_type_scope(event->type_scope);
        g_free(event);
        return ret;
@@ -484,14 +484,14 @@ int ctf_stream_declaration_visit(FILE *fd, int depth, struct ctf_node *node, str
                ret = ctf_typedef_visit(fd, depth + 1,
                                        &node->u._typedef.declaration_specifier,
                                        &node->u._typedef.type_declarators,
-                                       stream->type_scope, stream->declaration_scope);
+                                       stream->type_scope, stream->definition_scope);
                if (ret)
                        return ret;
                break;
        case NODE_TYPEALIAS:
                ret = ctf_typealias_visit(fd, depth + 1,
                                &node->u.typealias.target, &node->u.typealias.alias
-                               stream->type_scope, stream->declaration_scope);
+                               stream->type_scope, stream->definition_scope);
                if (ret)
                        return ret;
                break;
@@ -514,7 +514,7 @@ int ctf_stream_declaration_visit(FILE *fd, int depth, struct ctf_node *node, str
 
                        declaration = ctf_declaration_specifier_visit(fd, depth,
                                        &node->u.ctf_expression.right,
-                                       stream->type_scope, stream->declaration_scope);
+                                       stream->type_scope, stream->definition_scope);
                        if (!declaration)
                                return -EPERM;
                        if (declaration->type->id != CTF_TYPE_STRUCT)
@@ -525,7 +525,7 @@ int ctf_stream_declaration_visit(FILE *fd, int depth, struct ctf_node *node, str
 
                        declaration = ctf_declaration_specifier_visit(fd, depth,
                                        &node->u.ctf_expression.right,
-                                       stream->type_scope, stream->declaration_scope);
+                                       stream->type_scope, stream->definition_scope);
                        if (!declaration)
                                return -EPERM;
                        if (declaration->type->id != CTF_TYPE_STRUCT)
@@ -536,7 +536,7 @@ int ctf_stream_declaration_visit(FILE *fd, int depth, struct ctf_node *node, str
 
                        declaration = ctf_declaration_specifier_visit(fd, depth,
                                        &node->u.ctf_expression.right,
-                                       stream->type_scope, stream->declaration_scope);
+                                       stream->type_scope, stream->definition_scope);
                        if (!declaration)
                                return -EPERM;
                        if (declaration->type->id != CTF_TYPE_STRUCT)
@@ -564,7 +564,7 @@ int ctf_stream_visit(FILE *fd, int depth, struct ctf_node *node,
 
        stream = g_new0(struct ctf_stream, 1);
        stream->type_scope = new_type_scope(parent_type_scope);
-       stream->declaration_scope = new_declaration_scope(trace->declaration_scope);
+       stream->definition_scope = new_definition_scope(trace->definition_scope);
        stream->events_by_id = g_ptr_array_new();
        stream->event_quark_to_id = g_hash_table_new(g_int_hash, g_int_equal);
        cds_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
@@ -587,7 +587,7 @@ error:
        declaration_unref(stream->packet_context);
        g_ptr_array_free(stream->events_by_id, TRUE);
        g_hash_table_free(stream->event_quark_to_id);
-       free_declaration_scope(stream->declaration_scope);
+       free_definition_scope(stream->definition_scope);
        free_type_scope(stream->type_scope);
        g_free(stream);
        return ret;
@@ -603,14 +603,14 @@ int ctf_trace_declaration_visit(FILE *fd, int depth, struct ctf_node *node, stru
                ret = ctf_typedef_visit(fd, depth + 1,
                                        &node->u._typedef.declaration_specifier,
                                        &node->u._typedef.type_declarators,
-                                       trace->type_scope, trace->declaration_scope);
+                                       trace->type_scope, trace->definition_scope);
                if (ret)
                        return ret;
                break;
        case NODE_TYPEALIAS:
                ret = ctf_typealias_visit(fd, depth + 1,
                                &node->u.typealias.target, &node->u.typealias.alias
-                               trace->type_scope, trace->declaration_scope);
+                               trace->type_scope, trace->definition_scope);
                if (ret)
                        return ret;
                break;
@@ -677,7 +677,7 @@ int ctf_trace_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace
        if (trace->type_scope)
                return -EEXIST;
        trace->type_scope = new_type_scope(trace->root_type_scope);
-       trace->declaration_scope = new_declaration_scope(trace->root_declaration_scope);
+       trace->definition_scope = new_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);
@@ -704,7 +704,7 @@ int ctf_trace_visit(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace
 
 error:
        g_ptr_array_free(trace->streams, TRUE);
-       free_declaration_scope(stream->declaration_scope);
+       free_definition_scope(stream->definition_scope);
        free_type_scope(stream->type_scope);
        return ret;
 }
@@ -721,7 +721,7 @@ int _ctf_visitor(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace *t
                        ret = ctf_typedef_visit(fd, depth + 1,
                                                &iter->u._typedef.declaration_specifier,
                                                &iter->u._typedef.type_declarators,
-                                               trace->type_scope, trace->declaration_scope);
+                                               trace->type_scope, trace->definition_scope);
                        if (ret)
                                return ret;
                }
@@ -729,14 +729,14 @@ int _ctf_visitor(FILE *fd, int depth, struct ctf_node *node, struct ctf_trace *t
                                        siblings) {
                        ret = ctf_typealias_visit(fd, depth + 1,
                                        &iter->u.typealias.target, &iter->u.typealias.alias
-                                       trace->type_scope, trace->declaration_scope);
+                                       trace->type_scope, trace->definition_scope);
                        if (ret)
                                return ret;
                }
                cds_list_for_each_entry(iter, &node->u.root.declaration_specifier, siblings) {
                        ret = ctf_declaration_specifier_visit(fd, depth, iter,
                                        trace->root_type_scope,
-                                       trace->root_declaration_scope);
+                                       trace->root_definition_scope);
                        if (ret)
                                return ret;
                }