From c13cbf74f302eb64e051045ce31f712a5e05203c Mon Sep 17 00:00:00 2001 From: Mathieu Desnoyers Date: Sun, 27 Mar 2011 12:00:56 -0400 Subject: [PATCH] Add struct/variant/enum named type to type scope Signed-off-by: Mathieu Desnoyers --- include/babeltrace/types.h | 56 ++++++++++-- types/types.c | 173 ++++++++++++++++++++++++++++++++----- 2 files changed, 199 insertions(+), 30 deletions(-) diff --git a/include/babeltrace/types.h b/include/babeltrace/types.h index e8480122..fd174b08 100644 --- a/include/babeltrace/types.h +++ b/include/babeltrace/types.h @@ -89,14 +89,20 @@ struct declaration; /* type scope */ struct type_scope { - /* Hash table mapping type name GQuark to struct type */ - GHashTable *types; + /* Hash table mapping type name GQuark to "struct declaration" */ + GHashTable *type_declarations; + /* Hash table mapping struct name GQuark to "struct type_struct" */ + GHashTable *struct_types; + /* Hash table mapping variant name GQuark to "struct type_variant" */ + GHashTable *variant_types; + /* Hash table mapping enum name GQuark to "struct type_enum" */ + GHashTable *enum_types; struct type_scope *parent_scope; }; /* declaration scope */ struct declaration_scope { - /* Hash table mapping field name GQuark to struct declaration */ + /* Hash table mapping field name GQuark to "struct declaration" */ GHashTable *declarations; struct declaration_scope *parent_scope; }; @@ -313,16 +319,48 @@ struct declaration_sequence { struct field current_element; /* struct field */ }; -int register_type(GQuark type_name, struct type *type, - struct type_scope *scope); -struct type *lookup_type(GQuark type_name, struct type_scope *scope); +/* + * type_declaration is for typedef and typealias. They are registered + * into type scopes. + */ +int register_type_declaration(GQuark type_name, struct declaration *declaration, + struct type_scope *scope); +struct declaration *lookup_type_declaration(GQuark type_name, + struct type_scope *scope); + +/* + * Type scopes also contain a separate registry for struct, variant and + * enum types. Those register types rather than type declarations, so + * that a named variant can be declared without specifying its target + * "choice" tag field immediately. + */ +int register_struct_type(GQuark struct_name, struct type_struct *struct_type, + struct type_scope *scope); +struct type_struct *lookup_struct_type(GQuark struct_name, + struct type_scope *scope); +int register_variant_type(GQuark variant_name, + struct type_variant *variant_type, + struct type_scope *scope); +struct type_variant *lookup_variant_type(GQuark variant_name, + struct type_scope *scope); +int register_enum_type(GQuark enum_name, struct type_enum *enum_type, + struct type_scope *scope); +struct type_enum *lookup_enum_type(GQuark enum_name, + struct type_scope *scope); + struct type_scope *new_type_scope(struct type_scope *parent_scope); void free_type_scope(struct type_scope *scope); +/* + * field_declaration is for field declarations. They are registered into + * declaration scopes. + */ struct declaration * - lookup_declaration(GQuark field_name, struct declaration_scope *scope); -int register_declaration(GQuark field_name, struct declaration *declaration, - struct declaration_scope *scope); + lookup_field_declaration(GQuark field_name, + struct declaration_scope *scope); +int register_field_declaration(GQuark field_name, + struct declaration *declaration, + struct declaration_scope *scope); struct declaration_scope * new_declaration_scope(struct declaration_scope *parent_scope); void free_declaration_scope(struct declaration_scope *scope); diff --git a/types/types.c b/types/types.c index 54116540..2f262987 100644 --- a/types/types.c +++ b/types/types.c @@ -23,57 +23,58 @@ #include static -struct type * - lookup_type_scope(GQuark type_name, struct type_scope *scope) +struct declaration * + lookup_type_declaration_scope(GQuark type_name, struct type_scope *scope) { - return g_hash_table_lookup(scope->types, + return g_hash_table_lookup(scope->type_declarations, (gconstpointer) (unsigned long) type_name); } -struct type *lookup_type(GQuark type_name, struct type_scope *scope) +struct declaration *lookup_type_declaration(GQuark type_name, struct type_scope *scope) { - struct type *type; + struct declaration *declaration; while (scope) { - type = lookup_type_scope(type_name, scope); - if (type) - return type; + declaration = lookup_type_declaration_scope(type_name, scope); + if (declaration) + return declaration; scope = scope->parent_scope; } return NULL; } -int register_type(GQuark name, struct type *type, struct type_scope *scope) +int register_type_declaration(GQuark name, struct declaration *declaration, + struct type_scope *scope) { if (!name) return -EPERM; /* Only lookup in local scope */ - if (lookup_type_scope(name, scope)) + if (lookup_type_declaration_scope(name, scope)) return -EEXIST; - g_hash_table_insert(scope->types, + g_hash_table_insert(scope->type_declarations, (gpointer) (unsigned long) name, - type); - type_ref(type); + declaration); + declaration_ref(declaration); return 0; } static struct declaration * - lookup_declaration_scope(GQuark field_name, struct declaration_scope *scope) + lookup_field_declaration_scope(GQuark field_name, struct declaration_scope *scope) { return g_hash_table_lookup(scope->declarations, (gconstpointer) (unsigned long) field_name); } struct declaration * - lookup_declaration(GQuark field_name, struct declaration_scope *scope) + lookup_field_declaration(GQuark field_name, struct declaration_scope *scope) { struct declaration *declaration; while (scope) { - declaration = lookup_declaration_scope(field_name, scope); + declaration = lookup_field_declaration_scope(field_name, scope); if (declaration) return declaration; scope = scope->parent_scope; @@ -81,14 +82,14 @@ struct declaration * return NULL; } -int register_declaration(GQuark field_name, struct declaration *declaration, - struct declaration_scope *scope) +int register_field_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)) + if (lookup_field_declaration_scope(field_name, scope)) return -EEXIST; g_hash_table_insert(scope->declarations, @@ -125,7 +126,16 @@ struct type_scope * { struct type_scope *scope = g_new(struct type_scope, 1); - scope->types = g_hash_table_new_full(g_direct_hash, + scope->type_declarations = g_hash_table_new_full(g_direct_hash, + g_direct_equal, NULL, + (GDestroyNotify) declaration_unref); + scope->struct_types = g_hash_table_new_full(g_direct_hash, + g_direct_equal, NULL, + (GDestroyNotify) type_unref); + scope->variant_types = g_hash_table_new_full(g_direct_hash, + g_direct_equal, NULL, + (GDestroyNotify) type_unref); + scope->enum_types = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) type_unref); scope->parent_scope = parent_scope; @@ -134,10 +144,131 @@ struct type_scope * void free_type_scope(struct type_scope *scope) { - g_hash_table_destroy(scope->types); + g_hash_table_destroy(scope->enum_types); + g_hash_table_destroy(scope->variant_types); + g_hash_table_destroy(scope->struct_types); + g_hash_table_destroy(scope->type_declarations); g_free(scope); } +static +struct type_struct *lookup_struct_type_scope(GQuark struct_name, + struct type_scope *scope) +{ + return g_hash_table_lookup(scope->struct_types, + (gconstpointer) (unsigned long) struct_name); +} + +struct type_struct *lookup_struct_type(GQuark struct_name, + struct type_scope *scope) +{ + struct type_struct *type; + + while (scope) { + type = lookup_struct_type_scope(struct_name, scope); + if (type) + return type; + scope = scope->parent_scope; + } + return NULL; +} + +int register_struct_type(GQuark struct_name, struct type_struct *struct_type, + struct type_scope *scope) +{ + if (!struct_name) + return -EPERM; + + /* Only lookup in local scope */ + if (lookup_struct_type_scope(struct_name, scope)) + return -EEXIST; + + g_hash_table_insert(scope->struct_types, + (gpointer) (unsigned long) struct_name, + struct_type); + type_ref(&struct_type->p); + return 0; +} + +static +struct type_variant *lookup_variant_type_scope(GQuark variant_name, + struct type_scope *scope) +{ + return g_hash_table_lookup(scope->variant_types, + (gconstpointer) (unsigned long) variant_name); +} + +struct type_variant *lookup_variant_type(GQuark variant_name, + struct type_scope *scope) +{ + struct type_variant *type; + + while (scope) { + type = lookup_variant_type_scope(variant_name, scope); + if (type) + return type; + scope = scope->parent_scope; + } + return NULL; +} + +int register_variant_type(GQuark variant_name, + struct type_variant *variant_type, + struct type_scope *scope) +{ + if (!variant_name) + return -EPERM; + + /* Only lookup in local scope */ + if (lookup_variant_type_scope(variant_name, scope)) + return -EEXIST; + + g_hash_table_insert(scope->variant_types, + (gpointer) (unsigned long) variant_name, + variant_type); + type_ref(&variant_type->p); + return 0; +} + +static +struct type_enum *lookup_enum_type_scope(GQuark enum_name, + struct type_scope *scope) +{ + return g_hash_table_lookup(scope->enum_types, + (gconstpointer) (unsigned long) enum_name); +} + +struct type_enum *lookup_enum_type(GQuark enum_name, + struct type_scope *scope) +{ + struct type_enum *type; + + while (scope) { + type = lookup_enum_type_scope(enum_name, scope); + if (type) + return type; + scope = scope->parent_scope; + } + return NULL; +} + +int register_enum_type(GQuark enum_name, struct type_enum *enum_type, + struct type_scope *scope) +{ + if (!enum_name) + return -EPERM; + + /* Only lookup in local scope */ + if (lookup_enum_type_scope(enum_name, scope)) + return -EEXIST; + + g_hash_table_insert(scope->enum_types, + (gpointer) (unsigned long) enum_name, + enum_type); + type_ref(&enum_type->p); + return 0; +} + struct declaration_scope * new_declaration_scope(struct declaration_scope *parent_scope) { -- 2.34.1