X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=types%2Ftypes.c;h=4b614f39978e49c6a41d9869e6f60fd251d9bc76;hp=28242d23c323201106dc49d93775b572b65f0372;hb=64893f33bdc4bfe20820928b28731277797e41fc;hpb=d79865b92da224131f58ab311e75e49043b62c7a diff --git a/types/types.c b/types/types.c index 28242d23..4b614f39 100644 --- a/types/types.c +++ b/types/types.c @@ -1,80 +1,159 @@ /* + * types.c + * * BabelTrace - Converter * * Types registry. * - * Copyright (c) 2010 Mathieu Desnoyers - * - * 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 type * + lookup_type_scope(GQuark type_name, struct type_scope *scope) +{ + return g_hash_table_lookup(scope->types, + (gconstpointer) (unsigned long) type_name); +} -struct type { - struct type_class *class; - size_t alignment; /* type alignment, in bits */ - ssize_t len; /* type length, in bits. -1 for dynamic size. */ -}; +struct type *lookup_type(GQuark type_name, struct type_scope *scope) +{ + struct type *type; -/* - * 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; + while (scope) { + type = lookup_type_scope(type_name, scope); + if (type) + return type; + scope = scope->parent_scope; + } + return NULL; +} -struct type_class *ctf_lookup_type_class(GQuark qname) +int register_type(GQuark name, struct type *type, struct type_scope *scope) { - return g_hash_table_lookup(type_classes, - (gconstpointer) (unsigned long) qname) + g_assert(name == type->name); + + if (!name) + return -EPERM; + + /* Only lookup in local scope */ + if (lookup_type_scope(name, scope)) + return -EEXIST; + + g_hash_table_insert(scope->types, + (gpointer) (unsigned long) name, + type); + type_ref(type); + return 0; +} + +static +struct declaration * + lookup_declaration_scope(GQuark field_name, struct declaration_scope *scope) +{ + return g_hash_table_lookup(scope->declarations, + (gconstpointer) (unsigned long) field_name); } -int ctf_register_type_class(const char *name, - void (*read)(), - void (*write)()) +struct declaration * + lookup_declaration(GQuark field_name, struct declaration_scope *scope) { - struct type_class tc = g_new(struct type_class, 1); - GQuark qname = g_quark_from_string(name); + struct declaration *declaration; - if (ctf_lookup_type_class(qname)) + while (scope) { + declaration = lookup_declaration_scope(field_name, scope); + if (declaration) + return declaration; + scope = scope->parent_scope; + } + return NULL; +} + +int register_declaration(GQuark field_name, struct declaration *declaration, + struct declaration_scope *scope) +{ + if (!field_name) + return -EPERM; + + /* Only lookup in local scope */ + if (lookup_declaration_scope(field_name, scope)) return -EEXIST; - g_hash_table_insert(type_classes, - (gconstpointer) (unsigned long) qname, - tc); + g_hash_table_insert(scope->declarations, + (gpointer) (unsigned long) field_name, + declaration); + declaration_ref(declaration); return 0; } -int ctf_init_types(void) +void type_ref(struct type *type) { - type_classes = g_hash_table_new_full(g_direct_hash, g_direct_equal, - NULL, g_free); - if (!type_classes) - return -ENOMEM; - return 0; + type->ref++; +} + +void type_unref(struct type *type) +{ + if (!--type->ref) + type->type_free(type); +} + +void declaration_ref(struct declaration *declaration) +{ + declaration->ref++; +} + +void declaration_unref(struct declaration *declaration) +{ + if (!--declaration->ref) + declaration->type->declaration_free(declaration); +} + +struct type_scope * + new_type_scope(struct type_scope *parent_scope) +{ + struct type_scope *scope = g_new(struct type_scope, 1); + + scope->types = g_hash_table_new_full(g_direct_hash, + g_direct_equal, NULL, + (GDestroyNotify) type_unref); + scope->parent_scope = parent_scope; + return scope; +} + +void free_type_scope(struct type_scope *scope) +{ + g_hash_table_destroy(scope->types); + g_free(scope); +} + +struct declaration_scope * + new_declaration_scope(struct declaration_scope *parent_scope) +{ + struct declaration_scope *scope = g_new(struct declaration_scope, 1); + + scope->declarations = g_hash_table_new_full(g_direct_hash, + g_direct_equal, NULL, + (GDestroyNotify) declaration_unref); + scope->parent_scope = parent_scope; + return scope; } -int ctf_finalize_types(void) +void free_declaration_scope(struct declaration_scope *scope) { - g_hash_table_destroy(type_classes); + g_hash_table_destroy(scope->declarations); + g_free(scope); }