X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=types%2Farray.c;h=cd7b31bf2724e8aedab636be99dd0cc0bcc1133f;hp=6ac4a1a1cbfab26b06ef5648380b48ceb1264d95;hb=809cbff588674d09c14b128eb95d332048382770;hpb=c054553dac076f91196b372fa19efaf2adc4e4f9 diff --git a/types/array.c b/types/array.c index 6ac4a1a1..cd7b31bf 100644 --- a/types/array.c +++ b/types/array.c @@ -18,104 +18,133 @@ #include #include +#include static -struct type *_array_type_new(struct type_class *type_class, - 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_type_free(struct type *type); +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 type *type) +void array_rw(struct stream_pos *pos, struct definition *definition) { - struct type_sequence *array = container_of(type, struct type_array, p); - struct type_class_array *array_class = array->_class; + 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_class); - fdest->array_begin(dest, array_class); - - for (i = 0; i < array_class->len; i++) { - struct type_class *elem_class = array->current_element.type; - elem_type->p._class->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_class); - fdest->array_end(dest, array_class); } static -void _array_type_class_free(struct type_class *type_class) +void _array_declaration_free(struct declaration *declaration) { - struct type_class_array *array_class = - container_of(type_class, struct type_class_array, p); + struct declaration_array *array_declaration = + container_of(declaration, struct declaration_array, p); - type_class_unref(array_class->elem); - g_free(array_class); + free_declaration_scope(array_declaration->scope); + declaration_unref(array_declaration->elem); + g_free(array_declaration); } -struct type_class_array * -array_type_class_new(const char *name, size_t len, struct type_class *elem) +struct declaration_array * + array_declaration_new(size_t len, + struct declaration *elem_declaration, + struct declaration_scope *parent_scope) { - struct type_class_array *array_class; - struct type_class *type_class; - int ret; - - array_class = g_new(struct type_class_array, 1); - type_class = &array_class->p; - array_class->len = len; - type_ref(elem); - array_class->elem = elem; - type_class->name = g_quark_from_string(name); - /* No need to align the array, the first element will align itself */ - type_class->alignment = 1; - type_class->copy = array_copy; - type_class->class_free = _array_type_class_free; - type_class->type_new = _array_type_new; - type_class->type_free = _array_type_free; - type_class->ref = 1; - - if (type_class->name) { - ret = register_type(type_class); - if (ret) - goto error_register; - } - return array_class; + struct declaration_array *array_declaration; + struct declaration *declaration; -error_register: - type_class_unref(array_class->elem); - g_free(array_class); - 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 type_array *_array_type_new(struct type_class *type_class, - 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_class_array *array_class = - container_of(type_class, struct type_class_array, p); - struct type_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 type_array, 1); - type_class_ref(&array_class->p); - array->p._class = array_class; + 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.type = - array_class->elem.p->type_new(&array_class->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_type_free(struct type *type) +void _array_definition_free(struct definition *definition) { - struct type_array *array = - container_of(type, struct type_array, p); - struct type *elem_type = array->current_element.type; + struct definition_array *array = + container_of(definition, struct definition_array, p); + uint64_t i; - elem_type->p._class->type_free(elem_type); - free_declaration_scope(array->scope); - type_class_unref(array->p._class); + 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; +}