X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=formats%2Fctf%2Fir%2Fresolve.c;fp=formats%2Fctf%2Fir%2Fresolve.c;h=0000000000000000000000000000000000000000;hp=4bc4130f96856b0018e91e449038430618df963e;hb=dc3fffef7b84cc4af1a7c99828fd57a106cd2257;hpb=f3985ab106d89d8e764c1a8dd0c8bda09b755d10 diff --git a/formats/ctf/ir/resolve.c b/formats/ctf/ir/resolve.c deleted file mode 100644 index 4bc4130f..00000000 --- a/formats/ctf/ir/resolve.c +++ /dev/null @@ -1,1193 +0,0 @@ -/* - * resolve.c - * - * Babeltrace - CTF IR: Type resolving internal - * - * Copyright 2015 Jérémie Galarneau - * Copyright 2016 Philippe Proulx - * - * Authors: Jérémie Galarneau - * Philippe Proulx - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define _printf_error(fmt, args...) \ - printf_verbose("[resolving] " fmt, ## args) - -typedef GPtrArray type_stack; - -/* - * A stack frame. - * - * `type` contains a compound field type (structure, variant, array, - * or sequence) and `index` indicates the index of the field type in - * the upper frame (-1 for array and sequence field types). - * - * `type` is owned by the stack frame. - */ -struct type_stack_frame { - struct bt_ctf_field_type *type; - int index; -}; - -/* - * The current context of the resolving engine. - * - * `scopes` contain the 6 CTF scope field types (see CTF, sect. 7.3.2) - * in the following order: - * - * * Packet header - * * Packet context - * * Event header - * * Stream event context - * * Event context - * * Event payload - */ -struct resolve_context { - struct bt_value *environment; - struct bt_ctf_field_type *scopes[6]; - - /* Root scope being visited */ - enum bt_ctf_scope root_scope; - type_stack *type_stack; - struct bt_ctf_field_type *cur_field_type; -}; - -/* TSDL dynamic scope prefixes as defined in CTF Section 7.3.2 */ -static const char * const absolute_path_prefixes[] = { - [BT_CTF_SCOPE_ENV] = "env.", - [BT_CTF_SCOPE_TRACE_PACKET_HEADER] = "trace.packet.header.", - [BT_CTF_SCOPE_STREAM_PACKET_CONTEXT] = "stream.packet.context.", - [BT_CTF_SCOPE_STREAM_EVENT_HEADER] = "stream.event.header.", - [BT_CTF_SCOPE_STREAM_EVENT_CONTEXT] = "stream.event.context.", - [BT_CTF_SCOPE_EVENT_CONTEXT] = "event.context.", - [BT_CTF_SCOPE_EVENT_FIELDS] = "event.fields.", -}; - -/* Number of path tokens used for the absolute prefixes */ -static const int absolute_path_prefix_ptoken_counts[] = { - [BT_CTF_SCOPE_ENV] = 1, - [BT_CTF_SCOPE_TRACE_PACKET_HEADER] = 3, - [BT_CTF_SCOPE_STREAM_PACKET_CONTEXT] = 3, - [BT_CTF_SCOPE_STREAM_EVENT_HEADER] = 3, - [BT_CTF_SCOPE_STREAM_EVENT_CONTEXT] = 3, - [BT_CTF_SCOPE_EVENT_CONTEXT] = 2, - [BT_CTF_SCOPE_EVENT_FIELDS] = 2, -}; - -/* - * Destroys a type stack frame. - */ -static -void type_stack_destroy_notify(gpointer data) -{ - struct type_stack_frame *frame = data; - - BT_PUT(frame->type); - g_free(frame); -} - -/* - * Creates a type stack. - * - * Return value is owned by the caller. - */ -static -type_stack *type_stack_create(void) -{ - return g_ptr_array_new_with_free_func(type_stack_destroy_notify); -} - -/* - * Destroys a type stack. - */ -static -void type_stack_destroy(type_stack *stack) -{ - g_ptr_array_free(stack, TRUE); -} - -/* - * Pushes a field type onto a type stack. - * - * `type` is owned by the caller (stack frame gets a new reference). - */ -static -int type_stack_push(type_stack *stack, struct bt_ctf_field_type *type) -{ - int ret = 0; - struct type_stack_frame *frame = NULL; - - if (!stack || !type) { - ret = -1; - goto end; - } - - frame = g_new0(struct type_stack_frame, 1); - if (!frame) { - ret = -1; - goto end; - } - - frame->type = bt_get(type); - g_ptr_array_add(stack, frame); - -end: - return ret; -} - -/* - * Checks whether or not `stack` is empty. - */ -static -bool type_stack_empty(type_stack *stack) -{ - return stack->len == 0; -} - -/* - * Returns the number of frames in `stack`. - */ -static -size_t type_stack_size(type_stack *stack) -{ - return stack->len; -} - -/* - * Returns the top frame of `stack`. - * - * Return value is owned by `stack`. - */ -static -struct type_stack_frame *type_stack_peek(type_stack *stack) -{ - struct type_stack_frame *entry = NULL; - - if (!stack || type_stack_empty(stack)) { - goto end; - } - - entry = g_ptr_array_index(stack, stack->len - 1); -end: - return entry; -} - -/* - * Returns the frame at index `index` in `stack`. - * - * Return value is owned by `stack`. - */ -static -struct type_stack_frame *type_stack_at(type_stack *stack, - size_t index) -{ - struct type_stack_frame *entry = NULL; - - if (!stack || index >= stack->len) { - goto end; - } - - entry = g_ptr_array_index(stack, index); - -end: - return entry; -} - -/* - * Removes the top frame of `stack`. - */ -static -void type_stack_pop(type_stack *stack) -{ - if (!type_stack_empty(stack)) { - /* - * This will call the frame's destructor and free it, as - * well as put its contained field type. - */ - g_ptr_array_set_size(stack, stack->len - 1); - } -} - -/* - * Returns the scope field type of `scope` in the context `ctx`. - * - * Return value is owned by `ctx` on success. - */ -static -struct bt_ctf_field_type *get_type_from_ctx(struct resolve_context *ctx, - enum bt_ctf_scope scope) -{ - assert(scope >= BT_CTF_SCOPE_TRACE_PACKET_HEADER && - scope <= BT_CTF_SCOPE_EVENT_FIELDS); - - return ctx->scopes[scope - BT_CTF_SCOPE_TRACE_PACKET_HEADER]; -} - -/* - * Returns the CTF scope from a path string. May return - * CTF_NODE_UNKNOWN if the path is found to be relative. - */ -static -enum bt_ctf_scope get_root_scope_from_absolute_pathstr(const char *pathstr) -{ - enum bt_ctf_scope scope; - enum bt_ctf_scope ret = BT_CTF_SCOPE_UNKNOWN; - const size_t prefixes_count = sizeof(absolute_path_prefixes) / - sizeof(*absolute_path_prefixes); - - for (scope = BT_CTF_SCOPE_ENV; scope < BT_CTF_SCOPE_ENV + - prefixes_count; scope++) { - /* - * Chech if path string starts with a known absolute - * path prefix. - * - * Refer to CTF 7.3.2 STATIC AND DYNAMIC SCOPES. - */ - if (strncmp(pathstr, absolute_path_prefixes[scope], - strlen(absolute_path_prefixes[scope]))) { - /* Prefix does not match: try the next one */ - continue; - } - - /* Found it! */ - ret = scope; - goto end; - } - -end: - return ret; -} - -/* - * Destroys a path token. - */ -static -void ptokens_destroy_func(gpointer ptoken, gpointer data) -{ - g_string_free(ptoken, TRUE); -} - -/* - * Destroys a path token list. - */ -static -void ptokens_destroy(GList *ptokens) -{ - if (!ptokens) { - return; - } - - g_list_foreach(ptokens, ptokens_destroy_func, NULL); - g_list_free(ptokens); -} - -/* - * Returns the string contained in a path token. - */ -static -const char *ptoken_get_string(GList *ptoken) -{ - GString *tokenstr = (GString *) ptoken->data; - - return tokenstr->str; -} - -/* - * Converts a path string to a path token list, that is, splits the - * individual words of a path string into a list of individual - * strings. - * - * Return value is owned by the caller on success. - */ -static -GList *pathstr_to_ptokens(const char *pathstr) -{ - const char *at = pathstr; - const char *last = at; - GList *ptokens = NULL; - - for (;;) { - if (*at == '.' || *at == '\0') { - GString *tokenstr; - - if (at == last) { - /* Error: empty token */ - _printf_error("Empty token in path string at position %d\n", - (int) (at - pathstr)); - goto error; - } - - tokenstr = g_string_new(NULL); - g_string_append_len(tokenstr, last, at - last); - ptokens = g_list_append(ptokens, tokenstr); - last = at + 1; - } - - if (*at == '\0') { - break; - } - - at++; - } - - return ptokens; - -error: - ptokens_destroy(ptokens); - return NULL; -} - -/* - * Converts a path token list to a field path object. The path token - * list is relative from `type`. The index of the source looking for - * its target within `type` is indicated by `src_index`. This can be - * `INT_MAX` if the source is contained in `type`. - * - * `ptokens` is owned by the caller. `field_path` is an output parameter - * owned by the caller that must be filled here. `type` is owned by the - * caller. - */ -static -int ptokens_to_field_path(GList *ptokens, struct bt_ctf_field_path *field_path, - struct bt_ctf_field_type *type, int src_index) -{ - int ret = 0; - GList *cur_ptoken = ptokens; - bool first_level_done = false; - - /* Get our own reference */ - bt_get(type); - - /* Locate target */ - while (cur_ptoken) { - int child_index; - struct bt_ctf_field_type *child_type; - const char *field_name = ptoken_get_string(cur_ptoken); - enum ctf_type_id type_id = bt_ctf_field_type_get_type_id(type); - - /* Find to which index corresponds the current path token */ - if (type_id == CTF_TYPE_ARRAY || type_id == CTF_TYPE_SEQUENCE) { - child_index = -1; - } else { - child_index = bt_ctf_field_type_get_field_index(type, - field_name); - if (child_index < 0) { - /* - * Error: field name does not exist or - * wrong current type. - */ - _printf_error("Cannot get index of field type named \"%s\"\n", - field_name); - ret = -1; - goto end; - } else if (child_index > src_index && - !first_level_done) { - _printf_error("Child type is located after source index (%d)\n", - src_index); - ret = -1; - goto end; - } - - /* Next path token */ - cur_ptoken = g_list_next(cur_ptoken); - first_level_done = true; - } - - /* Create new field path entry */ - g_array_append_val(field_path->indexes, child_index); - - /* Get child field type */ - child_type = bt_ctf_field_type_get_field_at_index(type, - child_index); - if (!child_type) { - _printf_error("Cannot get child type at index %d (field \"%s\")\n", - child_index, field_name); - ret = -1; - goto end; - } - - /* Move child type to current type */ - BT_MOVE(type, child_type); - } - -end: - bt_put(type); - return ret; -} - -/* - * Converts a known absolute path token list to a field path object - * within the resolving context `ctx`. - * - * `ptokens` is owned by the caller. `field_path` is an output parameter - * owned by the caller that must be filled here. - */ -static -int absolute_ptokens_to_field_path(GList *ptokens, - struct bt_ctf_field_path *field_path, - struct resolve_context *ctx) -{ - int ret = 0; - GList *cur_ptoken; - struct bt_ctf_field_type *type; - - /* Skip absolute path tokens */ - cur_ptoken = g_list_nth(ptokens, - absolute_path_prefix_ptoken_counts[field_path->root]); - - /* Start with root type */ - type = get_type_from_ctx(ctx, field_path->root); - if (!type) { - /* Error: root type is not available */ - _printf_error("Root type with scope type %d is not available\n", - field_path->root); - ret = -1; - goto end; - } - - /* Locate target */ - ret = ptokens_to_field_path(cur_ptoken, field_path, type, INT_MAX); - -end: - return ret; -} - -/* - * Converts a known relative path token list to a field path object - * within the resolving context `ctx`. - * - * `ptokens` is owned by the caller. `field_path` is an output parameter - * owned by the caller that must be filled here. - */ -static -int relative_ptokens_to_field_path(GList *ptokens, - struct bt_ctf_field_path *field_path, - struct resolve_context *ctx) -{ - int ret = 0; - int parent_pos_in_stack; - struct bt_ctf_field_path *tail_field_path = bt_ctf_field_path_create(); - - if (!tail_field_path) { - _printf_error("Cannot create field path\n"); - ret = -1; - goto end; - } - - parent_pos_in_stack = type_stack_size(ctx->type_stack) - 1; - - while (parent_pos_in_stack >= 0) { - struct bt_ctf_field_type *parent_type = - type_stack_at(ctx->type_stack, - parent_pos_in_stack)->type; - int cur_index = type_stack_at(ctx->type_stack, - parent_pos_in_stack)->index; - - /* Locate target from current parent type */ - ret = ptokens_to_field_path(ptokens, tail_field_path, - parent_type, cur_index); - if (ret) { - /* Not found... yet */ - bt_ctf_field_path_clear(tail_field_path); - } else { - /* Found: stitch tail field path to head field path */ - int i = 0; - int tail_field_path_len = - tail_field_path->indexes->len; - - while (true) { - struct bt_ctf_field_type *cur_type = - type_stack_at(ctx->type_stack, i)->type; - int index = type_stack_at( - ctx->type_stack, i)->index; - - if (cur_type == parent_type) { - break; - } - - g_array_append_val(field_path->indexes, - index); - i++; - } - - for (i = 0; i < tail_field_path_len; i++) { - int index = g_array_index( - tail_field_path->indexes, - int, i); - - g_array_append_val(field_path->indexes, - index); - } - break; - } - - parent_pos_in_stack--; - } - - if (parent_pos_in_stack < 0) { - /* Not found: look in previous scopes */ - field_path->root--; - - while (field_path->root >= BT_CTF_SCOPE_TRACE_PACKET_HEADER) { - struct bt_ctf_field_type *root_type; - bt_ctf_field_path_clear(field_path); - - root_type = get_type_from_ctx(ctx, field_path->root); - if (!root_type) { - field_path->root--; - continue; - } - - /* Locate target in previous scope */ - ret = ptokens_to_field_path(ptokens, field_path, - root_type, INT_MAX); - if (ret) { - /* Not found yet */ - field_path->root--; - continue; - } - - /* Found */ - break; - } - } - -end: - BT_PUT(tail_field_path); - return ret; -} - -/* - * Converts a path string to a field path object within the resolving - * context `ctx`. - * - * Return value is owned by the caller on success. - */ -static -struct bt_ctf_field_path *pathstr_to_field_path(const char *pathstr, - struct resolve_context *ctx) -{ - int ret; - enum bt_ctf_scope root_scope; - GList *ptokens = NULL; - struct bt_ctf_field_path *field_path = NULL; - - /* Create field path */ - field_path = bt_ctf_field_path_create(); - if (!field_path) { - _printf_error("Cannot create field path\n"); - ret = -1; - goto end; - } - - /* Convert path string to path tokens */ - ptokens = pathstr_to_ptokens(pathstr); - if (!ptokens) { - _printf_error("Cannot convert path string \"%s\" to path tokens\n", - pathstr); - ret = -1; - goto end; - } - - /* Absolute or relative path? */ - root_scope = get_root_scope_from_absolute_pathstr(pathstr); - - if (root_scope == BT_CTF_SCOPE_UNKNOWN) { - /* Relative path: start with current root scope */ - field_path->root = ctx->root_scope; - ret = relative_ptokens_to_field_path(ptokens, field_path, ctx); - if (ret) { - _printf_error("Cannot get relative field path of path string \"%s\"\n", - pathstr); - _printf_error(" Starting at root scope %d, finished at root scope %d\n", - ctx->root_scope, field_path->root); - goto end; - } - } else if (root_scope == BT_CTF_SCOPE_ENV) { - _printf_error("Sequence field types referring the trace environment are not supported as of this version\n"); - ret = -1; - goto end; - } else { - /* Absolute path: use found root scope */ - field_path->root = root_scope; - ret = absolute_ptokens_to_field_path(ptokens, field_path, ctx); - if (ret) { - _printf_error("Cannot get absolute field path of path string \"%s\"\n", - pathstr); - _printf_error(" Looking in root scope %d\n", root_scope); - goto end; - } - } - -end: - if (ret) { - BT_PUT(field_path); - } - - ptokens_destroy(ptokens); - - return field_path; -} - -/* - * Retrieves a field type by following the field path `field_path` in - * the resolving context `ctx`. - * - * Return value is owned by the caller on success. - */ -static -struct bt_ctf_field_type *field_path_to_field_type( - struct bt_ctf_field_path *field_path, - struct resolve_context *ctx) -{ - int i; - struct bt_ctf_field_type *type; - - /* Start with root type */ - type = get_type_from_ctx(ctx, field_path->root); - bt_get(type); - if (!type) { - /* Error: root type is not available */ - _printf_error("Root type with scope type %d is not available\n", - field_path->root); - goto error; - } - - /* Locate target */ - for (i = 0; i < field_path->indexes->len; i++) { - struct bt_ctf_field_type *child_type; - int child_index = - g_array_index(field_path->indexes, int, i); - - /* Get child field type */ - child_type = bt_ctf_field_type_get_field_at_index(type, - child_index); - if (!child_type) { - _printf_error("Cannot get field type field at index %d\n", - child_index); - goto error; - } - - /* Move child type to current type */ - BT_MOVE(type, child_type); - } - - return type; - -error: - BT_PUT(type); - return type; -} - -/* - * Returns the equivalent field path object of the context type stack. - * - * Return value is owned by the caller on success. - */ -static -struct bt_ctf_field_path *get_ctx_stack_field_path(struct resolve_context *ctx) -{ - int i; - struct bt_ctf_field_path *field_path; - - /* Create field path */ - field_path = bt_ctf_field_path_create(); - if (!field_path) { - _printf_error("Cannot create field path\n"); - goto error; - } - - field_path->root = ctx->root_scope; - - for (i = 0; i < type_stack_size(ctx->type_stack); i++) { - struct type_stack_frame *frame; - - frame = type_stack_at(ctx->type_stack, i); - g_array_append_val(field_path->indexes, frame->index); - } - - return field_path; - -error: - BT_PUT(field_path); - return field_path; -} - -/* - * Returns the lowest common ancestor of two field path objects - * having the same root scope. - * - * `field_path1` and `field_path2` are owned by the caller. - */ -int get_field_paths_lca_index(struct bt_ctf_field_path *field_path1, - struct bt_ctf_field_path *field_path2) -{ - int lca_index = 0; - int field_path1_len, field_path2_len; - - /* - * Start from both roots and find the first mismatch. - */ - assert(field_path1->root == field_path2->root); - field_path1_len = field_path1->indexes->len; - field_path2_len = field_path2->indexes->len; - - while (true) { - int target_index, ctx_index; - - if (lca_index == field_path2_len || - lca_index == field_path1_len) { - /* - * This means that both field paths never split. - * This is invalid because the target cannot be - * an ancestor of the source. - */ - _printf_error("In source and target: one is an ancestor of the other\n"); - lca_index = -1; - break; - } - - target_index = g_array_index(field_path1->indexes, int, - lca_index); - ctx_index = g_array_index(field_path2->indexes, int, - lca_index); - - if (target_index != ctx_index) { - /* LCA index is the previous */ - break; - } - - lca_index++; - } - - return lca_index; -} - -/* - * Validates a target field path. - * - * `target_field_path` and `target_type` are owned by the caller. - */ -static -int validate_target_field_path(struct bt_ctf_field_path *target_field_path, - struct bt_ctf_field_type *target_type, - struct resolve_context *ctx) -{ - int ret = 0; - struct bt_ctf_field_path *ctx_field_path; - int target_field_path_len = target_field_path->indexes->len; - int lca_index; - int ctx_cur_field_type_id; - int target_type_id; - - /* Get context field path */ - ctx_field_path = get_ctx_stack_field_path(ctx); - if (!ctx_field_path) { - _printf_error("Cannot get source field path\n"); - ret = -1; - goto end; - } - - /* - * Make sure the target is not a root. - */ - if (target_field_path_len == 0) { - _printf_error("Target field path's length is 0 (targeting the root)\n"); - ret = -1; - goto end; - } - - /* - * Make sure the root of the target field path is not located - * after the context field path's root. - */ - if (target_field_path->root > ctx_field_path->root) { - _printf_error("Target is located after source\n"); - ret = -1; - goto end; - } - - if (target_field_path->root == ctx_field_path->root) { - int target_index, ctx_index; - - /* - * Find the index of the lowest common ancestor of both field - * paths. - */ - lca_index = get_field_paths_lca_index(target_field_path, - ctx_field_path); - if (lca_index < 0) { - _printf_error("Cannot get least common ancestor\n"); - ret = -1; - goto end; - } - - /* - * Make sure the target field path is located before the - * context field path. - */ - target_index = g_array_index(target_field_path->indexes, - int, lca_index); - ctx_index = g_array_index(ctx_field_path->indexes, - int, lca_index); - - if (target_index >= ctx_index) { - _printf_error("Target index (%d) is greater or equal to source index (%d) in LCA\n", - target_index, ctx_index); - ret = -1; - goto end; - } - } - - /* - * Make sure the target type has the right type and properties. - */ - ctx_cur_field_type_id = bt_ctf_field_type_get_type_id( - ctx->cur_field_type); - target_type_id = bt_ctf_field_type_get_type_id(target_type); - - if (ctx_cur_field_type_id == CTF_TYPE_VARIANT) { - if (target_type_id != CTF_TYPE_ENUM) { - _printf_error("Variant type's tag field type is not an enumeration\n"); - ret = -1; - goto end; - } - } else if (ctx_cur_field_type_id == CTF_TYPE_SEQUENCE) { - if (target_type_id != CTF_TYPE_INTEGER || - bt_ctf_field_type_integer_get_signed( - target_type)) { - _printf_error("Sequence type's length field type is not an unsigned integer\n"); - ret = -1; - goto end; - } - } else { - assert(false); - } - -end: - BT_PUT(ctx_field_path); - return ret; -} - -/* - * Resolves a variant or sequence field type `type`. - * - * `type` is owned by the caller. - */ -static -int resolve_sequence_or_variant_type(struct bt_ctf_field_type *type, - struct resolve_context *ctx) -{ - int ret = 0; - const char *pathstr; - int type_id = bt_ctf_field_type_get_type_id(type); - struct bt_ctf_field_path *target_field_path = NULL; - struct bt_ctf_field_type *target_type = NULL; - - /* Get path string */ - switch (type_id) { - case CTF_TYPE_SEQUENCE: - pathstr = - bt_ctf_field_type_sequence_get_length_field_name(type); - break; - case CTF_TYPE_VARIANT: - pathstr = - bt_ctf_field_type_variant_get_tag_name(type); - break; - default: - assert(false); - ret = -1; - goto end; - } - - /* Get target field path out of path string */ - target_field_path = pathstr_to_field_path(pathstr, ctx); - if (!target_field_path) { - _printf_error("Cannot get target field path for path string \"%s\"\n", - pathstr); - ret = -1; - goto end; - } - - /* Get target field type */ - target_type = field_path_to_field_type(target_field_path, ctx); - if (!target_type) { - _printf_error("Cannot get target field type for path string \"%s\"\n", - pathstr); - ret = -1; - goto end; - } - - ret = validate_target_field_path(target_field_path, target_type, ctx); - if (ret) { - _printf_error("Invalid target field path for path string \"%s\"\n", - pathstr); - goto end; - } - - /* Set target field path and target field type */ - if (type_id == CTF_TYPE_SEQUENCE) { - ret = bt_ctf_field_type_sequence_set_length_field_path( - type, target_field_path); - if (ret) { - _printf_error("Cannot set sequence field type's length field path\n"); - goto end; - } - } else if (type_id == CTF_TYPE_VARIANT) { - ret = bt_ctf_field_type_variant_set_tag_field_path( - type, target_field_path); - if (ret) { - _printf_error("Cannot set variant field type's tag field path\n"); - goto end; - } - - ret = bt_ctf_field_type_variant_set_tag_field_type( - type, target_type); - if (ret) { - _printf_error("Cannot set variant field type's tag field type\n"); - goto end; - } - } else { - assert(false); - } - -end: - BT_PUT(target_field_path); - BT_PUT(target_type); - return ret; -} - -/* - * Resolves a field type `type`. - * - * `type` is owned by the caller. - */ -static -int resolve_type(struct bt_ctf_field_type *type, struct resolve_context *ctx) -{ - int ret = 0; - int type_id; - - if (!type) { - /* Type is not available; still valid */ - goto end; - } - - type_id = bt_ctf_field_type_get_type_id(type); - ctx->cur_field_type = type; - - /* Resolve sequence/variant field type */ - switch (type_id) { - case CTF_TYPE_SEQUENCE: - case CTF_TYPE_VARIANT: - ret = resolve_sequence_or_variant_type(type, ctx); - if (ret) { - _printf_error("Cannot resolve sequence or variant field type's length/tag\n"); - goto end; - } - break; - default: - break; - } - - /* Recurse into compound types */ - switch (type_id) { - case CTF_TYPE_STRUCT: - case CTF_TYPE_VARIANT: - case CTF_TYPE_SEQUENCE: - case CTF_TYPE_ARRAY: - { - int field_count, f_index; - - ret = type_stack_push(ctx->type_stack, type); - if (ret) { - _printf_error("Cannot push field type on type stack\n"); - _printf_error(" Stack size: %zu\n", - type_stack_size(ctx->type_stack)); - goto end; - } - - field_count = bt_ctf_field_type_get_field_count(type); - if (field_count < 0) { - _printf_error("Cannot get field type field count\n"); - ret = field_count; - goto end; - } - - for (f_index = 0; f_index < field_count; f_index++) { - struct bt_ctf_field_type *child_type = - bt_ctf_field_type_get_field_at_index(type, - f_index); - - if (!child_type) { - _printf_error("Cannot get field type field at index %d/%d\n", - f_index, field_count); - ret = -1; - goto end; - } - - if (type_id == CTF_TYPE_ARRAY || - type_id == CTF_TYPE_SEQUENCE) { - type_stack_peek(ctx->type_stack)->index = -1; - } else { - type_stack_peek(ctx->type_stack)->index = - f_index; - } - - ret = resolve_type(child_type, ctx); - BT_PUT(child_type); - if (ret) { - goto end; - } - } - - type_stack_pop(ctx->type_stack); - break; - } - default: - break; - } - -end: - return ret; -} - -/* - * Resolves the root field type corresponding to the scope `root_scope`. - */ -static -int resolve_root_type(enum bt_ctf_scope root_scope, struct resolve_context *ctx) -{ - int ret; - - assert(type_stack_size(ctx->type_stack) == 0); - ctx->root_scope = root_scope; - ret = resolve_type(get_type_from_ctx(ctx, root_scope), ctx); - ctx->root_scope = BT_CTF_SCOPE_UNKNOWN; - - return ret; -} - -BT_HIDDEN -int bt_ctf_resolve_types( - struct bt_value *environment, - struct bt_ctf_field_type *packet_header_type, - struct bt_ctf_field_type *packet_context_type, - struct bt_ctf_field_type *event_header_type, - struct bt_ctf_field_type *stream_event_ctx_type, - struct bt_ctf_field_type *event_context_type, - struct bt_ctf_field_type *event_payload_type, - enum bt_ctf_resolve_flag flags) -{ - int ret = 0; - struct resolve_context ctx = { - .environment = environment, - .scopes = { - packet_header_type, - packet_context_type, - event_header_type, - stream_event_ctx_type, - event_context_type, - event_payload_type, - }, - .root_scope = BT_CTF_SCOPE_UNKNOWN, - }; - - /* Initialize type stack */ - ctx.type_stack = type_stack_create(); - if (!ctx.type_stack) { - printf_error("Cannot create type stack\n"); - ret = -1; - goto end; - } - - /* Resolve packet header type */ - if (flags & BT_CTF_RESOLVE_FLAG_PACKET_HEADER) { - ret = resolve_root_type(BT_CTF_SCOPE_TRACE_PACKET_HEADER, &ctx); - if (ret) { - _printf_error("Cannot resolve trace packet header type\n"); - goto end; - } - } - - /* Resolve packet context type */ - if (flags & BT_CTF_RESOLVE_FLAG_PACKET_CONTEXT) { - ret = resolve_root_type(BT_CTF_SCOPE_STREAM_PACKET_CONTEXT, &ctx); - if (ret) { - _printf_error("Cannot resolve stream packet context type\n"); - goto end; - } - } - - /* Resolve event header type */ - if (flags & BT_CTF_RESOLVE_FLAG_EVENT_HEADER) { - ret = resolve_root_type(BT_CTF_SCOPE_STREAM_EVENT_HEADER, &ctx); - if (ret) { - _printf_error("Cannot resolve stream event header type\n"); - goto end; - } - } - - /* Resolve stream event context type */ - if (flags & BT_CTF_RESOLVE_FLAG_STREAM_EVENT_CTX) { - ret = resolve_root_type(BT_CTF_SCOPE_STREAM_EVENT_CONTEXT, &ctx); - if (ret) { - _printf_error("Cannot resolve stream event context type\n"); - goto end; - } - } - - /* Resolve event context type */ - if (flags & BT_CTF_RESOLVE_FLAG_EVENT_CONTEXT) { - ret = resolve_root_type(BT_CTF_SCOPE_EVENT_CONTEXT, &ctx); - if (ret) { - _printf_error("Cannot resolve event context type\n"); - goto end; - } - } - - /* Resolve event payload type */ - if (flags & BT_CTF_RESOLVE_FLAG_EVENT_PAYLOAD) { - ret = resolve_root_type(BT_CTF_SCOPE_EVENT_FIELDS, &ctx); - if (ret) { - _printf_error("Cannot resolve event payload type\n"); - goto end; - } - } - -end: - type_stack_destroy(ctx.type_stack); - - return ret; -}