From d06d03dbf4babd3426818f23770e15058a6876c4 Mon Sep 17 00:00:00 2001 From: Mathieu Desnoyers Date: Mon, 4 Oct 2010 23:09:09 -0400 Subject: [PATCH] Add array Signed-off-by: Mathieu Desnoyers --- formats/ctf/ctf.c | 4 ++ formats/ctf/types/array.c | 34 ++++++++++++++ formats/ctf/types/sequence.c | 34 ++++++++++++++ formats/ctf/types/struct.c | 1 - include/babeltrace/ctf/types.h | 8 ++++ include/babeltrace/format.h | 8 ++++ include/babeltrace/types.h | 10 ++++- types/array.c | 82 ++++++++++++++++++++++++++++++++++ types/float.c | 3 ++ types/struct.c | 2 +- 10 files changed, 183 insertions(+), 3 deletions(-) create mode 100644 formats/ctf/types/array.c create mode 100644 formats/ctf/types/sequence.c create mode 100644 types/array.c diff --git a/formats/ctf/ctf.c b/formats/ctf/ctf.c index 63fe47e3..48c62c02 100644 --- a/formats/ctf/ctf.c +++ b/formats/ctf/ctf.c @@ -41,6 +41,10 @@ static const struct format ctf_format = { .enum_write = ctf_enum_write, .struct_begin = ctf_struct_begin, .struct_end = ctf_struct_end, + .array_begin = ctf_array_begin, + .array_end = ctf_array_end, + .sequence_begin = ctf_sequence_begin, + .sequence_end = ctf_sequence_end, }; void ctf_init(void) diff --git a/formats/ctf/types/array.c b/formats/ctf/types/array.c new file mode 100644 index 00000000..0133268f --- /dev/null +++ b/formats/ctf/types/array.c @@ -0,0 +1,34 @@ +/* + * Common Trace Format + * + * Array format access functions. + * + * Copyright (c) 2010 Mathieu Desnoyers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include + +void ctf_array_begin(struct stream_pos *pos, + const struct type_class_array *array_class) +{ + /* No need to align, because the first field will align itself. */ +} + +void ctf_array_end(struct stream_pos *pos, + const struct type_class_array *array_class) +{ +} diff --git a/formats/ctf/types/sequence.c b/formats/ctf/types/sequence.c new file mode 100644 index 00000000..c4c34229 --- /dev/null +++ b/formats/ctf/types/sequence.c @@ -0,0 +1,34 @@ +/* + * Common Trace Format + * + * Sequence format access functions. + * + * Copyright (c) 2010 Mathieu Desnoyers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include + +void ctf_sequence_begin(struct stream_pos *pos, + const struct type_class_sequence *sequence_class) +{ + align_pos(pos, sequence_class->p.alignment); +} + +void ctf_sequence_end(struct stream_pos *pos, + const struct type_class_sequence *sequence_class) +{ +} diff --git a/formats/ctf/types/struct.c b/formats/ctf/types/struct.c index 729c456e..f99cc539 100644 --- a/formats/ctf/types/struct.c +++ b/formats/ctf/types/struct.c @@ -21,7 +21,6 @@ */ #include -#include void ctf_struct_begin(struct stream_pos *pos, const struct type_class_struct *struct_class) diff --git a/include/babeltrace/ctf/types.h b/include/babeltrace/ctf/types.h index 75b8bd3e..eee7d5df 100644 --- a/include/babeltrace/ctf/types.h +++ b/include/babeltrace/ctf/types.h @@ -76,5 +76,13 @@ void ctf_struct_begin(struct stream_pos *pos, const struct type_class_struct *struct_class); void ctf_struct_end(struct stream_pos *pos, const struct type_class_struct *struct_class); +void ctf_array_begin(struct stream_pos *pos, + const struct type_class_array *array_class); +void ctf_array_end(struct stream_pos *pos, + const struct type_class_array *array_class); +void ctf_sequence_begin(struct stream_pos *pos, + const struct type_class_sequence *sequence_class); +void ctf_sequence_end(struct stream_pos *pos, + const struct type_class_sequence *sequence_class); #endif /* _BABELTRACE_CTF_TYPES_H */ diff --git a/include/babeltrace/format.h b/include/babeltrace/format.h index bc2bdb06..9478dcf4 100644 --- a/include/babeltrace/format.h +++ b/include/babeltrace/format.h @@ -66,6 +66,14 @@ struct format { const struct type_class_struct *struct_class); void (*struct_end)(struct stream_pos *pos, const struct type_class_struct *struct_class); + void (*array_begin)(struct stream_pos *pos, + const struct type_class_array *array_class); + void (*array_end)(struct stream_pos *pos, + const struct type_class_array *array_class); + void (*sequence_begin)(struct stream_pos *pos, + const struct type_class_sequence *sequence_class); + void (*sequence_end)(struct stream_pos *pos, + const struct type_class_sequence *sequence_class); }; struct format *bt_lookup_format(GQuark qname); diff --git a/include/babeltrace/types.h b/include/babeltrace/types.h index ada6c6d1..cc1965a0 100644 --- a/include/babeltrace/types.h +++ b/include/babeltrace/types.h @@ -214,14 +214,22 @@ struct field * struct_type_get_field_from_index(struct type_class_struct *struct_class, unsigned long index); +/* + * elem_class passed as parameter now belongs to the array. No need to free it + * explicitely. + */ struct type_class_array *array_type_new(const char *name, size_t len, struct type_class *elem_class); void array_type_free(struct type_class_array *array_class); +/* + * int_class and elem_class passed as parameter now belongs to the sequence. No + * need to free them explicitely. + */ struct type_class_sequence *sequence_type_new(const char *name, struct type_class_integer *int_class, struct type_class *elem_class); -void array_type_free(struct type_class_array *array_class); +void sequence_type_free(struct type_class_sequence *sequence_class); #endif /* _BABELTRACE_TYPES_H */ diff --git a/types/array.c b/types/array.c new file mode 100644 index 00000000..153a38e6 --- /dev/null +++ b/types/array.c @@ -0,0 +1,82 @@ +/* + * BabelTrace - Array Type Converter + * + * Copyright (c) 2010 Mathieu Desnoyers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include +#include + +void array_copy(struct stream_pos *dest, const struct format *fdest, + struct stream_pos *src, const struct format *fsrc, + const struct type_class *type_class) +{ + struct type_class_array *array_class = + container_of(type_class, struct type_class_array, p); + unsigned int 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_class->elem; + elem_class->copy(dest, fdest, src, fsrc, &elem_class->p); + } + fsrc->array_end(src, array_class); + fdest->array_end(dest, array_class); +} + +void array_type_free(struct type_class_array *array_class) +{ + array_class->elem->free(&array_class->elem->p); + g_free(array_class); +} + +static void _array_type_free(struct type_class *type_class) +{ + struct type_class_struct *array_class = + container_of(type_class, struct type_class_array, p); + array_type_free(array_class); +} + +struct type_class_array *array_type_new(const char *name, size_t len, + struct type_class *elem) +{ + struct type_class_array *array_class; + int ret; + + array_class = g_new(struct type_class_array, 1); + type_class = &float_class->p; + + array_class->len = len; + 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->free = _array_type_free; + + if (type_class->name) { + ret = ctf_register_type(type_class); + if (ret) + goto error_register; + } + return array_class; + +error_register: + g_free(array_class); + return NULL; +} diff --git a/types/float.c b/types/float.c index 266f7579..56ca402c 100644 --- a/types/float.c +++ b/types/float.c @@ -40,6 +40,9 @@ void float_copy(struct stream_pos *dest, const struct format *fdest, void float_type_free(struct type_class_float *float_class) { + integer_type_free(float_class->exp); + integer_type_free(float_class->mantissa); + integer_type_free(float_class->sign); g_free(float_class); } diff --git a/types/struct.c b/types/struct.c index 8c1a5834..b1bedda8 100644 --- a/types/struct.c +++ b/types/struct.c @@ -37,7 +37,7 @@ void struct_copy(struct stream_pos *dest, const struct format *fdest, struct field, i); struct type_class *field_class = field->type_class; - field_class->copy(dest, fdest, src, fsrc, type_class); + field_class->copy(dest, fdest, src, fsrc, &field_class->p); } fsrc->struct_end(src, struct_class); -- 2.34.1