types/types.c

   1 /*
   2  * declarations.c
   3  *
   4  * BabelTrace - Converter
   5  *
   6  * Types registry.
   7  *
   8  * Copyright 2010, 2011 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  */
  20
  21 #include <babeltrace/format.h>
  22 #include <glib.h>
  23 #include <errno.h>
  24
  25 static
  26 struct definition *
  27         lookup_typedef_declaration_scope(GQuark declaration_name,
  28                 struct declaration_scope *scope)
  29 {
  30         return g_hash_table_lookup(scope->typedef_declarations,
  31                                    (gconstpointer) (unsigned long) declaration_name);
  32 }
  33
  34 struct definition *lookup_typedef_declaration(GQuark declaration_name,
  35                 struct declaration_scope *scope)
  36 {
  37         struct definition *definition;
  38
  39         while (scope) {
  40                 definition = lookup_typedef_declaration_scope(declaration_name,
  41                                                               scope);
  42                 if (definition)
  43                         return definition;
  44                 scope = scope->parent_scope;
  45         }
  46         return NULL;
  47 }
  48
  49 int register_typedef_declaration(GQuark name, struct declaration *declaration,
  50                 struct declaration_scope *scope)
  51 {
  52         if (!name)
  53                 return -EPERM;
  54
  55         /* Only lookup in local scope */
  56         if (lookup_typedef_declaration_scope(name, scope))
  57                 return -EEXIST;
  58
  59         g_hash_table_insert(scope->typedef_declarations,
  60                             (gpointer) (unsigned long) name,
  61                             declaration);
  62         declaration_ref(declaration);
  63         return 0;
  64 }
  65
  66 static
  67 struct definition *
  68         lookup_field_definition_scope(GQuark field_name,
  69                 struct definition_scope *scope)
  70 {
  71         return g_hash_table_lookup(scope->definitions,
  72                                    (gconstpointer) (unsigned long) field_name);
  73 }
  74
  75 struct definition *
  76         lookup_field_definition(GQuark field_name,
  77                 struct definition_scope *scope)
  78 {
  79         struct definition *definition;
  80
  81         while (scope) {
  82                 definition = lookup_field_definition_scope(field_name, scope);
  83                 if (definition)
  84                         return definition;
  85                 scope = scope->parent_scope;
  86         }
  87         return NULL;
  88 }
  89
  90 int register_field_definition(GQuark field_name, struct definition *definition,
  91                 struct definition_scope *scope)
  92 {
  93         if (!field_name)
  94                 return -EPERM;
  95
  96         /* Only lookup in local scope */
  97         if (lookup_field_definition_scope(field_name, scope))
  98                 return -EEXIST;
  99
 100         g_hash_table_insert(scope->definitions,
 101                             (gpointer) (unsigned long) field_name,
 102                             definition);
 103         definition_ref(definition);
 104         return 0;
 105 }
 106
 107 void declaration_ref(struct declaration *declaration)
 108 {
 109         declaration->ref++;
 110 }
 111
 112 void declaration_unref(struct declaration *declaration)
 113 {
 114         if (!--declaration->ref)
 115                 declaration->declaration_free(declaration);
 116 }
 117
 118 void definition_ref(struct definition *definition)
 119 {
 120         definition->ref++;
 121 }
 122
 123 void definition_unref(struct definition *definition)
 124 {
 125         if (!--definition->ref)
 126                 definition->declaration->definition_free(definition);
 127 }
 128
 129 struct declaration_scope *
 130         new_declaration_scope(struct declaration_scope *parent_scope)
 131 {
 132         struct declaration_scope *scope = g_new(struct declaration_scope, 1);
 133
 134         scope->typedef_declarations = g_hash_table_new_full(g_direct_hash,
 135                                         g_direct_equal, NULL,
 136                                         (GDestroyNotify) definition_unref);
 137         scope->struct_declarations = g_hash_table_new_full(g_direct_hash,
 138                                         g_direct_equal, NULL,
 139                                         (GDestroyNotify) declaration_unref);
 140         scope->variant_declarations = g_hash_table_new_full(g_direct_hash,
 141                                         g_direct_equal, NULL,
 142                                         (GDestroyNotify) declaration_unref);
 143         scope->enum_declarations = g_hash_table_new_full(g_direct_hash,
 144                                         g_direct_equal, NULL,
 145                                         (GDestroyNotify) declaration_unref);
 146         scope->parent_scope = parent_scope;
 147         return scope;
 148 }
 149
 150 void free_declaration_scope(struct declaration_scope *scope)
 151 {
 152         g_hash_table_destroy(scope->enum_declarations);
 153         g_hash_table_destroy(scope->variant_declarations);
 154         g_hash_table_destroy(scope->struct_declarations);
 155         g_hash_table_destroy(scope->typedef_declarations);
 156         g_free(scope);
 157 }
 158
 159 static
 160 struct declaration_struct *lookup_struct_declaration_scope(GQuark struct_name,
 161                                              struct declaration_scope *scope)
 162 {
 163         return g_hash_table_lookup(scope->struct_declarations,
 164                                    (gconstpointer) (unsigned long) struct_name);
 165 }
 166
 167 struct declaration_struct *lookup_struct_declaration(GQuark struct_name,
 168                                        struct declaration_scope *scope)
 169 {
 170         struct declaration_struct *declaration;
 171
 172         while (scope) {
 173                 declaration = lookup_struct_declaration_scope(struct_name, scope);
 174                 if (declaration)
 175                         return declaration;
 176                 scope = scope->parent_scope;
 177         }
 178         return NULL;
 179 }
 180
 181 int register_struct_declaration(GQuark struct_name,
 182         struct declaration_struct *struct_declaration,
 183         struct declaration_scope *scope)
 184 {
 185         if (!struct_name)
 186                 return -EPERM;
 187
 188         /* Only lookup in local scope */
 189         if (lookup_struct_declaration_scope(struct_name, scope))
 190                 return -EEXIST;
 191
 192         g_hash_table_insert(scope->struct_declarations,
 193                             (gpointer) (unsigned long) struct_name,
 194                             struct_declaration);
 195         declaration_ref(&struct_declaration->p);
 196         return 0;
 197 }
 198
 199 static
 200 struct declaration_variant *
 201         lookup_variant_declaration_scope(GQuark variant_name,
 202                 struct declaration_scope *scope)
 203 {
 204         return g_hash_table_lookup(scope->variant_declarations,
 205                                    (gconstpointer) (unsigned long) variant_name);
 206 }
 207
 208 struct declaration_variant *
 209         lookup_variant_declaration(GQuark variant_name,
 210                 struct declaration_scope *scope)
 211 {
 212         struct declaration_variant *declaration;
 213
 214         while (scope) {
 215                 declaration = lookup_variant_declaration_scope(variant_name, scope);
 216                 if (declaration)
 217                         return declaration;
 218                 scope = scope->parent_scope;
 219         }
 220         return NULL;
 221 }
 222
 223 int register_variant_declaration(GQuark variant_name,
 224                 struct declaration_variant *variant_declaration,
 225                 struct declaration_scope *scope)
 226 {
 227         if (!variant_name)
 228                 return -EPERM;
 229
 230         /* Only lookup in local scope */
 231         if (lookup_variant_declaration_scope(variant_name, scope))
 232                 return -EEXIST;
 233
 234         g_hash_table_insert(scope->variant_declarations,
 235                             (gpointer) (unsigned long) variant_name,
 236                             variant_declaration);
 237         declaration_ref(&variant_declaration->p);
 238         return 0;
 239 }
 240
 241 static
 242 struct declaration_enum *
 243         lookup_enum_declaration_scope(GQuark enum_name,
 244                 struct declaration_scope *scope)
 245 {
 246         return g_hash_table_lookup(scope->enum_declarations,
 247                                    (gconstpointer) (unsigned long) enum_name);
 248 }
 249
 250 struct declaration_enum *
 251         lookup_enum_declaration(GQuark enum_name,
 252                 struct declaration_scope *scope)
 253 {
 254         struct declaration_enum *declaration;
 255
 256         while (scope) {
 257                 declaration = lookup_enum_declaration_scope(enum_name, scope);
 258                 if (declaration)
 259                         return declaration;
 260                 scope = scope->parent_scope;
 261         }
 262         return NULL;
 263 }
 264
 265 int register_enum_declaration(GQuark enum_name,
 266                 struct declaration_enum *enum_declaration,
 267                 struct declaration_scope *scope)
 268 {
 269         if (!enum_name)
 270                 return -EPERM;
 271
 272         /* Only lookup in local scope */
 273         if (lookup_enum_declaration_scope(enum_name, scope))
 274                 return -EEXIST;
 275
 276         g_hash_table_insert(scope->enum_declarations,
 277                             (gpointer) (unsigned long) enum_name,
 278                             enum_declaration);
 279         declaration_ref(&enum_declaration->p);
 280         return 0;
 281 }
 282
 283 struct definition_scope *
 284         new_definition_scope(struct definition_scope *parent_scope)
 285 {
 286         struct definition_scope *scope = g_new(struct definition_scope, 1);
 287
 288         scope->definitions = g_hash_table_new_full(g_direct_hash,
 289                                         g_direct_equal, NULL,
 290                                         (GDestroyNotify) definition_unref);
 291         scope->parent_scope = parent_scope;
 292         return scope;
 293 }
 294
 295 void free_definition_scope(struct definition_scope *scope)
 296 {
 297         g_hash_table_destroy(scope->definitions);
 298         g_free(scope);
 299 }