X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=types%2Farray.c;h=cd7b31bf2724e8aedab636be99dd0cc0bcc1133f;hp=6dd3b9ca8a6c869e419ef17c54ff9141ebf8c31f;hb=809cbff588674d09c14b128eb95d332048382770;hpb=e19c3d69b39d2fa422ab54b5ec7192799f536680 diff --git a/types/array.c b/types/array.c index 6dd3b9ca..cd7b31bf 100644 --- a/types/array.c +++ b/types/array.c @@ -18,107 +18,133 @@ #include #include +#include static -struct declaration *_array_declaration_new(struct type *type, - struct declaration_scope *parent_scope); +struct definition *_array_definition_new(struct declaration *declaration, + struct definition_scope *parent_scope, + GQuark field_name, int index); static -void _array_declaration_free(struct declaration *declaration); +void _array_definition_free(struct definition *definition); -void array_copy(struct stream_pos *dest, const struct format *fdest, - struct stream_pos *src, const struct format *fsrc, - struct declaration *declaration) +void array_rw(struct stream_pos *pos, struct definition *definition) { - struct declaration_array *array = - container_of(declaration, struct declaration_array, p); - struct type_array *array_type = array->type; + struct definition_array *array_definition = + container_of(definition, struct definition_array, p); + const struct declaration_array *array_declaration = + array_definition->declaration; uint64_t i; - fsrc->array_begin(src, array_type); - fdest->array_begin(dest, array_type); - - for (i = 0; i < array_type->len; i++) { - struct type *elem_type = array->current_element.type; - elem_type->p.type->copy(dest, fdest, src, fsrc, elem_type); + /* No need to align, because the first field will align itself. */ + for (i = 0; i < array_declaration->len; i++) { + struct definition *elem = + g_array_index(array_definition->elems, struct field, i).definition; + generic_rw(pos, elem); } - fsrc->array_end(src, array_type); - fdest->array_end(dest, array_type); } static -void _array_type_free(struct type *type) +void _array_declaration_free(struct declaration *declaration) { - struct type_array *array_type = - container_of(type, struct type_array, p); + struct declaration_array *array_declaration = + container_of(declaration, struct declaration_array, p); - type_unref(array_type->elem); - g_free(array_type); + free_declaration_scope(array_declaration->scope); + declaration_unref(array_declaration->elem); + g_free(array_declaration); } -struct type_array * - array_type_new(const char *name, size_t len, struct type *elem_type) +struct declaration_array * + array_declaration_new(size_t len, + struct declaration *elem_declaration, + struct declaration_scope *parent_scope) { - struct type_array *array_type; - struct type *type; - int ret; - - array_type = g_new(struct type_array, 1); - type = &array_type->p; - array_type->len = len; - type_ref(elem_type); - array_type->elem = elem_type; - type->name = g_quark_from_string(name); - /* No need to align the array, the first element will align itself */ - type->alignment = 1; - type->copy = array_copy; - type->type_free = _array_type_free; - type->declaration_new = _array_declaration_new; - type->declaration_free = _array_declaration_free; - type->ref = 1; - - if (type->name) { - ret = register_type(type); - if (ret) - goto error_register; - } - return array_type; + struct declaration_array *array_declaration; + struct declaration *declaration; -error_register: - type_unref(array_type->elem); - g_free(array_type); - return NULL; + array_declaration = g_new(struct declaration_array, 1); + declaration = &array_declaration->p; + array_declaration->len = len; + declaration_ref(elem_declaration); + array_declaration->elem = elem_declaration; + array_declaration->scope = new_declaration_scope(parent_scope); + declaration->id = CTF_TYPE_ARRAY; + /* No need to align the array, the first element will align itself */ + declaration->alignment = 1; + declaration->declaration_free = _array_declaration_free; + declaration->definition_new = _array_definition_new; + declaration->definition_free = _array_definition_free; + declaration->ref = 1; + return array_declaration; } static -struct declaration * - _array_declaration_new(struct type *type, - struct declaration_scope *parent_scope) +struct definition * + _array_definition_new(struct declaration *declaration, + struct definition_scope *parent_scope, + GQuark field_name, int index) { - struct type_array *array_type = - container_of(type, struct type_array, p); - struct declaration_array *array; + struct declaration_array *array_declaration = + container_of(declaration, struct declaration_array, p); + struct definition_array *array; + uint64_t i; - array = g_new(struct declaration_array, 1); - type_ref(&array_type->p); - array->p.type = array_type; + array = g_new(struct definition_array, 1); + declaration_ref(&array_declaration->p); + array->p.declaration = declaration; + array->declaration = array_declaration; array->p.ref = 1; - array->scope = new_declaration_scope(parent_scope); - array->current_element.declaration = - array_type->elem.p->declaration_new(&array_type->elem.p, - parent_scope); + array->p.index = index; + array->scope = new_definition_scope(parent_scope, field_name); + array->elems = g_array_sized_new(FALSE, TRUE, sizeof(struct field), + array_declaration->len); + g_array_set_size(array->elems, array_declaration->len); + for (i = 0; i < array_declaration->len; i++) { + struct field *field; + GString *str; + GQuark name; + + str = g_string_new(""); + g_string_printf(str, "[%" PRIu64 "]", i); + name = g_quark_from_string(str->str); + (void) g_string_free(str, TRUE); + + field = &g_array_index(array->elems, struct field, i); + field->name = name; + field->definition = array_declaration->elem->definition_new(array_declaration->elem, + array->scope, + name, i); + } return &array->p; } static -void _array_declaration_free(struct declaration *declaration) +void _array_definition_free(struct definition *definition) { - struct type_array *array = - container_of(declaration, struct type_array, p); - struct declaration *elem_declaration = - array->current_element.declaration; - - elem_type->p.type->declaration_free(elem_type); - free_declaration_scope(array->scope); - type_unref(array->p.type); + struct definition_array *array = + container_of(definition, struct definition_array, p); + uint64_t i; + + for (i = 0; i < array->elems->len; i++) { + struct field *field; + + field = &g_array_index(array->elems, struct field, i); + field->definition->declaration->definition_free(field->definition); + } + (void) g_array_free(array->elems, TRUE); + free_definition_scope(array->scope); + declaration_unref(array->p.declaration); g_free(array); } + +uint64_t array_len(struct definition_array *array) +{ + return array->elems->len; +} + +struct definition *array_index(struct definition_array *array, uint64_t i) +{ + if (i >= array->elems->len) + return NULL; + return g_array_index(array->elems, struct field, i).definition; +}