types/types.c

   1 /*
   2  * types.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 type *
  27         lookup_type_scope(GQuark type_name, struct type_scope *scope)
  28 {
  29         return g_hash_table_lookup(scope->types,
  30                                    (gconstpointer) (unsigned long) type_name);
  31 }
  32
  33 struct type *lookup_type(GQuark type_name, struct type_scope *scope)
  34 {
  35         struct type *type;
  36
  37         while (scope) {
  38                 type = lookup_type_scope(type_name, scope);
  39                 if (type)
  40                         return type;
  41                 scope = scope->parent_scope;
  42         }
  43         return NULL;
  44 }
  45
  46 int register_type(GQuark name, struct type *type, struct type_scope *scope)
  47 {
  48         if (!name)
  49                 return -EPERM;
  50
  51         /* Only lookup in local scope */
  52         if (lookup_type_scope(name, scope))
  53                 return -EEXIST;
  54
  55         g_hash_table_insert(scope->types,
  56                             (gpointer) (unsigned long) name,
  57                             type);
  58         type_ref(type);
  59         return 0;
  60 }
  61
  62 static
  63 struct declaration *
  64         lookup_declaration_scope(GQuark field_name, struct declaration_scope *scope)
  65 {
  66         return g_hash_table_lookup(scope->declarations,
  67                                    (gconstpointer) (unsigned long) field_name);
  68 }
  69
  70 struct declaration *
  71         lookup_declaration(GQuark field_name, struct declaration_scope *scope)
  72 {
  73         struct declaration *declaration;
  74
  75         while (scope) {
  76                 declaration = lookup_declaration_scope(field_name, scope);
  77                 if (declaration)
  78                         return declaration;
  79                 scope = scope->parent_scope;
  80         }
  81         return NULL;
  82 }
  83
  84 int register_declaration(GQuark field_name, struct declaration *declaration,
  85                          struct declaration_scope *scope)
  86 {
  87         if (!field_name)
  88                 return -EPERM;
  89
  90         /* Only lookup in local scope */
  91         if (lookup_declaration_scope(field_name, scope))
  92                 return -EEXIST;
  93
  94         g_hash_table_insert(scope->declarations,
  95                             (gpointer) (unsigned long) field_name,
  96                             declaration);
  97         declaration_ref(declaration);
  98         return 0;
  99 }
 100
 101 void type_ref(struct type *type)
 102 {
 103         type->ref++;
 104 }
 105
 106 void type_unref(struct type *type)
 107 {
 108         if (!--type->ref)
 109                 type->type_free(type);
 110 }
 111
 112 void declaration_ref(struct declaration *declaration)
 113 {
 114         declaration->ref++;
 115 }
 116
 117 void declaration_unref(struct declaration *declaration)
 118 {
 119         if (!--declaration->ref)
 120                 declaration->type->declaration_free(declaration);
 121 }
 122
 123 struct type_scope *
 124         new_type_scope(struct type_scope *parent_scope)
 125 {
 126         struct type_scope *scope = g_new(struct type_scope, 1);
 127
 128         scope->types = g_hash_table_new_full(g_direct_hash,
 129                                         g_direct_equal, NULL,
 130                                         (GDestroyNotify) type_unref);
 131         scope->parent_scope = parent_scope;
 132         return scope;
 133 }
 134
 135 void free_type_scope(struct type_scope *scope)
 136 {
 137         g_hash_table_destroy(scope->types);
 138         g_free(scope);
 139 }
 140
 141 struct declaration_scope *
 142         new_declaration_scope(struct declaration_scope *parent_scope)
 143 {
 144         struct declaration_scope *scope = g_new(struct declaration_scope, 1);
 145
 146         scope->declarations = g_hash_table_new_full(g_direct_hash,
 147                                         g_direct_equal, NULL,
 148                                         (GDestroyNotify) declaration_unref);
 149         scope->parent_scope = parent_scope;
 150         return scope;
 151 }
 152
 153 void free_declaration_scope(struct declaration_scope *scope)
 154 {
 155         g_hash_table_destroy(scope->declarations);
 156         g_free(scope);
 157 }