X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=plugins%2Flibctfcopytrace%2Fclock-fields.c;h=5d312a81125730c800d3d37163933d5f93baaf06;hb=f01de2aee1992a782fe57109c100d4a36b79ebf2;hp=86f4f28bdfdae82811fc423af98355b30454d443;hpb=b2f1f465086eb82ac6b1a57538b643fdced00ac5;p=babeltrace.git diff --git a/plugins/libctfcopytrace/clock-fields.c b/plugins/libctfcopytrace/clock-fields.c index 86f4f28b..5d312a81 100644 --- a/plugins/libctfcopytrace/clock-fields.c +++ b/plugins/libctfcopytrace/clock-fields.c @@ -26,6 +26,9 @@ * SOFTWARE. */ +#define BT_LOG_TAG "PLUGIN-CTFCOPYTRACE-LIB-CLOCK-FIELDS" +#include "logging.h" + #include #include #include @@ -89,27 +92,25 @@ static int update_header_clock_int_field_type(FILE *err, struct bt_ctf_field_type *type, struct bt_ctf_clock_class *writer_clock_class) { - struct bt_ctf_clock_class *clock; + struct bt_ctf_clock_class *clock = NULL; int ret; clock = bt_ctf_field_type_integer_get_mapped_clock_class(type); if (!clock) { return 0; } - bt_put(clock); + BT_PUT(clock); ret = bt_ctf_field_type_integer_set_size(type, 64); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE_STR("Failed to set integer size to 64."); goto end; } ret = bt_ctf_field_type_integer_set_mapped_clock_class(type, writer_clock_class); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE_STR("Failed to map integer to clock_class."); goto end; } @@ -124,23 +125,22 @@ int find_update_clock_fields(FILE *err, struct bt_ctf_field_type *type, int ret; switch (bt_ctf_field_type_get_type_id(type)) { - case BT_CTF_TYPE_ID_INTEGER: + case BT_CTF_FIELD_TYPE_ID_INTEGER: return update_header_clock_int_field_type(err, type, writer_clock_class); - case BT_CTF_TYPE_ID_STRUCT: + case BT_CTF_FIELD_TYPE_ID_STRUCT: return find_update_struct_clock_fields(err, type, writer_clock_class); - case BT_CTF_TYPE_ID_ARRAY: + case BT_CTF_FIELD_TYPE_ID_ARRAY: return find_update_array_clock_fields(err, type, writer_clock_class); - case BT_CTF_TYPE_ID_SEQUENCE: + case BT_CTF_FIELD_TYPE_ID_SEQUENCE: return find_update_sequence_clock_fields(err, type, writer_clock_class); - case BT_CTF_TYPE_ID_UNTAGGED_VARIANT: - case BT_CTF_TYPE_ID_VARIANT: + case BT_CTF_FIELD_TYPE_ID_VARIANT: return find_update_variant_clock_fields(err, type, writer_clock_class); - case BT_CTF_TYPE_ID_ENUM: + case BT_CTF_FIELD_TYPE_ID_ENUM: return find_update_enum_clock_fields(err, type, writer_clock_class); break; @@ -158,34 +158,35 @@ int find_update_variant_clock_fields(FILE *err, struct bt_ctf_field_type *type, struct bt_ctf_clock_class *writer_clock_class) { int count, i, ret; + struct bt_ctf_field_type *entry_type = NULL; count = bt_ctf_field_type_variant_get_field_count(type); for (i = 0; i < count; i++) { - struct bt_ctf_field_type *entry_type; const char *entry_name; ret = bt_ctf_field_type_variant_get_field(type, &entry_name, &entry_type, i); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); - ret = -1; - goto end; + BT_LOGE_STR("Failed to get variant field."); + goto error; } + ret = find_update_clock_fields(err, entry_type, writer_clock_class); - bt_put(entry_type); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); - ret = -1; - goto end; + BT_LOGE_STR("Failed to find clock fields."); + goto error; } + BT_PUT(entry_type); } ret = 0; + goto end; +error: + ret = -1; end: + bt_put(entry_type); return ret; } @@ -194,33 +195,33 @@ int find_update_struct_clock_fields(FILE *err, struct bt_ctf_field_type *type, struct bt_ctf_clock_class *writer_clock_class) { int count, i, ret; + struct bt_ctf_field_type *entry_type = NULL; count = bt_ctf_field_type_structure_get_field_count(type); for (i = 0; i < count; i++) { - struct bt_ctf_field_type *entry_type; const char *entry_name; ret = bt_ctf_field_type_structure_get_field(type, &entry_name, &entry_type, i); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); - ret = -1; - goto end; + BT_LOGE_STR("Failed to get struct field."); + goto error; } + ret = find_update_clock_fields(err, entry_type, writer_clock_class); - bt_put(entry_type); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); - ret = -1; - goto end; + BT_LOGE_STR("Failed to find clock fields."); + goto error; } + BT_PUT(entry_type); } ret = 0; + goto end; +error: + bt_put(entry_type); end: return ret; } @@ -230,20 +231,23 @@ int find_update_sequence_clock_fields(FILE *err, struct bt_ctf_field_type *type, struct bt_ctf_clock_class *writer_clock_class) { int ret; - struct bt_ctf_field_type *entry_type; + struct bt_ctf_field_type *entry_type = NULL; entry_type = bt_ctf_field_type_sequence_get_element_type(type); + assert(entry_type); + ret = find_update_clock_fields(err, entry_type, writer_clock_class); - bt_put(entry_type); + BT_PUT(entry_type); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); - ret = -1; - goto end; + BT_LOGE_STR("Failed to find clock fields."); + goto error; } ret = 0; + goto end; +error: + ret = -1; end: return ret; } @@ -252,21 +256,20 @@ static int find_update_array_clock_fields(FILE *err, struct bt_ctf_field_type *type, struct bt_ctf_clock_class *writer_clock_class) { - int ret; - struct bt_ctf_field_type *entry_type; + int ret = 0; + struct bt_ctf_field_type *entry_type = NULL; entry_type = bt_ctf_field_type_array_get_element_type(type); + assert(entry_type); + ret = find_update_clock_fields(err, entry_type, writer_clock_class); - bt_put(entry_type); + BT_PUT(entry_type); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to find clock fields."); ret = -1; goto end; } - ret = 0; - end: return ret; } @@ -276,20 +279,23 @@ int find_update_enum_clock_fields(FILE *err, struct bt_ctf_field_type *type, struct bt_ctf_clock_class *writer_clock_class) { int ret; - struct bt_ctf_field_type *entry_type; + struct bt_ctf_field_type *entry_type = NULL; entry_type = bt_ctf_field_type_enumeration_get_container_type(type); + assert(entry_type); + ret = find_update_clock_fields(err, entry_type, writer_clock_class); - bt_put(entry_type); + BT_PUT(entry_type); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); - ret = -1; - goto end; + BT_LOGE_STR("Failed to find clock fields."); + goto error; } ret = 0; + goto end; +error: + ret = -1; end: return ret; } @@ -300,42 +306,37 @@ struct bt_ctf_field_type *override_header_type(FILE *err, struct bt_ctf_trace *writer_trace) { struct bt_ctf_field_type *new_type = NULL; + struct bt_ctf_clock_class *writer_clock_class = NULL; int ret; - struct bt_ctf_clock_class *writer_clock_class; /* FIXME multi-clock? */ - writer_clock_class = bt_ctf_trace_get_clock_class(writer_trace, 0); - if (!writer_clock_class) { - fprintf(err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); - goto end; - } + writer_clock_class = bt_ctf_trace_get_clock_class_by_index(writer_trace, 0); + assert(writer_clock_class); new_type = bt_ctf_field_type_copy(type); if (!new_type) { - fprintf(err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); - goto end_put; + BT_LOGE_STR("Failed to copy field type."); + goto error; } - if (bt_ctf_field_type_get_type_id(new_type) != BT_CTF_TYPE_ID_STRUCT) { - fprintf(err, "[error] Unexpected header field type\n"); + if (bt_ctf_field_type_get_type_id(new_type) != BT_CTF_FIELD_TYPE_ID_STRUCT) { + BT_LOGE("Expected header field type to be struct: type=%d", + bt_ctf_field_type_get_type_id(new_type)); goto error; } ret = find_update_struct_clock_fields(err, new_type, writer_clock_class); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to find clock fields in struct."); goto error; } + BT_PUT(writer_clock_class); - goto end_put; + goto end; error: - BT_PUT(new_type); -end_put: bt_put(writer_clock_class); + BT_PUT(new_type); end: return new_type; } @@ -350,21 +351,22 @@ int copy_float_field(FILE *err, struct bt_ctf_field *field, ret = bt_ctf_field_floating_point_get_value(field, &value); if (ret) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto end; + BT_LOGE_STR("Failed to get value."); + goto error; } + ret = bt_ctf_field_floating_point_set_value(copy_field, value); if (ret) { ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to set floating point value."); goto end; } ret = 0; + goto end; +error: + ret = -1; end: return ret; } @@ -379,21 +381,22 @@ int copy_string_field(FILE *err, struct bt_ctf_field *field, value = bt_ctf_field_string_get_value(field); if (!value) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto end; + BT_LOGE_STR("Failed to get value."); + goto error; } + ret = bt_ctf_field_string_set_value(copy_field, value); if (ret) { ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to set string value."); goto end; } ret = 0; + goto end; +error: + ret = -1; end: return ret; } @@ -403,59 +406,51 @@ int copy_override_field(FILE *err, struct bt_ctf_event *event, struct bt_ctf_event *writer_event, struct bt_ctf_field *field, struct bt_ctf_field *copy_field) { - struct bt_ctf_field_type *type; - int ret; + struct bt_ctf_field_type *type = NULL; + int ret = 0; type = bt_ctf_field_get_type(field); - if (!type) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; - } + assert(type); switch (bt_ctf_field_type_get_type_id(type)) { - case BT_CTF_TYPE_ID_INTEGER: + case BT_CTF_FIELD_TYPE_ID_INTEGER: ret = copy_find_clock_int_field(err, event, writer_event, field, type, copy_field); break; - case BT_CTF_TYPE_ID_STRUCT: + case BT_CTF_FIELD_TYPE_ID_STRUCT: ret = copy_find_clock_struct_field(err, event, writer_event, field, type, copy_field); break; - case BT_CTF_TYPE_ID_FLOAT: + case BT_CTF_FIELD_TYPE_ID_FLOAT: ret = copy_float_field(err, field, type, copy_field); break; - case BT_CTF_TYPE_ID_ENUM: + case BT_CTF_FIELD_TYPE_ID_ENUM: ret = copy_find_clock_enum_field(err, event, writer_event, field, type, copy_field); break; - case BT_CTF_TYPE_ID_STRING: + case BT_CTF_FIELD_TYPE_ID_STRING: ret = copy_string_field(err, field, type, copy_field); break; - case BT_CTF_TYPE_ID_ARRAY: + case BT_CTF_FIELD_TYPE_ID_ARRAY: ret = copy_find_clock_array_field(err, event, writer_event, field, type, copy_field); break; - case BT_CTF_TYPE_ID_SEQUENCE: + case BT_CTF_FIELD_TYPE_ID_SEQUENCE: ret = copy_find_clock_sequence_field(err, event, writer_event, field, type, copy_field); break; - case BT_CTF_TYPE_ID_UNTAGGED_VARIANT: - case BT_CTF_TYPE_ID_VARIANT: + case BT_CTF_FIELD_TYPE_ID_VARIANT: ret = copy_find_clock_variant_field(err, event, writer_event, field, type, copy_field); break; /* No default, we want to catch missing field types. */ - case BT_CTF_TYPE_ID_UNKNOWN: + case BT_CTF_FIELD_TYPE_ID_UNKNOWN: case BT_CTF_NR_TYPE_IDS: break; } - ret = 0; - bt_put(type); + BT_PUT(type); -end: return ret; } @@ -465,38 +460,30 @@ int copy_find_clock_enum_field(FILE *err, struct bt_ctf_event *event, struct bt_ctf_field_type *type, struct bt_ctf_field *copy_field) { int ret; - struct bt_ctf_field *container, *copy_container; + struct bt_ctf_field *container = NULL, *copy_container = NULL; container = bt_ctf_field_enumeration_get_container(field); - if (!container) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; - } + assert(container); copy_container = bt_ctf_field_enumeration_get_container(copy_field); - if (!copy_container) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end_put_container; - } + assert(copy_container); ret = copy_override_field(err, event, writer_event, container, copy_container); if (ret) { ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end_put_copy_container; + BT_LOGE_STR("Failed to override enum field."); + goto error; } -end_put_copy_container: + ret = 0; + goto end; + +error: + ret = -1; +end: bt_put(copy_container); -end_put_container: bt_put(container); -end: return ret; } @@ -506,52 +493,37 @@ int copy_find_clock_variant_field(FILE *err, struct bt_ctf_event *event, struct bt_ctf_field_type *type, struct bt_ctf_field *copy_field) { int ret; - struct bt_ctf_field *tag; - struct bt_ctf_field *variant_field, *copy_variant_field; + struct bt_ctf_field *tag = NULL; + struct bt_ctf_field *variant_field = NULL, *copy_variant_field = NULL; tag = bt_ctf_field_variant_get_tag(field); - if (!tag) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; - } + assert(tag); variant_field = bt_ctf_field_variant_get_field(field, tag); if (!variant_field) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end_put_tag; + BT_LOGE_STR("Failed to get variant field."); + goto error; } copy_variant_field = bt_ctf_field_variant_get_field(copy_field, tag); - if (!copy_variant_field) { - bt_put(variant_field); - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end_put_variant_field; - } + assert(copy_variant_field); ret = copy_override_field(err, event, writer_event, variant_field, copy_variant_field); if (ret) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end_put_copy_variand_field; + BT_LOGE_STR("Failed to override variant field."); + goto error; } ret = 0; + goto end; -end_put_copy_variand_field: +error: + ret = -1; +end: bt_put(copy_variant_field); -end_put_variant_field: bt_put(variant_field); -end_put_tag: bt_put(tag); -end: return ret; } @@ -563,77 +535,53 @@ int copy_find_clock_sequence_field(FILE *err, { int ret; uint64_t i, count; - struct bt_ctf_field_type *entry_type; - struct bt_ctf_field *length_field; - - entry_type = bt_ctf_field_type_sequence_get_element_type(type); - if (!entry_type) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; - } + struct bt_ctf_field *length_field = NULL; + struct bt_ctf_field *entry_field = NULL, *entry_copy = NULL; length_field = bt_ctf_field_sequence_get_length(field); - if (!length_field) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; - } + assert(length_field); ret = bt_ctf_field_unsigned_integer_get_value(length_field, &count); if (ret) { - bt_put(length_field); - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; + BT_LOGE("Failed to get value."); + goto error; } ret = bt_ctf_field_sequence_set_length(copy_field, length_field); - bt_put(length_field); if (ret) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; + BT_LOGE_STR("Failed to set sequence length."); + goto error; } + BT_PUT(length_field); for (i = 0; i < count; i++) { - struct bt_ctf_field *entry_field, *entry_copy; - entry_field = bt_ctf_field_sequence_get_field(field, i); if (!entry_field) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; + BT_LOGE_STR("Failed to get sequence field."); + goto error; } entry_copy = bt_ctf_field_sequence_get_field(copy_field, i); - if (!entry_copy) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; - } + assert(entry_copy); ret = copy_override_field(err, event, writer_event, entry_field, entry_copy); - bt_put(entry_field); - bt_put(entry_copy); if (ret) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; + BT_LOGE_STR("Faield to override field in sequence."); + goto error; } + BT_PUT(entry_field); + BT_PUT(entry_copy); } - bt_put(entry_type); ret = 0; + goto end; +error: + bt_put(length_field); + bt_put(entry_field); + bt_put(entry_copy); + ret = -1; end: return ret; } @@ -645,49 +593,37 @@ int copy_find_clock_array_field(FILE *err, struct bt_ctf_field *copy_field) { int ret, count, i; - struct bt_ctf_field_type *entry_type; + struct bt_ctf_field *entry_field = NULL, *entry_copy = NULL; count = bt_ctf_field_type_array_get_length(type); - entry_type = bt_ctf_field_type_array_get_element_type(type); - if (!entry_type) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; - } for (i = 0; i < count; i++) { - struct bt_ctf_field *entry_field, *entry_copy; - entry_field = bt_ctf_field_array_get_field(field, i); if (!entry_field) { ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; + BT_LOGE_STR("Failed to get array field."); + goto error; } entry_copy = bt_ctf_field_array_get_field(copy_field, i); - if (!entry_copy) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; - } + assert(entry_copy); ret = copy_override_field(err, event, writer_event, entry_field, entry_copy); - bt_put(entry_field); - bt_put(entry_copy); if (ret) { ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; + BT_LOGE_STR("Failed to override field in array."); + goto error; } + BT_PUT(entry_field); + BT_PUT(entry_copy); } - bt_put(entry_type); ret = 0; + goto end; + +error: + bt_put(entry_field); + bt_put(entry_copy); end: return ret; @@ -700,59 +636,48 @@ int copy_find_clock_struct_field(FILE *err, struct bt_ctf_field *copy_field) { int count, i, ret; + struct bt_ctf_field_type *entry_type = NULL; + struct bt_ctf_field *entry_field = NULL, *entry_copy = NULL; count = bt_ctf_field_type_structure_get_field_count(type); for (i = 0; i < count; i++) { - struct bt_ctf_field_type *entry_type; - struct bt_ctf_field *entry_field; const char *entry_name; - struct bt_ctf_field *entry_copy; entry_field = bt_ctf_field_structure_get_field_by_index(field, i); if (!entry_field) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; + BT_LOGE_STR("Failed to get struct field."); + goto error; } ret = bt_ctf_field_type_structure_get_field(type, &entry_name, &entry_type, i); if (ret) { - bt_put(entry_field); - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); - goto end; + BT_LOGE_STR("Failed to get struct field."); + goto error; } entry_copy = bt_ctf_field_structure_get_field_by_index(copy_field, i); - if (!entry_copy) { - bt_put(entry_field); - bt_put(entry_type); - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; - } + assert(entry_copy); ret = copy_override_field(err, event, writer_event, entry_field, entry_copy); - - bt_put(entry_copy); - bt_put(entry_field); - bt_put(entry_type); if (ret) { - BT_PUT(entry_copy); - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; + BT_LOGE_STR("Failed to override field in struct."); + goto error; } + BT_PUT(entry_copy); + BT_PUT(entry_field); + BT_PUT(entry_type); } ret = 0; + goto end; +error: + bt_put(entry_type); + bt_put(entry_field); + bt_put(entry_copy); + ret = -1; end: return ret; } @@ -769,38 +694,36 @@ int set_int_value(FILE *err, struct bt_ctf_field *field, if (bt_ctf_field_type_integer_get_signed(type)) { ret = bt_ctf_field_signed_integer_get_value(field, &value); if (ret) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto end; + BT_LOGE("Failed to get value."); + goto error; } - printf(" - v(s) = %ld\n", value); + ret = bt_ctf_field_signed_integer_set_value(copy_field, value); if (ret) { ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to set signed integer value."); goto end; } } else { ret = bt_ctf_field_unsigned_integer_get_value(field, &uvalue); if (ret) { - ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto end; + BT_LOGE("Failed to get value."); + goto error; } + ret = bt_ctf_field_unsigned_integer_set_value(copy_field, uvalue); if (ret) { ret = -1; - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to set unsigned integer value."); goto end; } } ret = 0; + goto end; +error: + ret = -1; end: return ret; } @@ -808,50 +731,36 @@ end: struct bt_ctf_clock_class *stream_class_get_clock_class(FILE *err, struct bt_ctf_stream_class *stream_class) { - struct bt_ctf_trace *trace; + struct bt_ctf_trace *trace = NULL; struct bt_ctf_clock_class *clock_class = NULL; trace = bt_ctf_stream_class_get_trace(stream_class); - if (!trace) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; - } + assert(trace); /* FIXME multi-clock? */ - clock_class = bt_ctf_trace_get_clock_class(trace, 0); + clock_class = bt_ctf_trace_get_clock_class_by_index(trace, 0); bt_put(trace); -end: + return clock_class; } struct bt_ctf_clock_class *event_get_clock_class(FILE *err, struct bt_ctf_event *event) { - struct bt_ctf_event_class *event_class; - struct bt_ctf_stream_class *stream_class; + struct bt_ctf_event_class *event_class = NULL; + struct bt_ctf_stream_class *stream_class = NULL; struct bt_ctf_clock_class *clock_class = NULL; event_class = bt_ctf_event_get_class(event); - if (!event_class) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; - } + assert(event_class); stream_class = bt_ctf_event_class_get_stream_class(event_class); - if (!stream_class) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end_put_event_class; - } + BT_PUT(event_class); + assert(stream_class); clock_class = stream_class_get_clock_class(err, stream_class); bt_put(stream_class); -end_put_event_class: - bt_put(event_class); -end: return clock_class; } @@ -861,8 +770,8 @@ int copy_find_clock_int_field(FILE *err, struct bt_ctf_field *field, struct bt_ctf_field_type *type, struct bt_ctf_field *copy_field) { - struct bt_ctf_clock_class *clock_class, *writer_clock_class; - struct bt_ctf_clock_value *clock_value, *writer_clock_value; + struct bt_ctf_clock_class *clock_class = NULL, *writer_clock_class = NULL; + struct bt_ctf_clock_value *clock_value = NULL, *writer_clock_value = NULL; uint64_t value; int ret; @@ -872,53 +781,44 @@ int copy_find_clock_int_field(FILE *err, } clock_value = bt_ctf_event_get_clock_value(event, clock_class); - bt_put(clock_class); - if (!clock_value) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; - } + BT_PUT(clock_class); + assert(clock_value); ret = bt_ctf_clock_value_get_value(clock_value, &value); - bt_put(clock_value); + BT_PUT(clock_value); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; + BT_LOGE("Failed to get clock value."); + goto error; } ret = bt_ctf_field_unsigned_integer_set_value(copy_field, value); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; + BT_LOGE_STR("Failed to set unsigned integer value."); + goto error; } writer_clock_class = event_get_clock_class(err, writer_event); - if (!writer_clock_class) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; - } + assert(writer_clock_class); writer_clock_value = bt_ctf_clock_value_create(writer_clock_class, value); - bt_put(writer_clock_class); + BT_PUT(writer_clock_class); if (!writer_clock_value) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; + BT_LOGE_STR("Failed to create clock value."); + goto error; } ret = bt_ctf_event_set_clock_value(writer_event, writer_clock_value); - bt_put(writer_clock_value); + BT_PUT(writer_clock_value); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; + BT_LOGE_STR("Failed to set clock value."); + goto error; } ret = 0; + goto end; +error: + ret = -1; end: return ret; }