X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;ds=sidebyside;f=types%2Ftypes.c;h=90720e2bed988b69be1bb820201fa60cf11bc06a;hb=1934b94f75b4e9804e92d8c62de21dca5a4322d6;hp=f4843e6a87384c2cd29bf633f480329bb2f11e55;hpb=ceb811dc38fe93065f7c1119b9509f9f29a45d76;p=babeltrace.git diff --git a/types/types.c b/types/types.c index f4843e6a..90720e2b 100644 --- a/types/types.c +++ b/types/types.c @@ -1,80 +1,299 @@ /* - * Common Trace Format - Converter + * declarations.c * - * Types registry. + * BabelTrace - Converter * - * Copyright (c) 2010 Mathieu Desnoyers + * Types registry. * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. + * Copyright 2010, 2011 - Mathieu Desnoyers * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. + * 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: * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. */ -#include +#include #include #include -struct type_class { - GQuark qname; - void (*read)(); - size_t (*write)(); -}; +static +struct definition * + lookup_typedef_declaration_scope(GQuark declaration_name, + struct declaration_scope *scope) +{ + return g_hash_table_lookup(scope->typedef_declarations, + (gconstpointer) (unsigned long) declaration_name); +} + +struct definition *lookup_typedef_declaration(GQuark declaration_name, + struct declaration_scope *scope) +{ + struct definition *definition; -struct type { - struct type_class *class; - size_t alignment; /* type alignment, in bits */ - ssize_t len; /* type length, in bits. -1 for dynamic size. */ -}; + while (scope) { + definition = lookup_typedef_declaration_scope(declaration_name, + scope); + if (definition) + return definition; + scope = scope->parent_scope; + } + return NULL; +} -/* - * Type class hash table contains the registered type classes. Type class - * registration is typically performed by a plugin. - * TODO: support plugin unload (unregistration of type classes). - */ -GHashTable *type_classes; +int register_typedef_declaration(GQuark name, struct declaration *declaration, + struct declaration_scope *scope) +{ + if (!name) + return -EPERM; + + /* Only lookup in local scope */ + if (lookup_typedef_declaration_scope(name, scope)) + return -EEXIST; + + g_hash_table_insert(scope->typedef_declarations, + (gpointer) (unsigned long) name, + declaration); + declaration_ref(declaration); + return 0; +} + +static +struct definition * + lookup_field_definition_scope(GQuark field_name, + struct definition_scope *scope) +{ + return g_hash_table_lookup(scope->definitions, + (gconstpointer) (unsigned long) field_name); +} + +struct definition * + lookup_field_definition(GQuark field_name, + struct definition_scope *scope) +{ + struct definition *definition; + + while (scope) { + definition = lookup_field_definition_scope(field_name, scope); + if (definition) + return definition; + scope = scope->parent_scope; + } + return NULL; +} + +int register_field_definition(GQuark field_name, struct definition *definition, + struct definition_scope *scope) +{ + if (!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, + (gpointer) (unsigned long) field_name, + definition); + definition_ref(definition); + return 0; +} + +void declaration_ref(struct declaration *declaration) +{ + declaration->ref++; +} + +void declaration_unref(struct declaration *declaration) +{ + if (!--declaration->ref) + declaration->declaration_free(declaration); +} + +void definition_ref(struct definition *definition) +{ + definition->ref++; +} + +void definition_unref(struct definition *definition) +{ + if (!--definition->ref) + definition->declaration->definition_free(definition); +} + +struct declaration_scope * + 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) definition_unref); + scope->struct_declarations = g_hash_table_new_full(g_direct_hash, + g_direct_equal, NULL, + (GDestroyNotify) declaration_unref); + scope->variant_declarations = g_hash_table_new_full(g_direct_hash, + g_direct_equal, NULL, + (GDestroyNotify) declaration_unref); + scope->enum_declarations = g_hash_table_new_full(g_direct_hash, + g_direct_equal, NULL, + (GDestroyNotify) declaration_unref); + scope->parent_scope = parent_scope; + return scope; +} + +void 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 *lookup_struct_declaration_scope(GQuark struct_name, + struct declaration_scope *scope) +{ + return g_hash_table_lookup(scope->struct_declarations, + (gconstpointer) (unsigned long) struct_name); +} + +struct declaration_struct *lookup_struct_declaration(GQuark struct_name, + struct declaration_scope *scope) +{ + struct declaration_struct *declaration; + + while (scope) { + declaration = lookup_struct_declaration_scope(struct_name, scope); + if (declaration) + return declaration; + scope = scope->parent_scope; + } + return NULL; +} + +int register_struct_declaration(GQuark struct_name, + struct declaration_struct *struct_declaration, + struct declaration_scope *scope) +{ + if (!struct_name) + return -EPERM; + + /* Only lookup in local scope */ + if (lookup_struct_declaration_scope(struct_name, scope)) + return -EEXIST; + + g_hash_table_insert(scope->struct_declarations, + (gpointer) (unsigned long) struct_name, + struct_declaration); + declaration_ref(&struct_declaration->p); + return 0; +} + +static +struct declaration_variant * + lookup_variant_declaration_scope(GQuark variant_name, + struct declaration_scope *scope) +{ + return g_hash_table_lookup(scope->variant_declarations, + (gconstpointer) (unsigned long) variant_name); +} -struct type_class *ctf_lookup_type_class(GQuark qname) +struct declaration_variant * + lookup_variant_declaration(GQuark variant_name, + struct declaration_scope *scope) { - return g_hash_table_lookup(type_classes, - (gconstpointer) (unsigned long) qname) + struct declaration_variant *declaration; + + while (scope) { + declaration = lookup_variant_declaration_scope(variant_name, scope); + if (declaration) + return declaration; + scope = scope->parent_scope; + } + return NULL; } -int ctf_register_type_class(const char *name, - void (*read)(), - void (*write)()) +int register_variant_declaration(GQuark variant_name, + struct declaration_variant *variant_declaration, + struct declaration_scope *scope) { - struct type_class tc = g_new(struct type_class, 1); - GQuark qname = g_quark_from_string(name); + if (!variant_name) + return -EPERM; - if (ctf_lookup_type_class(qname)) + /* Only lookup in local scope */ + if (lookup_variant_declaration_scope(variant_name, scope)) return -EEXIST; - g_hash_table_insert(type_classes, - (gconstpointer) (unsigned long) qname, - tc); + g_hash_table_insert(scope->variant_declarations, + (gpointer) (unsigned long) variant_name, + variant_declaration); + declaration_ref(&variant_declaration->p); return 0; } -int ctf_init_types(void) +static +struct declaration_enum * + lookup_enum_declaration_scope(GQuark enum_name, + struct declaration_scope *scope) +{ + return g_hash_table_lookup(scope->enum_declarations, + (gconstpointer) (unsigned long) enum_name); +} + +struct declaration_enum * + lookup_enum_declaration(GQuark enum_name, + struct declaration_scope *scope) +{ + struct declaration_enum *declaration; + + while (scope) { + declaration = lookup_enum_declaration_scope(enum_name, scope); + if (declaration) + return declaration; + scope = scope->parent_scope; + } + return NULL; +} + +int register_enum_declaration(GQuark enum_name, + struct declaration_enum *enum_declaration, + struct declaration_scope *scope) { - type_classes = g_hash_table_new_full(g_direct_hash, g_direct_equal, - NULL, g_free); - if (!type_classes) - return -ENOMEM; + if (!enum_name) + return -EPERM; + + /* Only lookup in local scope */ + if (lookup_enum_declaration_scope(enum_name, scope)) + return -EEXIST; + + g_hash_table_insert(scope->enum_declarations, + (gpointer) (unsigned long) enum_name, + enum_declaration); + declaration_ref(&enum_declaration->p); return 0; } -int ctf_finalize_types(void) +struct definition_scope * + new_definition_scope(struct definition_scope *parent_scope) +{ + struct definition_scope *scope = g_new(struct definition_scope, 1); + + scope->definitions = g_hash_table_new_full(g_direct_hash, + g_direct_equal, NULL, + (GDestroyNotify) definition_unref); + scope->parent_scope = parent_scope; + return scope; +} + +void free_definition_scope(struct definition_scope *scope) { - g_hash_table_destroy(type_classes); + g_hash_table_destroy(scope->definitions); + g_free(scope); }