Fix: memory leak when using mapping iterator

[babeltrace.git] / formats / ctf / ir / fields.c

diff --git a/formats/ctf/ir/fields.c b/formats/ctf/ir/fields.c
index 2df961f4b61e90bf049247717bb267bb0eb5ec00..412b7fdef065cc3adf0cf80bd3d35f32a5d811bb 100644 (file)
--- a/formats/ctf/ir/fields.c
+++ b/formats/ctf/ir/fields.c
@@ -866,7 +866,7 @@ end:
        return container;
 }
 
-const char *bt_ctf_field_enumeration_get_mapping_name(
+const char *bt_ctf_field_enumeration_get_single_mapping_name(
        struct bt_ctf_field *field)
 {
        int ret;
@@ -874,7 +874,7 @@ const char *bt_ctf_field_enumeration_get_mapping_name(
        struct bt_ctf_field *container = NULL;
        struct bt_ctf_field_type *container_type = NULL;
        struct bt_ctf_field_type_integer *integer_type = NULL;
-       struct bt_ctf_field_type_enumeration *enumeration_type = NULL;
+       struct bt_ctf_field_type_enumeration_mapping_iterator *iter = NULL;
 
        container = bt_ctf_field_enumeration_get_container(field);
        if (!container) {
@@ -888,29 +888,37 @@ const char *bt_ctf_field_enumeration_get_mapping_name(
 
        integer_type = container_of(container_type,
                struct bt_ctf_field_type_integer, parent);
-       enumeration_type = container_of(field->type,
-               struct bt_ctf_field_type_enumeration, parent);
 
        if (!integer_type->declaration.signedness) {
                uint64_t value;
+
                ret = bt_ctf_field_unsigned_integer_get_value(container,
                      &value);
                if (ret) {
                        goto error_put_container_type;
                }
-
-               name = bt_ctf_field_type_enumeration_get_mapping_name_unsigned(
-                       enumeration_type, value);
+               iter = bt_ctf_field_type_enumeration_find_mappings_by_unsigned_value(
+                               field->type, value);
+               if (!iter) {
+                       goto error_put_container_type;
+               }
+               (void) bt_ctf_field_type_enumeration_mapping_iterator_get_unsigned(
+                               iter, &name, NULL, NULL);
        } else {
                int64_t value;
+
                ret = bt_ctf_field_signed_integer_get_value(container,
                      &value);
                if (ret) {
                        goto error_put_container_type;
                }
-
-               name = bt_ctf_field_type_enumeration_get_mapping_name_signed(
-                       enumeration_type, value);
+               iter = bt_ctf_field_type_enumeration_find_mappings_by_signed_value(
+                               field->type, value);
+               if (!iter) {
+                       goto error_put_container_type;
+               }
+               (void) bt_ctf_field_type_enumeration_mapping_iterator_get_signed(
+                               iter, &name, NULL, NULL);
        }
 
 error_put_container_type:
@@ -918,6 +926,7 @@ error_put_container_type:
 error_put_container:
        bt_put(container);
 end:
+       bt_put(iter);
        return name;
 }
 
@@ -1687,7 +1696,7 @@ int bt_ctf_field_array_validate(struct bt_ctf_field *field)
        for (i = 0; i < array->elements->len; i++) {
                ret = bt_ctf_field_validate(array->elements->pdata[i]);
                if (ret) {
-                       fprintf(stderr, "Failed to validate sequence field #%zu\n", i);
+                       fprintf(stderr, "Failed to validate array field #%zu\n", i);
                        goto end;
                }
        }
@@ -2523,7 +2532,7 @@ bool bt_ctf_field_array_is_set(struct bt_ctf_field *field)
 
        array = container_of(field, struct bt_ctf_field_array, parent);
        for (i = 0; i < array->elements->len; i++) {
-               is_set = bt_ctf_field_validate(array->elements->pdata[i]);
+               is_set = bt_ctf_field_is_set(array->elements->pdata[i]);
                if (!is_set) {
                        goto end;
                }