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);
  27 static
  28 void _array_definition_free(struct definition *definition);
  29
  30 void array_copy(struct stream_pos *dest, const struct format *fdest,
  31                 struct stream_pos *src, const struct format *fsrc,
  32                 struct definition *definition)
  33 {
  34         struct definition_array *array =
  35                 container_of(definition, struct definition_array, p);
  36         struct declaration_array *array_declaration = array->declaration;
  37         uint64_t i;
  38
  39         fsrc->array_begin(src, array_declaration);
  40         if (fdest)
  41                 fdest->array_begin(dest, array_declaration);
  42
  43         for (i = 0; i < array_declaration->len; i++) {
  44                 struct definition *elem =
  45                         g_array_index(array->elems, struct field, i).definition;
  46                 elem->declaration->copy(dest, fdest, src, fsrc, elem);
  47         }
  48         fsrc->array_end(src, array_declaration);
  49         if (fdest)
  50                 fdest->array_end(dest, array_declaration);
  51 }
  52
  53 static
  54 void _array_declaration_free(struct declaration *declaration)
  55 {
  56         struct declaration_array *array_declaration =
  57                 container_of(declaration, struct declaration_array, p);
  58
  59         free_declaration_scope(array_declaration->scope);
  60         declaration_unref(array_declaration->elem);
  61         g_free(array_declaration);
  62 }
  63
  64 struct declaration_array *
  65         array_declaration_new(size_t len,
  66                               struct declaration *elem_declaration,
  67                               struct declaration_scope *parent_scope)
  68 {
  69         struct declaration_array *array_declaration;
  70         struct declaration *declaration;
  71
  72         array_declaration = g_new(struct declaration_array, 1);
  73         declaration = &array_declaration->p;
  74         array_declaration->len = len;
  75         declaration_ref(elem_declaration);
  76         array_declaration->elem = elem_declaration;
  77         array_declaration->scope = new_declaration_scope(parent_scope);
  78         declaration->id = CTF_TYPE_ARRAY;
  79         /* No need to align the array, the first element will align itself */
  80         declaration->alignment = 1;
  81         declaration->copy = array_copy;
  82         declaration->declaration_free = _array_declaration_free;
  83         declaration->definition_new = _array_definition_new;
  84         declaration->definition_free = _array_definition_free;
  85         declaration->ref = 1;
  86         return array_declaration;
  87 }
  88
  89 static
  90 struct definition *
  91         _array_definition_new(struct declaration *declaration,
  92                               struct definition_scope *parent_scope,
  93                               GQuark field_name, int index)
  94 {
  95         struct declaration_array *array_declaration =
  96                 container_of(declaration, struct declaration_array, p);
  97         struct definition_array *array;
  98         uint64_t i;
  99
 100         array = g_new(struct definition_array, 1);
 101         declaration_ref(&array_declaration->p);
 102         array->p.declaration = declaration;
 103         array->declaration = array_declaration;
 104         array->p.ref = 1;
 105         array->p.index = index;
 106         array->scope = new_definition_scope(parent_scope, field_name);
 107         array->elems = g_array_sized_new(FALSE, TRUE, sizeof(struct field),
 108                                          array_declaration->len);
 109         g_array_set_size(array->elems, array_declaration->len);
 110         for (i = 0; i < array_declaration->len; i++) {
 111                 struct field *field;
 112                 GString *str;
 113                 GQuark name;
 114
 115                 str = g_string_new("");
 116                 g_string_printf(str, "[%" PRIu64 "]", i);
 117                 name = g_quark_from_string(str->str);
 118                 (void) g_string_free(str, TRUE);
 119
 120                 field = &g_array_index(array->elems, struct field, i);
 121                 field->name = name;
 122                 field->definition = array_declaration->elem->definition_new(array_declaration->elem,
 123                                           array->scope,
 124                                           name, i);
 125         }
 126         return &array->p;
 127 }
 128
 129 static
 130 void _array_definition_free(struct definition *definition)
 131 {
 132         struct definition_array *array =
 133                 container_of(definition, struct definition_array, p);
 134         uint64_t i;
 135
 136         for (i = 0; i < array->elems->len; i++) {
 137                 struct field *field;
 138
 139                 field = &g_array_index(array->elems, struct field, i);
 140                 field->definition->declaration->definition_free(field->definition);
 141         }
 142         (void) g_array_free(array->elems, TRUE);
 143         free_definition_scope(array->scope);
 144         declaration_unref(array->p.declaration);
 145         g_free(array);
 146 }
 147
 148 uint64_t array_len(struct definition_array *array)
 149 {
 150         return array->elems->len;
 151 }
 152
 153 struct definition *array_index(struct definition_array *array, uint64_t i)
 154 {
 155         if (i >= array->elems->len)
 156                 return NULL;
 157         return g_array_index(array->elems, struct field, i).definition;
 158 }