types/enum.c

   1 /*
   2  * enum.c
   3  *
   4  * BabelTrace - Enumeration Type
   5  *
   6  * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
   7  *
   8  * Author: 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/compiler.h>
  22 #include <babeltrace/format.h>
  23 #include <stdint.h>
  24 #include <glib.h>
  25
  26 static
  27 struct definition *_enum_definition_new(struct declaration *declaration,
  28                                         struct definition_scope *parent_scope,
  29                                         GQuark field_name, int index,
  30                                         const char *root_name);
  31 static
  32 void _enum_definition_free(struct definition *definition);
  33
  34 static
  35 void enum_range_set_free(void *ptr)
  36 {
  37         g_array_unref(ptr);
  38 }
  39
  40 #if (__WORDSIZE == 32)
  41 static inline
  42 gpointer get_uint_v(uint64_t *v)
  43 {
  44         return v;
  45 }
  46
  47 static inline
  48 gpointer get_int_v(int64_t *v)
  49 {
  50         return v;
  51 }
  52
  53 static
  54 guint enum_val_hash(gconstpointer key)
  55 {
  56         int64_t ukey = *(const int64_t *)key;
  57
  58         return (guint)ukey ^ (guint)(ukey >> 32);
  59 }
  60
  61 static
  62 gboolean enum_val_equal(gconstpointer a, gconstpointer b)
  63 {
  64         int64_t ua = *(const int64_t *)a;
  65         int64_t ub = *(const int64_t *)b;
  66
  67         return ua == ub;
  68 }
  69
  70 static
  71 void enum_val_free(void *ptr)
  72 {
  73         g_free(ptr);
  74 }
  75 #else  /* __WORDSIZE != 32 */
  76 static inline
  77 gpointer get_uint_v(uint64_t *v)
  78 {
  79         return (gpointer) *v;
  80 }
  81
  82 static inline
  83 gpointer get_int_v(int64_t *v)
  84 {
  85         return (gpointer) *v;
  86 }
  87
  88 static
  89 guint enum_val_hash(gconstpointer key)
  90 {
  91         return g_direct_hash(key);
  92 }
  93
  94 static
  95 gboolean enum_val_equal(gconstpointer a, gconstpointer b)
  96 {
  97         return g_direct_equal(a, b);
  98 }
  99
 100 static
 101 void enum_val_free(void *ptr)
 102 {
 103 }
 104 #endif /* __WORDSIZE != 32 */
 105
 106 /*
 107  * Returns a GArray or NULL.
 108  * Caller must release the GArray with g_array_unref().
 109  */
 110 GArray *enum_uint_to_quark_set(const struct declaration_enum *enum_declaration,
 111                                uint64_t v)
 112 {
 113         struct enum_range_to_quark *iter;
 114         GArray *qs, *ranges = NULL;
 115
 116         /* Single values lookup */
 117         qs = g_hash_table_lookup(enum_declaration->table.value_to_quark_set,
 118                                  get_uint_v(&v));
 119
 120         /* Range lookup */
 121         cds_list_for_each_entry(iter, &enum_declaration->table.range_to_quark, node) {
 122                 if (iter->range.start._unsigned > v || iter->range.end._unsigned < v)
 123                         continue;
 124                 if (!ranges) {
 125                         size_t qs_len = 0;
 126
 127                         if (qs)
 128                                 qs_len = qs->len;
 129                         ranges = g_array_sized_new(FALSE, TRUE,
 130                                         sizeof(GQuark),
 131                                         qs_len + 1);
 132                         g_array_set_size(ranges, qs_len + 1);
 133                         if (qs)
 134                                 memcpy(ranges->data, qs->data,
 135                                        sizeof(GQuark) * qs_len);
 136                         g_array_index(ranges, GQuark, qs_len) = iter->quark;
 137                 } else {
 138                         size_t qs_len = ranges->len;
 139
 140                         g_array_set_size(ranges, qs_len + 1);
 141                         g_array_index(ranges, GQuark, qs_len) = iter->quark;
 142                 }
 143         }
 144         if (!ranges) {
 145                 if (!qs)
 146                         return NULL;
 147                 ranges = qs;
 148                 g_array_ref(ranges);
 149         }
 150         return ranges;
 151 }
 152
 153 /*
 154  * Returns a GArray or NULL.
 155  * Caller must release the GArray with g_array_unref().
 156  */
 157 GArray *enum_int_to_quark_set(const struct declaration_enum *enum_declaration,
 158                               int64_t v)
 159 {
 160         struct enum_range_to_quark *iter;
 161         GArray *qs, *ranges = NULL;
 162
 163         /* Single values lookup */
 164         qs = g_hash_table_lookup(enum_declaration->table.value_to_quark_set,
 165                                  get_int_v(&v));
 166
 167         /* Range lookup */
 168         cds_list_for_each_entry(iter, &enum_declaration->table.range_to_quark, node) {
 169                 if (iter->range.start._signed > v || iter->range.end._signed < v)
 170                         continue;
 171                 if (!ranges) {
 172                         size_t qs_len = 0;
 173
 174                         if (qs)
 175                                 qs_len = qs->len;
 176                         ranges = g_array_sized_new(FALSE, TRUE,
 177                                         sizeof(GQuark),
 178                                         qs_len + 1);
 179                         g_array_set_size(ranges, qs_len + 1);
 180                         if (qs)
 181                                 memcpy(ranges->data, qs->data,
 182                                        sizeof(GQuark) * qs_len);
 183                         g_array_index(ranges, GQuark, qs_len) = iter->quark;
 184                 } else {
 185                         size_t qs_len = ranges->len;
 186
 187                         g_array_set_size(ranges, qs_len + 1);
 188                         g_array_index(ranges, GQuark, qs_len) = iter->quark;
 189                 }
 190         }
 191         if (!ranges) {
 192                 if (!qs)
 193                         return NULL;
 194                 ranges = qs;
 195                 g_array_ref(ranges);
 196         }
 197         return ranges;
 198 }
 199
 200 static
 201 void enum_unsigned_insert_value_to_quark_set(struct declaration_enum *enum_declaration,
 202                          uint64_t v, GQuark q)
 203 {
 204         uint64_t *valuep;
 205         GArray *array;
 206
 207         array = g_hash_table_lookup(enum_declaration->table.value_to_quark_set,
 208                                     get_uint_v(&v));
 209         if (!array) {
 210                 array = g_array_sized_new(FALSE, TRUE, sizeof(GQuark), 1);
 211                 g_array_set_size(array, 1);
 212                 g_array_index(array, GQuark, array->len - 1) = q;
 213 #if (__WORDSIZE == 32)
 214                 valuep = g_new(uint64_t, 1);
 215                 *valuep = v;
 216 #else  /* __WORDSIZE != 32 */
 217                 valuep = get_uint_v(&v);
 218 #endif /* __WORDSIZE != 32 */
 219                 g_hash_table_insert(enum_declaration->table.value_to_quark_set, valuep, array);
 220         } else {
 221                 g_array_set_size(array, array->len + 1);
 222                 g_array_index(array, GQuark, array->len - 1) = q;
 223         }
 224 }
 225
 226 static
 227 void enum_signed_insert_value_to_quark_set(struct declaration_enum *enum_declaration,
 228                         int64_t v, GQuark q)
 229 {
 230         int64_t *valuep;
 231         GArray *array;
 232
 233         array = g_hash_table_lookup(enum_declaration->table.value_to_quark_set,
 234                                     get_int_v(&v));
 235         if (!array) {
 236                 array = g_array_sized_new(FALSE, TRUE, sizeof(GQuark), 1);
 237                 g_array_set_size(array, 1);
 238                 g_array_index(array, GQuark, array->len - 1) = q;
 239 #if (__WORDSIZE == 32)
 240                 valuep = g_new(int64_t, 1);
 241                 *valuep = v;
 242 #else  /* __WORDSIZE != 32 */
 243                 valuep = get_int_v(&v);
 244 #endif /* __WORDSIZE != 32 */
 245                 g_hash_table_insert(enum_declaration->table.value_to_quark_set, valuep, array);
 246         } else {
 247                 g_array_set_size(array, array->len + 1);
 248                 g_array_index(array, GQuark, array->len - 1) = q;
 249         }
 250 }
 251
 252 GArray *enum_quark_to_range_set(const struct declaration_enum *enum_declaration,
 253                                 GQuark q)
 254 {
 255         return g_hash_table_lookup(enum_declaration->table.quark_to_range_set,
 256                                    (gconstpointer) (unsigned long) q);
 257 }
 258
 259 static
 260 void enum_signed_insert_range_to_quark(struct declaration_enum *enum_declaration,
 261                         int64_t start, int64_t end, GQuark q)
 262 {
 263         struct enum_range_to_quark *rtoq;
 264
 265         rtoq = g_new(struct enum_range_to_quark, 1);
 266         cds_list_add(&rtoq->node, &enum_declaration->table.range_to_quark);
 267         rtoq->range.start._signed = start;
 268         rtoq->range.end._signed = end;
 269         rtoq->quark = q;
 270 }
 271
 272 static
 273 void enum_unsigned_insert_range_to_quark(struct declaration_enum *enum_declaration,
 274                         uint64_t start, uint64_t end, GQuark q)
 275 {
 276         struct enum_range_to_quark *rtoq;
 277
 278         rtoq = g_new(struct enum_range_to_quark, 1);
 279         cds_list_add(&rtoq->node, &enum_declaration->table.range_to_quark);
 280         rtoq->range.start._unsigned = start;
 281         rtoq->range.end._unsigned = end;
 282         rtoq->quark = q;
 283 }
 284
 285 void enum_signed_insert(struct declaration_enum *enum_declaration,
 286                         int64_t start, int64_t end, GQuark q)
 287 {
 288         GArray *array;
 289         struct enum_range *range;
 290
 291         if (start == end) {
 292                 enum_signed_insert_value_to_quark_set(enum_declaration, start, q);
 293         } else {
 294                 if (start > end) {
 295                         uint64_t tmp;
 296
 297                         tmp = start;
 298                         start = end;
 299                         end = tmp;
 300                 }
 301                 enum_signed_insert_range_to_quark(enum_declaration, start, end, q);
 302         }
 303
 304         array = g_hash_table_lookup(enum_declaration->table.quark_to_range_set,
 305                                     (gconstpointer) (unsigned long) q);
 306         if (!array) {
 307                 array = g_array_sized_new(FALSE, TRUE,
 308                                           sizeof(struct enum_range), 1);
 309                 g_hash_table_insert(enum_declaration->table.quark_to_range_set,
 310                                     (gpointer) (unsigned long) q,
 311                                     array);
 312         }
 313         g_array_set_size(array, array->len + 1);
 314         range = &g_array_index(array, struct enum_range, array->len - 1);
 315         range->start._signed = start;
 316         range->end._signed = end;
 317 }
 318
 319 void enum_unsigned_insert(struct declaration_enum *enum_declaration,
 320                           uint64_t start, uint64_t end, GQuark q)
 321 {
 322         GArray *array;
 323         struct enum_range *range;
 324
 325
 326         if (start == end) {
 327                 enum_unsigned_insert_value_to_quark_set(enum_declaration, start, q);
 328         } else {
 329                 if (start > end) {
 330                         uint64_t tmp;
 331
 332                         tmp = start;
 333                         start = end;
 334                         end = tmp;
 335                 }
 336                 enum_unsigned_insert_range_to_quark(enum_declaration, start, end, q);
 337         }
 338
 339         array = g_hash_table_lookup(enum_declaration->table.quark_to_range_set,
 340                                     (gconstpointer) (unsigned long) q);
 341         if (!array) {
 342                 array = g_array_sized_new(FALSE, TRUE,
 343                                           sizeof(struct enum_range), 1);
 344                 g_hash_table_insert(enum_declaration->table.quark_to_range_set,
 345                                     (gpointer) (unsigned long) q,
 346                                     array);
 347         }
 348         g_array_set_size(array, array->len + 1);
 349         range = &g_array_index(array, struct enum_range, array->len - 1);
 350         range->start._unsigned = start;
 351         range->end._unsigned = end;
 352 }
 353
 354 size_t enum_get_nr_enumerators(struct declaration_enum *enum_declaration)
 355 {
 356         return g_hash_table_size(enum_declaration->table.quark_to_range_set);
 357 }
 358
 359 static
 360 void _enum_declaration_free(struct declaration *declaration)
 361 {
 362         struct declaration_enum *enum_declaration =
 363                 container_of(declaration, struct declaration_enum, p);
 364         struct enum_range_to_quark *iter, *tmp;
 365
 366         g_hash_table_destroy(enum_declaration->table.value_to_quark_set);
 367         cds_list_for_each_entry_safe(iter, tmp, &enum_declaration->table.range_to_quark, node) {
 368                 cds_list_del(&iter->node);
 369                 g_free(iter);
 370         }
 371         g_hash_table_destroy(enum_declaration->table.quark_to_range_set);
 372         declaration_unref(&enum_declaration->integer_declaration->p);
 373         g_free(enum_declaration);
 374 }
 375
 376 struct declaration_enum *
 377         enum_declaration_new(struct declaration_integer *integer_declaration)
 378 {
 379         struct declaration_enum *enum_declaration;
 380
 381         enum_declaration = g_new(struct declaration_enum, 1);
 382
 383         enum_declaration->table.value_to_quark_set = g_hash_table_new_full(enum_val_hash,
 384                                                             enum_val_equal,
 385                                                             enum_val_free,
 386                                                             enum_range_set_free);
 387         CDS_INIT_LIST_HEAD(&enum_declaration->table.range_to_quark);
 388         enum_declaration->table.quark_to_range_set = g_hash_table_new_full(g_direct_hash,
 389                                                         g_direct_equal,
 390                                                         NULL, enum_range_set_free);
 391         declaration_ref(&integer_declaration->p);
 392         enum_declaration->integer_declaration = integer_declaration;
 393         enum_declaration->p.id = CTF_TYPE_ENUM;
 394         enum_declaration->p.alignment = 1;
 395         enum_declaration->p.declaration_free = _enum_declaration_free;
 396         enum_declaration->p.definition_new = _enum_definition_new;
 397         enum_declaration->p.definition_free = _enum_definition_free;
 398         enum_declaration->p.ref = 1;
 399         return enum_declaration;
 400 }
 401
 402 static
 403 struct definition *
 404         _enum_definition_new(struct declaration *declaration,
 405                              struct definition_scope *parent_scope,
 406                              GQuark field_name, int index,
 407                              const char *root_name)
 408 {
 409         struct declaration_enum *enum_declaration =
 410                 container_of(declaration, struct declaration_enum, p);
 411         struct definition_enum *_enum;
 412         struct definition *definition_integer_parent;
 413         int ret;
 414
 415         _enum = g_new(struct definition_enum, 1);
 416         declaration_ref(&enum_declaration->p);
 417         _enum->p.declaration = declaration;
 418         _enum->declaration = enum_declaration;
 419         _enum->p.ref = 1;
 420         /*
 421          * Use INT_MAX order to ensure that all fields of the parent
 422          * scope are seen as being prior to this scope.
 423          */
 424         _enum->p.index = root_name ? INT_MAX : index;
 425         _enum->p.name = field_name;
 426         _enum->p.path = new_definition_path(parent_scope, field_name, root_name);
 427         _enum->p.scope = new_definition_scope(parent_scope, field_name, root_name);
 428         _enum->value = NULL;
 429         ret = register_field_definition(field_name, &_enum->p,
 430                                         parent_scope);
 431         assert(!ret);
 432         definition_integer_parent =
 433                 enum_declaration->integer_declaration->p.definition_new(&enum_declaration->integer_declaration->p,
 434                                 _enum->p.scope,
 435                                 g_quark_from_static_string("container"), 0, NULL);
 436         _enum->integer = container_of(definition_integer_parent,
 437                                       struct definition_integer, p);
 438         return &_enum->p;
 439 }
 440
 441 static
 442 void _enum_definition_free(struct definition *definition)
 443 {
 444         struct definition_enum *_enum =
 445                 container_of(definition, struct definition_enum, p);
 446
 447         definition_unref(&_enum->integer->p);
 448         free_definition_scope(_enum->p.scope);
 449         declaration_unref(_enum->p.declaration);
 450         if (_enum->value)
 451                 g_array_unref(_enum->value);
 452         g_free(_enum);
 453 }