X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=types%2Ftypes.c;fp=types%2Ftypes.c;h=0000000000000000000000000000000000000000;hp=f58d2e4ad22e2421dafecedf7f5fea7ee35ba8a4;hb=dc3fffef7b84cc4af1a7c99828fd57a106cd2257;hpb=f3985ab106d89d8e764c1a8dd0c8bda09b755d10 diff --git a/types/types.c b/types/types.c deleted file mode 100644 index f58d2e4a..00000000 --- a/types/types.c +++ /dev/null @@ -1,678 +0,0 @@ -/* - * types.c - * - * BabelTrace - Converter - * - * Types registry. - * - * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation - * - * Author: Mathieu Desnoyers - * - * 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 - -static -GQuark prefix_quark(const char *prefix, GQuark quark) -{ - GQuark nq; - GString *str; - char *quark_str; - - str = g_string_new(prefix); - g_string_append(str, g_quark_to_string(quark)); - quark_str = g_string_free(str, FALSE); - nq = g_quark_from_string(quark_str); - g_free(quark_str); - return nq; -} - -static -struct bt_declaration * - bt_lookup_declaration_scope(GQuark declaration_name, - struct declaration_scope *scope) -{ - return g_hash_table_lookup(scope->typedef_declarations, - (gconstpointer) GUINT_TO_POINTER(declaration_name)); -} - -struct bt_declaration *bt_lookup_declaration(GQuark declaration_name, - struct declaration_scope *scope) -{ - struct bt_declaration *declaration; - - while (scope) { - declaration = bt_lookup_declaration_scope(declaration_name, - scope); - if (declaration) - return declaration; - scope = scope->parent_scope; - } - return NULL; -} - -int bt_register_declaration(GQuark name, struct bt_declaration *declaration, - struct declaration_scope *scope) -{ - if (!name) - return -EPERM; - - /* Only lookup in local scope */ - if (bt_lookup_declaration_scope(name, scope)) - return -EEXIST; - - g_hash_table_insert(scope->typedef_declarations, - GUINT_TO_POINTER(name), - declaration); - bt_declaration_ref(declaration); - return 0; -} - -static -struct bt_definition * - lookup_field_definition_scope(GQuark field_name, - struct definition_scope *scope) -{ - return g_hash_table_lookup(scope->definitions, - (gconstpointer) GUINT_TO_POINTER(field_name)); -} - -/* - * Returns the index at which the paths differ. - * If the value returned equals len, it means the paths are identical - * from index 0 to len-1. - */ -static int compare_paths(GArray *a, GArray *b, int len) -{ - int i; - - assert(len <= a->len); - assert(len <= b->len); - - for (i = 0; i < len; i++) { - GQuark qa, qb; - - qa = g_array_index(a, GQuark, i); - qb = g_array_index(b, GQuark, i); - if (qa != qb) - return i; - } - return i; -} - -static int is_path_child_of(GArray *path, GArray *maybe_parent) -{ - int ret; - - if (babeltrace_debug) { - int i, need_dot = 0; - - printf_debug("Is path \""); - for (i = 0; i < path->len; need_dot = 1, i++) - printf("%s%s", need_dot ? "." : "", - g_quark_to_string(g_array_index(path, GQuark, i))); - need_dot = 0; - printf("\" child of \""); - for (i = 0; i < maybe_parent->len; need_dot = 1, i++) - printf("%s%s", need_dot ? "." : "", - g_quark_to_string(g_array_index(maybe_parent, GQuark, i))); - printf("\" ? "); - } - - if (path->len <= maybe_parent->len) { - ret = 0; - goto end; - } - if (compare_paths(path, maybe_parent, maybe_parent->len) - == maybe_parent->len) - ret = 1; - else - ret = 0; -end: - if (babeltrace_debug) - printf("%s\n", ret ? "Yes" : "No"); - return ret; -} - -static struct definition_scope * - get_definition_scope(const struct bt_definition *definition) -{ - return definition->scope; -} - -/* - * OK, here is the fun. We want to lookup a field that is: - * - either in the same dynamic scope: - * - either in the current scope, but prior to the current field. - * - or in a parent scope (or parent of parent ...) still in a field - * prior to the current field position within the parents. - * - or in a different dynamic scope: - * - either in a upper dynamic scope (walk down a targeted scope from - * the dynamic scope root) - * - or in a lower dynamic scope (failure) - * The dynamic scope roots are linked together, so we can access the - * parent dynamic scope from the child dynamic scope by walking up to - * the parent. - * If we cannot find such a field that is prior to our current path, we - * return NULL. - * - * cur_path: the path leading to the variant definition. - * lookup_path: the path leading to the enum we want to look for. - * scope: the definition scope containing the variant definition. - */ -struct bt_definition * - bt_lookup_path_definition(GArray *cur_path, - GArray *lookup_path, - struct definition_scope *scope) -{ - struct bt_definition *definition, *lookup_definition; - GQuark last; - int index; - - /* Going up in the hierarchy. Check where we come from. */ - assert(is_path_child_of(cur_path, scope->scope_path)); - assert(cur_path->len - scope->scope_path->len == 1); - - /* - * First, check if the target name is size one, present in - * our parent path, located prior to us. - */ - if (lookup_path->len == 1) { - last = g_array_index(lookup_path, GQuark, 0); - lookup_definition = lookup_field_definition_scope(last, scope); - last = g_array_index(cur_path, GQuark, cur_path->len - 1); - definition = lookup_field_definition_scope(last, scope); - assert(definition); - if (lookup_definition && lookup_definition->index < definition->index) - return lookup_definition; - else - return NULL; - } - - while (scope) { - if (is_path_child_of(cur_path, scope->scope_path) && - cur_path->len - scope->scope_path->len == 1) { - last = g_array_index(cur_path, GQuark, cur_path->len - 1); - definition = lookup_field_definition_scope(last, scope); - assert(definition); - index = definition->index; - } else { - /* - * Getting to a dynamic scope parent. We are - * guaranteed that the parent is entirely - * located before the child. - */ - index = -1; - } -lookup: - if (is_path_child_of(lookup_path, scope->scope_path)) { - /* Means we can lookup the field in this scope */ - last = g_array_index(lookup_path, GQuark, - scope->scope_path->len); - lookup_definition = lookup_field_definition_scope(last, scope); - if (!lookup_definition || ((index != -1) && lookup_definition->index >= index)) - return NULL; - /* Found it! And it is prior to the current field. */ - if (lookup_path->len - scope->scope_path->len == 1) { - /* Direct child */ - return lookup_definition; - } else { - scope = get_definition_scope(lookup_definition); - /* Check if the definition has a sub-scope */ - if (!scope) - return NULL; - /* - * Don't compare index anymore, because we are - * going within a scope that has been validated - * to be entirely prior to the current scope. - */ - cur_path = NULL; - index = -1; - goto lookup; - } - } else { - /* lookup_path is within an upper scope */ - cur_path = scope->scope_path; - scope = scope->parent_scope; - } - } - return NULL; -} - -int bt_register_field_definition(GQuark field_name, struct bt_definition *definition, - struct definition_scope *scope) -{ - if (!scope || !field_name) - return -EPERM; - - /* Only lookup in local scope */ - if (lookup_field_definition_scope(field_name, scope)) - return -EEXIST; - - g_hash_table_insert(scope->definitions, - GUINT_TO_POINTER(field_name), - definition); - /* Don't keep reference on definition */ - return 0; -} - -void bt_declaration_ref(struct bt_declaration *declaration) -{ - declaration->ref++; -} - -void bt_declaration_unref(struct bt_declaration *declaration) -{ - if (!declaration) - return; - if (!--declaration->ref) - declaration->declaration_free(declaration); -} - -void bt_definition_ref(struct bt_definition *definition) -{ - definition->ref++; -} - -void bt_definition_unref(struct bt_definition *definition) -{ - if (!definition) - return; - if (!--definition->ref) - definition->declaration->definition_free(definition); -} - -struct declaration_scope * - bt_new_declaration_scope(struct declaration_scope *parent_scope) -{ - struct declaration_scope *scope = g_new(struct declaration_scope, 1); - - scope->typedef_declarations = g_hash_table_new_full(g_direct_hash, - g_direct_equal, NULL, - (GDestroyNotify) bt_declaration_unref); - scope->struct_declarations = g_hash_table_new_full(g_direct_hash, - g_direct_equal, NULL, - (GDestroyNotify) bt_declaration_unref); - scope->variant_declarations = g_hash_table_new_full(g_direct_hash, - g_direct_equal, NULL, - (GDestroyNotify) bt_declaration_unref); - scope->enum_declarations = g_hash_table_new_full(g_direct_hash, - g_direct_equal, NULL, - (GDestroyNotify) bt_declaration_unref); - scope->parent_scope = parent_scope; - return scope; -} - -void bt_free_declaration_scope(struct declaration_scope *scope) -{ - g_hash_table_destroy(scope->enum_declarations); - g_hash_table_destroy(scope->variant_declarations); - g_hash_table_destroy(scope->struct_declarations); - g_hash_table_destroy(scope->typedef_declarations); - g_free(scope); -} - -static -struct declaration_struct *bt_lookup_struct_declaration_scope(GQuark struct_name, - struct declaration_scope *scope) -{ - return g_hash_table_lookup(scope->struct_declarations, - (gconstpointer) GUINT_TO_POINTER(struct_name)); -} - -struct declaration_struct *bt_lookup_struct_declaration(GQuark struct_name, - struct declaration_scope *scope) -{ - struct declaration_struct *declaration; - - while (scope) { - declaration = bt_lookup_struct_declaration_scope(struct_name, scope); - if (declaration) - return declaration; - scope = scope->parent_scope; - } - return NULL; -} - -int bt_register_struct_declaration(GQuark struct_name, - struct declaration_struct *struct_declaration, - struct declaration_scope *scope) -{ - GQuark prefix_name; - int ret; - - if (!struct_name) - return -EPERM; - - /* Only lookup in local scope */ - if (bt_lookup_struct_declaration_scope(struct_name, scope)) - return -EEXIST; - - g_hash_table_insert(scope->struct_declarations, - GUINT_TO_POINTER(struct_name), - struct_declaration); - bt_declaration_ref(&struct_declaration->p); - - /* Also add in typedef/typealias scopes */ - prefix_name = prefix_quark("struct ", struct_name); - ret = bt_register_declaration(prefix_name, &struct_declaration->p, scope); - assert(!ret); - return 0; -} - -static -struct declaration_untagged_variant * - bt_lookup_variant_declaration_scope(GQuark variant_name, - struct declaration_scope *scope) -{ - return g_hash_table_lookup(scope->variant_declarations, - (gconstpointer) GUINT_TO_POINTER(variant_name)); -} - -struct declaration_untagged_variant * - bt_lookup_variant_declaration(GQuark variant_name, - struct declaration_scope *scope) -{ - struct declaration_untagged_variant *declaration; - - while (scope) { - declaration = bt_lookup_variant_declaration_scope(variant_name, scope); - if (declaration) - return declaration; - scope = scope->parent_scope; - } - return NULL; -} - -int bt_register_variant_declaration(GQuark variant_name, - struct declaration_untagged_variant *untagged_variant_declaration, - struct declaration_scope *scope) -{ - GQuark prefix_name; - int ret; - - if (!variant_name) - return -EPERM; - - /* Only lookup in local scope */ - if (bt_lookup_variant_declaration_scope(variant_name, scope)) - return -EEXIST; - - g_hash_table_insert(scope->variant_declarations, - GUINT_TO_POINTER(variant_name), - untagged_variant_declaration); - bt_declaration_ref(&untagged_variant_declaration->p); - - /* Also add in typedef/typealias scopes */ - prefix_name = prefix_quark("variant ", variant_name); - ret = bt_register_declaration(prefix_name, - &untagged_variant_declaration->p, scope); - assert(!ret); - return 0; -} - -static -struct declaration_enum * - bt_lookup_enum_declaration_scope(GQuark enum_name, - struct declaration_scope *scope) -{ - return g_hash_table_lookup(scope->enum_declarations, - (gconstpointer) GUINT_TO_POINTER(enum_name)); -} - -struct declaration_enum * - bt_lookup_enum_declaration(GQuark enum_name, - struct declaration_scope *scope) -{ - struct declaration_enum *declaration; - - while (scope) { - declaration = bt_lookup_enum_declaration_scope(enum_name, scope); - if (declaration) - return declaration; - scope = scope->parent_scope; - } - return NULL; -} - -int bt_register_enum_declaration(GQuark enum_name, - struct declaration_enum *enum_declaration, - struct declaration_scope *scope) -{ - GQuark prefix_name; - int ret; - - if (!enum_name) - return -EPERM; - - /* Only lookup in local scope */ - if (bt_lookup_enum_declaration_scope(enum_name, scope)) - return -EEXIST; - - g_hash_table_insert(scope->enum_declarations, - GUINT_TO_POINTER(enum_name), - enum_declaration); - bt_declaration_ref(&enum_declaration->p); - - /* Also add in typedef/typealias scopes */ - prefix_name = prefix_quark("enum ", enum_name); - ret = bt_register_declaration(prefix_name, &enum_declaration->p, scope); - assert(!ret); - return 0; -} - -static struct definition_scope * - _bt_new_definition_scope(struct definition_scope *parent_scope, - int scope_path_len) -{ - struct definition_scope *scope = g_new(struct definition_scope, 1); - - scope->definitions = g_hash_table_new(g_direct_hash, - g_direct_equal); - scope->parent_scope = parent_scope; - scope->scope_path = g_array_sized_new(FALSE, TRUE, sizeof(GQuark), - scope_path_len); - g_array_set_size(scope->scope_path, scope_path_len); - return scope; -} - -GQuark bt_new_definition_path(struct definition_scope *parent_scope, - GQuark field_name, const char *root_name) -{ - GQuark path; - GString *str; - gchar *c_str; - int need_dot = 0; - - str = g_string_new(""); - if (root_name) { - g_string_append(str, root_name); - need_dot = 1; - } else if (parent_scope) { - int i; - - for (i = 0; i < parent_scope->scope_path->len; i++) { - GQuark q = g_array_index(parent_scope->scope_path, - GQuark, i); - if (!q) - continue; - if (need_dot) - g_string_append(str, "."); - g_string_append(str, g_quark_to_string(q)); - need_dot = 1; - } - } - if (field_name) { - if (need_dot) - g_string_append(str, "."); - g_string_append(str, g_quark_to_string(field_name)); - } - c_str = g_string_free(str, FALSE); - if (c_str[0] == '\0') - return 0; - path = g_quark_from_string(c_str); - printf_debug("new definition path: %s\n", c_str); - g_free(c_str); - return path; -} - -struct definition_scope * - bt_new_definition_scope(struct definition_scope *parent_scope, - GQuark field_name, const char *root_name) -{ - struct definition_scope *scope; - - if (root_name) { - scope = _bt_new_definition_scope(parent_scope, 0); - bt_append_scope_path(root_name, scope->scope_path); - } else { - int scope_path_len = 1; - - assert(parent_scope); - scope_path_len += parent_scope->scope_path->len; - scope = _bt_new_definition_scope(parent_scope, scope_path_len); - memcpy(scope->scope_path->data, parent_scope->scope_path->data, - sizeof(GQuark) * (scope_path_len - 1)); - g_array_index(scope->scope_path, GQuark, scope_path_len - 1) = - field_name; - } - if (babeltrace_debug) { - int i, need_dot = 0; - - printf_debug("new definition scope: "); - for (i = 0; i < scope->scope_path->len; need_dot = 1, i++) - printf("%s%s", need_dot ? "." : "", - g_quark_to_string(g_array_index(scope->scope_path, GQuark, i))); - printf("\n"); - } - return scope; -} - -/* - * in: path (dot separated), out: q (GArray of GQuark) - */ -void bt_append_scope_path(const char *path, GArray *q) -{ - const char *ptrbegin, *ptrend = path; - GQuark quark; - - for (;;) { - char *str; - size_t len; - - ptrbegin = ptrend; - ptrend = strchr(ptrbegin, '.'); - if (!ptrend) - break; - len = ptrend - ptrbegin; - /* Don't accept two consecutive dots */ - assert(len != 0); - str = g_new(char, len + 1); /* include \0 */ - memcpy(str, ptrbegin, len); - str[len] = '\0'; - quark = g_quark_from_string(str); - g_array_append_val(q, quark); - g_free(str); - ptrend++; /* skip current dot */ - } - /* last. Check for trailing dot (and discard). */ - if (ptrbegin[0] != '\0') { - quark = g_quark_from_string(ptrbegin); - g_array_append_val(q, quark); - } -} - -void bt_free_definition_scope(struct definition_scope *scope) -{ - g_array_free(scope->scope_path, TRUE); - g_hash_table_destroy(scope->definitions); - g_free(scope); -} - -struct bt_definition *bt_lookup_definition(const struct bt_definition *definition, - const char *field_name) -{ - struct definition_scope *scope = get_definition_scope(definition); - - if (!scope) - return NULL; - - return lookup_field_definition_scope(g_quark_from_string(field_name), - scope); -} - -struct definition_integer *bt_lookup_integer(const struct bt_definition *definition, - const char *field_name, - int signedness) -{ - struct bt_definition *lookup; - struct definition_integer *lookup_integer; - - lookup = bt_lookup_definition(definition, field_name); - if (!lookup) - return NULL; - if (lookup->declaration->id != BT_CTF_TYPE_ID_INTEGER) - return NULL; - lookup_integer = container_of(lookup, struct definition_integer, p); - if (lookup_integer->declaration->signedness != signedness) - return NULL; - return lookup_integer; -} - -struct definition_enum *bt_lookup_enum(const struct bt_definition *definition, - const char *field_name, - int signedness) -{ - struct bt_definition *lookup; - struct definition_enum *lookup_enum; - - lookup = bt_lookup_definition(definition, field_name); - if (!lookup) - return NULL; - if (lookup->declaration->id != BT_CTF_TYPE_ID_ENUM) - return NULL; - lookup_enum = container_of(lookup, struct definition_enum, p); - if (lookup_enum->integer->declaration->signedness != signedness) - return NULL; - return lookup_enum; -} - -struct bt_definition *bt_lookup_variant(const struct bt_definition *definition, - const char *field_name) -{ - struct bt_definition *lookup; - struct definition_variant *bt_lookup_variant; - - lookup = bt_lookup_definition(definition, field_name); - if (!lookup) - return NULL; - if (lookup->declaration->id != BT_CTF_TYPE_ID_VARIANT) - return NULL; - bt_lookup_variant = container_of(lookup, struct definition_variant, p); - lookup = bt_variant_get_current_field(bt_lookup_variant); - assert(lookup); - return lookup; -}