types/array.c

   1 /*
   2  * array.c
   3  *
   4  * BabelTrace - Array Type Converter
   5  *
   6  * Copyright 2010, 2011 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a copy
   9  * of this software and associated documentation files (the "Software"), to deal
  10  * in the Software without restriction, including without limitation the rights
  11  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12  * copies of the Software, and to permit persons to whom the Software is
  13  * furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  */
  18
  19 #include <babeltrace/compiler.h>
  20 #include <babeltrace/format.h>
  21 #include <inttypes.h>
  22
  23 static
  24 struct definition *_array_definition_new(struct declaration *declaration,
  25                         struct definition_scope *parent_scope,
  26                         GQuark field_name, int index, const char *root_name);
  27 static
  28 void _array_definition_free(struct definition *definition);
  29
  30 int array_rw(struct stream_pos *pos, struct definition *definition)
  31 {
  32         struct definition_array *array_definition =
  33                 container_of(definition, struct definition_array, p);
  34         const struct declaration_array *array_declaration =
  35                 array_definition->declaration;
  36         uint64_t i;
  37         int ret;
  38
  39         /* No need to align, because the first field will align itself. */
  40         for (i = 0; i < array_declaration->len; i++) {
  41                 struct definition *field =
  42                         g_ptr_array_index(array_definition->elems, i);
  43                 ret = generic_rw(pos, field);
  44                 if (ret)
  45                         return ret;
  46         }
  47         return 0;
  48 }
  49
  50 static
  51 void _array_declaration_free(struct declaration *declaration)
  52 {
  53         struct declaration_array *array_declaration =
  54                 container_of(declaration, struct declaration_array, p);
  55
  56         free_declaration_scope(array_declaration->scope);
  57         declaration_unref(array_declaration->elem);
  58         g_free(array_declaration);
  59 }
  60
  61 struct declaration_array *
  62         array_declaration_new(size_t len,
  63                               struct declaration *elem_declaration,
  64                               struct declaration_scope *parent_scope)
  65 {
  66         struct declaration_array *array_declaration;
  67         struct declaration *declaration;
  68
  69         array_declaration = g_new(struct declaration_array, 1);
  70         declaration = &array_declaration->p;
  71         array_declaration->len = len;
  72         declaration_ref(elem_declaration);
  73         array_declaration->elem = elem_declaration;
  74         array_declaration->scope = new_declaration_scope(parent_scope);
  75         declaration->id = CTF_TYPE_ARRAY;
  76         /* No need to align the array, the first element will align itself */
  77         declaration->alignment = 1;
  78         declaration->declaration_free = _array_declaration_free;
  79         declaration->definition_new = _array_definition_new;
  80         declaration->definition_free = _array_definition_free;
  81         declaration->ref = 1;
  82         return array_declaration;
  83 }
  84
  85 static
  86 struct definition *
  87         _array_definition_new(struct declaration *declaration,
  88                               struct definition_scope *parent_scope,
  89                               GQuark field_name, int index, const char *root_name)
  90 {
  91         struct declaration_array *array_declaration =
  92                 container_of(declaration, struct declaration_array, p);
  93         struct definition_array *array;
  94         int ret;
  95         int i;
  96
  97         array = g_new(struct definition_array, 1);
  98         declaration_ref(&array_declaration->p);
  99         array->p.declaration = declaration;
 100         array->declaration = array_declaration;
 101         array->p.ref = 1;
 102         /*
 103          * Use INT_MAX order to ensure that all fields of the parent
 104          * scope are seen as being prior to this scope.
 105          */
 106         array->p.index = root_name ? INT_MAX : index;
 107         array->p.name = field_name;
 108         array->p.path = new_definition_path(parent_scope, field_name, root_name);
 109         array->p.scope = new_definition_scope(parent_scope, field_name, root_name);
 110         ret = register_field_definition(field_name, &array->p,
 111                                         parent_scope);
 112         assert(!ret);
 113         array->string = NULL;
 114         array->elems = NULL;
 115
 116         if (array_declaration->elem->id == CTF_TYPE_INTEGER) {
 117                 struct declaration_integer *integer_declaration =
 118                         container_of(array_declaration->elem, struct declaration_integer, p);
 119
 120                 if (integer_declaration->encoding == CTF_STRING_UTF8
 121                       || integer_declaration->encoding == CTF_STRING_ASCII) {
 122
 123                         array->string = g_string_new("");
 124
 125                         if (integer_declaration->len == CHAR_BIT
 126                             && integer_declaration->p.alignment == CHAR_BIT) {
 127                                 return &array->p;
 128                         }
 129                 }
 130         }
 131
 132         array->elems = g_ptr_array_sized_new(array_declaration->len);
 133         g_ptr_array_set_size(array->elems, array_declaration->len);
 134         for (i = 0; i < array_declaration->len; i++) {
 135                 struct definition **field;
 136                 GString *str;
 137                 GQuark name;
 138
 139                 str = g_string_new("");
 140                 g_string_printf(str, "[%u]", (unsigned int) i);
 141                 name = g_quark_from_string(str->str);
 142                 (void) g_string_free(str, TRUE);
 143
 144                 field = (struct definition **) &g_ptr_array_index(array->elems, i);
 145                 *field = array_declaration->elem->definition_new(array_declaration->elem,
 146                                           array->p.scope,
 147                                           name, i, NULL);
 148                 if (!*field)
 149                         goto error;
 150         }
 151
 152         return &array->p;
 153
 154 error:
 155         for (i--; i >= 0; i--) {
 156                 struct definition *field;
 157
 158                 field = g_ptr_array_index(array->elems, i);
 159                 field->declaration->definition_free(field);
 160         }
 161         (void) g_ptr_array_free(array->elems, TRUE);
 162         free_definition_scope(array->p.scope);
 163         declaration_unref(array->p.declaration);
 164         g_free(array);
 165         return NULL;
 166 }
 167
 168 static
 169 void _array_definition_free(struct definition *definition)
 170 {
 171         struct definition_array *array =
 172                 container_of(definition, struct definition_array, p);
 173         uint64_t i;
 174
 175         if (array->string)
 176                 (void) g_string_free(array->string, TRUE);
 177         if (array->elems) {
 178                 for (i = 0; i < array->elems->len; i++) {
 179                         struct definition *field;
 180
 181                         field = g_ptr_array_index(array->elems, i);
 182                         field->declaration->definition_free(field);
 183                 }
 184                 (void) g_ptr_array_free(array->elems, TRUE);
 185         }
 186         free_definition_scope(array->p.scope);
 187         declaration_unref(array->p.declaration);
 188         g_free(array);
 189 }
 190
 191 uint64_t array_len(struct definition_array *array)
 192 {
 193         if (!array->elems)
 194                 return array->string->len;
 195         return array->elems->len;
 196 }
 197
 198 struct definition *array_index(struct definition_array *array, uint64_t i)
 199 {
 200         if (!array->elems)
 201                 return NULL;
 202         if (i >= array->elems->len)
 203                 return NULL;
 204         return g_ptr_array_index(array->elems, i);
 205 }