types/variant.c

   1 /*
   2  * variant.c
   3  *
   4  * BabelTrace - Variant Type Converter
   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  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28
  29 #include <babeltrace/compiler.h>
  30 #include <babeltrace/format.h>
  31 #include <babeltrace/types.h>
  32 #include <errno.h>
  33
  34 static
  35 struct bt_definition *_variant_definition_new(struct bt_declaration *declaration,
  36                                 struct definition_scope *parent_scope,
  37                                 GQuark field_name, int index,
  38                                 const char *root_name);
  39 static
  40 void _variant_definition_free(struct bt_definition *definition);
  41
  42 int bt_variant_rw(struct bt_stream_pos *ppos, struct bt_definition *definition)
  43 {
  44         struct definition_variant *variant_definition =
  45                 container_of(definition, struct definition_variant, p);
  46         struct bt_definition *field;
  47
  48         field = bt_variant_get_current_field(variant_definition);
  49         return generic_rw(ppos, field);
  50 }
  51
  52 static
  53 void _untagged_variant_declaration_free(struct bt_declaration *declaration)
  54 {
  55         struct declaration_untagged_variant *untagged_variant_declaration =
  56                 container_of(declaration, struct declaration_untagged_variant, p);
  57         unsigned long i;
  58
  59         bt_free_declaration_scope(untagged_variant_declaration->scope);
  60         g_hash_table_destroy(untagged_variant_declaration->fields_by_tag);
  61
  62         for (i = 0; i < untagged_variant_declaration->fields->len; i++) {
  63                 struct declaration_field *declaration_field =
  64                         &g_array_index(untagged_variant_declaration->fields,
  65                                        struct declaration_field, i);
  66                 bt_declaration_unref(declaration_field->declaration);
  67         }
  68         g_array_free(untagged_variant_declaration->fields, true);
  69         g_free(untagged_variant_declaration);
  70 }
  71
  72 struct declaration_untagged_variant *bt_untagged_bt_variant_declaration_new(
  73                                       struct declaration_scope *parent_scope)
  74 {
  75         struct declaration_untagged_variant *untagged_variant_declaration;
  76         struct bt_declaration *declaration;
  77
  78         untagged_variant_declaration = g_new(struct declaration_untagged_variant, 1);
  79         declaration = &untagged_variant_declaration->p;
  80         untagged_variant_declaration->fields_by_tag = g_hash_table_new(g_direct_hash,
  81                                                        g_direct_equal);
  82         untagged_variant_declaration->fields = g_array_sized_new(FALSE, TRUE,
  83                                                  sizeof(struct declaration_field),
  84                                                  DEFAULT_NR_STRUCT_FIELDS);
  85         untagged_variant_declaration->scope = bt_new_declaration_scope(parent_scope);
  86         declaration->id = CTF_TYPE_UNTAGGED_VARIANT;
  87         declaration->alignment = 1;
  88         declaration->declaration_free = _untagged_variant_declaration_free;
  89         declaration->definition_new = NULL;
  90         declaration->definition_free = NULL;
  91         declaration->ref = 1;
  92         return untagged_variant_declaration;
  93 }
  94
  95 static
  96 void _variant_declaration_free(struct bt_declaration *declaration)
  97 {
  98         struct declaration_variant *variant_declaration =
  99                 container_of(declaration, struct declaration_variant, p);
 100
 101         bt_declaration_unref(&variant_declaration->untagged_variant->p);
 102         g_array_free(variant_declaration->tag_name, TRUE);
 103         g_free(variant_declaration);
 104 }
 105
 106 struct declaration_variant *
 107         bt_variant_declaration_new(struct declaration_untagged_variant *untagged_variant, const char *tag)
 108 {
 109         struct declaration_variant *variant_declaration;
 110         struct bt_declaration *declaration;
 111
 112         variant_declaration = g_new(struct declaration_variant, 1);
 113         declaration = &variant_declaration->p;
 114         variant_declaration->untagged_variant = untagged_variant;
 115         bt_declaration_ref(&untagged_variant->p);
 116         variant_declaration->tag_name = g_array_new(FALSE, TRUE, sizeof(GQuark));
 117         bt_append_scope_path(tag, variant_declaration->tag_name);
 118         declaration->id = CTF_TYPE_VARIANT;
 119         declaration->alignment = 1;
 120         declaration->declaration_free = _variant_declaration_free;
 121         declaration->definition_new = _variant_definition_new;
 122         declaration->definition_free = _variant_definition_free;
 123         declaration->ref = 1;
 124         return variant_declaration;
 125 }
 126
 127 static
 128 struct bt_definition *
 129         _variant_definition_new(struct bt_declaration *declaration,
 130                                 struct definition_scope *parent_scope,
 131                                 GQuark field_name, int index,
 132                                 const char *root_name)
 133 {
 134         struct declaration_variant *variant_declaration =
 135                 container_of(declaration, struct declaration_variant, p);
 136         struct definition_variant *variant;
 137         unsigned long i;
 138         int ret;
 139
 140         variant = g_new(struct definition_variant, 1);
 141         bt_declaration_ref(&variant_declaration->p);
 142         variant->p.declaration = declaration;
 143         variant->declaration = variant_declaration;
 144         variant->p.ref = 1;
 145         /*
 146          * Use INT_MAX order to ensure that all fields of the parent
 147          * scope are seen as being prior to this scope.
 148          */
 149         variant->p.index = root_name ? INT_MAX : index;
 150         variant->p.name = field_name;
 151         variant->p.path = bt_new_definition_path(parent_scope, field_name, root_name);
 152         variant->p.scope = bt_new_definition_scope(parent_scope, field_name, root_name);
 153
 154         ret = bt_register_field_definition(field_name, &variant->p,
 155                                         parent_scope);
 156         assert(!ret);
 157
 158         variant->enum_tag = bt_lookup_path_definition(variant->p.scope->scope_path,
 159                                                    variant_declaration->tag_name,
 160                                                    parent_scope);
 161
 162         if (!variant->enum_tag)
 163                 goto error;
 164         bt_definition_ref(variant->enum_tag);
 165         variant->fields = g_ptr_array_sized_new(variant_declaration->untagged_variant->fields->len);
 166         g_ptr_array_set_size(variant->fields, variant_declaration->untagged_variant->fields->len);
 167         for (i = 0; i < variant_declaration->untagged_variant->fields->len; i++) {
 168                 struct declaration_field *declaration_field =
 169                         &g_array_index(variant_declaration->untagged_variant->fields,
 170                                        struct declaration_field, i);
 171                 struct bt_definition **field =
 172                         (struct bt_definition **) &g_ptr_array_index(variant->fields, i);
 173
 174                 /*
 175                  * All child definition are at index 0, because they are
 176                  * various choices of the same field.
 177                  */
 178                 *field = declaration_field->declaration->definition_new(declaration_field->declaration,
 179                                                   variant->p.scope,
 180                                                   declaration_field->name, 0, NULL);
 181                 if (!*field)
 182                         goto error;
 183         }
 184         variant->current_field = NULL;
 185         return &variant->p;
 186 error:
 187         bt_free_definition_scope(variant->p.scope);
 188         bt_declaration_unref(&variant_declaration->p);
 189         g_free(variant);
 190         return NULL;
 191 }
 192
 193 static
 194 void _variant_definition_free(struct bt_definition *definition)
 195 {
 196         struct definition_variant *variant =
 197                 container_of(definition, struct definition_variant, p);
 198         unsigned long i;
 199
 200         assert(variant->fields->len == variant->declaration->untagged_variant->fields->len);
 201         for (i = 0; i < variant->fields->len; i++) {
 202                 struct bt_definition *field = g_ptr_array_index(variant->fields, i);
 203                 bt_definition_unref(field);
 204         }
 205         bt_definition_unref(variant->enum_tag);
 206         bt_free_definition_scope(variant->p.scope);
 207         bt_declaration_unref(variant->p.declaration);
 208         g_ptr_array_free(variant->fields, TRUE);
 209         g_free(variant);
 210 }
 211
 212 void bt_untagged_variant_declaration_add_field(struct declaration_untagged_variant *untagged_variant_declaration,
 213                             const char *field_name,
 214                             struct bt_declaration *field_declaration)
 215 {
 216         struct declaration_field *field;
 217         unsigned long index;
 218
 219         g_array_set_size(untagged_variant_declaration->fields, untagged_variant_declaration->fields->len + 1);
 220         index = untagged_variant_declaration->fields->len - 1;  /* last field (new) */
 221         field = &g_array_index(untagged_variant_declaration->fields, struct declaration_field, index);
 222         field->name = g_quark_from_string(field_name);
 223         bt_declaration_ref(field_declaration);
 224         field->declaration = field_declaration;
 225         /* Keep index in hash rather than pointer, because array can relocate */
 226         g_hash_table_insert(untagged_variant_declaration->fields_by_tag,
 227                             (gpointer) (unsigned long) field->name,
 228                             (gpointer) index);
 229         /*
 230          * Alignment of variant is based on the alignment of its currently
 231          * selected choice, so we leave variant alignment as-is (statically
 232          * speaking).
 233          */
 234 }
 235
 236 struct declaration_field *
 237 bt_untagged_variant_declaration_get_field_from_tag(struct declaration_untagged_variant *untagged_variant_declaration, GQuark tag)
 238 {
 239         gpointer index;
 240         gboolean found;
 241
 242         found = g_hash_table_lookup_extended(
 243                                 untagged_variant_declaration->fields_by_tag,
 244                                 (gconstpointer) (unsigned long) tag, NULL, &index);
 245
 246         if (!found) {
 247                 return NULL;
 248         }
 249
 250         return &g_array_index(untagged_variant_declaration->fields, struct declaration_field, (unsigned long)index);
 251 }
 252
 253 /*
 254  * field returned only valid as long as the field structure is not appended to.
 255  */
 256 struct bt_definition *bt_variant_get_current_field(struct definition_variant *variant)
 257 {
 258         struct definition_enum *_enum =
 259                 container_of(variant->enum_tag, struct definition_enum, p);
 260         struct declaration_variant *variant_declaration = variant->declaration;
 261         unsigned long index;
 262         GArray *tag_array;
 263         GQuark tag;
 264
 265         tag_array = _enum->value;
 266         /*
 267          * The 1 to 1 mapping from enumeration to value should have been already
 268          * checked. (see TODO above)
 269          */
 270         assert(tag_array->len == 1);
 271         tag = g_array_index(tag_array, GQuark, 0);
 272         index = (unsigned long) g_hash_table_lookup(variant_declaration->untagged_variant->fields_by_tag,
 273                                                     (gconstpointer) (unsigned long) tag);
 274         variant->current_field = g_ptr_array_index(variant->fields, index);
 275         return variant->current_field;
 276 }